quicktype generated-output diff

Test case

test/inputs/schema/minmaxlength.schema

27 generated files · +394 −84

Mschema-cplusplusdefault / quicktype.hpp+12 −3

@@ -224,16 +224,19 @@ namespace quicktype {
      class TopLevel {
          public:
          TopLevel() :
 -            intersection_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, 4, 5, std::nullopt),
 +            empty_only_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, 0, std::nullopt),
 +            intersection_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, 4, 5, std::string("^[a-z]+$")),
              maxlength_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, 5, std::nullopt),
              minlength_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, 3, std::nullopt, std::nullopt),
              min_max_intersection_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, 3, 5, std::nullopt),
 -            minmaxlength_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, 3, 5, std::nullopt),
 -            union_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, 3, 6, std::nullopt)
 +            minmaxlength_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, 3, 5, std::string("^[a-z]+$")),
 +            union_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, 3, 6, std::string("^[a-z]+$"))
          {}
          virtual ~TopLevel() = default;
          private:
 +        std::string empty_only;
 +        ClassMemberConstraints empty_only_constraint;
          std::string intersection;
          ClassMemberConstraints intersection_constraint;
          InUnion in_union;
@@ -250,6 +253,10 @@ namespace quicktype {
          ClassMemberConstraints union_constraint;
          public:
 +        const std::string & get_empty_only() const { return empty_only; }
 +        std::string & get_mutable_empty_only() { return empty_only; }
 +        void set_empty_only(const std::string & value) { CheckConstraint("empty_only", empty_only_constraint, value); this->empty_only = value; }
++
          const std::string & get_intersection() const { return intersection; }
          std::string & get_mutable_intersection() { return intersection; }
          void set_intersection(const std::string & value) { CheckConstraint("intersection", intersection_constraint, value); this->intersection = value; }
@@ -297,6 +304,7 @@ struct adl_serializer<std::variant<double, std::string>> {
+ }
  namespace quicktype {
      inline void from_json(const json & j, TopLevel& x) {
 +        x.set_empty_only(j.at("emptyOnly").get<std::string>());
          x.set_intersection(j.at("intersection").get<std::string>());
          x.set_in_union(j.at("inUnion").get<InUnion>());
          x.set_maxlength(j.at("maxlength").get<std::string>());
@@ -309,6 +317,7 @@ namespace quicktype {
      inline void to_json(json & j, const TopLevel & x) {
          j = json::object();
 +        j["emptyOnly"] = x.get_empty_only();
          j["intersection"] = x.get_intersection();
          j["inUnion"] = x.get_in_union();
          j["maxlength"] = x.get_maxlength();

Mschema-csharp-recordsdefault / QuickType.cs+76 −16

@@ -25,34 +25,38 @@ namespace QuickType
      public partial record TopLevel
+     {
 +        [JsonProperty("emptyOnly", Required = Required.Always)]
 +        [JsonConverter(typeof(PurpleMinMaxLengthCheckConverter))]
 +        public string EmptyOnly { get; set; }
++
          [JsonProperty("intersection", Required = Required.Always)]
 -        [JsonConverter(typeof(FluffyMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(TentacledMinMaxLengthCheckConverter))]
          public string Intersection { get; set; }
          [JsonProperty("inUnion", Required = Required.Always)]
          public InUnion InUnion { get; set; }
          [JsonProperty("maxlength", Required = Required.Always)]
 -        [JsonConverter(typeof(TentacledMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(StickyMinMaxLengthCheckConverter))]
          public string Maxlength { get; set; }
          [JsonProperty("minlength", Required = Required.Always)]
 -        [JsonConverter(typeof(StickyMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(IndecentMinMaxLengthCheckConverter))]
          public string Minlength { get; set; }
          [JsonProperty("minMaxIntersection", Required = Required.Always)]
 -        [JsonConverter(typeof(PurpleMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(IndigoMinMaxLengthCheckConverter))]
          public string MinMaxIntersection { get; set; }
          [JsonProperty("minmaxlength", Required = Required.Always)]
 -        [JsonConverter(typeof(PurpleMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(FluffyMinMaxLengthCheckConverter))]
          public string Minmaxlength { get; set; }
          [JsonProperty("minMaxUnion", Required = Required.Always)]
          public string MinMaxUnion { get; set; }
          [JsonProperty("union", Required = Required.Always)]
 -        [JsonConverter(typeof(IndigoMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(HilariousMinMaxLengthCheckConverter))]
          public string Union { get; set; }
+     }
@@ -89,6 +93,34 @@ namespace QuickType
          };
+     }
 +    internal class PurpleMinMaxLengthCheckConverter : JsonConverter
 +    {
 +        public override bool CanConvert(Type t) => t == typeof(string);
++
 +        public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
 +        {
 +            var value = serializer.Deserialize<string>(reader);
 +            if (value.Length <= 0)
 +            {
 +                return value;
 +            }
 +            throw new Exception("Cannot unmarshal type string");
 +        }
++
 +        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
 +        {
 +            var value = (string)untypedValue;
 +            if (value.Length <= 0)
 +            {
 +                serializer.Serialize(writer, value);
 +                return;
 +            }
 +            throw new Exception("Cannot marshal type string");
 +        }
++
 +        public static readonly PurpleMinMaxLengthCheckConverter Singleton = new PurpleMinMaxLengthCheckConverter();
 +    }
++
      internal class InUnionConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(InUnion) || t == typeof(InUnion?);
@@ -135,7 +167,7 @@ namespace QuickType
          public static readonly InUnionConverter Singleton = new InUnionConverter();
+     }
 -    internal class PurpleMinMaxLengthCheckConverter : JsonConverter
 +    internal class FluffyMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -160,10 +192,10 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly PurpleMinMaxLengthCheckConverter Singleton = new PurpleMinMaxLengthCheckConverter();
 +        public static readonly FluffyMinMaxLengthCheckConverter Singleton = new FluffyMinMaxLengthCheckConverter();
+     }
 -    internal class FluffyMinMaxLengthCheckConverter : JsonConverter
 +    internal class TentacledMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -188,10 +220,10 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly FluffyMinMaxLengthCheckConverter Singleton = new FluffyMinMaxLengthCheckConverter();
 +        public static readonly TentacledMinMaxLengthCheckConverter Singleton = new TentacledMinMaxLengthCheckConverter();
+     }
 -    internal class TentacledMinMaxLengthCheckConverter : JsonConverter
 +    internal class StickyMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -216,10 +248,38 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly TentacledMinMaxLengthCheckConverter Singleton = new TentacledMinMaxLengthCheckConverter();
 +        public static readonly StickyMinMaxLengthCheckConverter Singleton = new StickyMinMaxLengthCheckConverter();
+     }
 -    internal class StickyMinMaxLengthCheckConverter : JsonConverter
 +    internal class IndigoMinMaxLengthCheckConverter : JsonConverter
 +    {
 +        public override bool CanConvert(Type t) => t == typeof(string);
++
 +        public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
 +        {
 +            var value = serializer.Deserialize<string>(reader);
 +            if (value.Length >= 3 && value.Length <= 5)
 +            {
 +                return value;
 +            }
 +            throw new Exception("Cannot unmarshal type string");
 +        }
++
 +        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
 +        {
 +            var value = (string)untypedValue;
 +            if (value.Length >= 3 && value.Length <= 5)
 +            {
 +                serializer.Serialize(writer, value);
 +                return;
 +            }
 +            throw new Exception("Cannot marshal type string");
 +        }
++
 +        public static readonly IndigoMinMaxLengthCheckConverter Singleton = new IndigoMinMaxLengthCheckConverter();
 +    }
++
 +    internal class IndecentMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -244,10 +304,10 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly StickyMinMaxLengthCheckConverter Singleton = new StickyMinMaxLengthCheckConverter();
 +        public static readonly IndecentMinMaxLengthCheckConverter Singleton = new IndecentMinMaxLengthCheckConverter();
+     }
 -    internal class IndigoMinMaxLengthCheckConverter : JsonConverter
 +    internal class HilariousMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -272,7 +332,7 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly IndigoMinMaxLengthCheckConverter Singleton = new IndigoMinMaxLengthCheckConverter();
 +        public static readonly HilariousMinMaxLengthCheckConverter Singleton = new HilariousMinMaxLengthCheckConverter();
+     }
+ }
  #pragma warning restore CS8618

Mschema-csharp-SystemTextJsondefault / QuickType.cs+75 −16

@@ -22,9 +22,14 @@ namespace QuickType
      public partial class TopLevel
+     {
 +        [JsonRequired]
 +        [JsonPropertyName("emptyOnly")]
 +        [JsonConverter(typeof(PurpleMinMaxLengthCheckConverter))]
 +        public string EmptyOnly { get; set; }
++
          [JsonRequired]
          [JsonPropertyName("intersection")]
 -        [JsonConverter(typeof(FluffyMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(TentacledMinMaxLengthCheckConverter))]
          public string Intersection { get; set; }
          [JsonRequired]
@@ -33,22 +38,22 @@ namespace QuickType
          [JsonRequired]
          [JsonPropertyName("maxlength")]
 -        [JsonConverter(typeof(TentacledMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(StickyMinMaxLengthCheckConverter))]
          public string Maxlength { get; set; }
          [JsonRequired]
          [JsonPropertyName("minlength")]
 -        [JsonConverter(typeof(StickyMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(IndecentMinMaxLengthCheckConverter))]
          public string Minlength { get; set; }
          [JsonRequired]
          [JsonPropertyName("minMaxIntersection")]
 -        [JsonConverter(typeof(PurpleMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(IndigoMinMaxLengthCheckConverter))]
          public string MinMaxIntersection { get; set; }
          [JsonRequired]
          [JsonPropertyName("minmaxlength")]
 -        [JsonConverter(typeof(PurpleMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(FluffyMinMaxLengthCheckConverter))]
          public string Minmaxlength { get; set; }
          [JsonRequired]
@@ -57,7 +62,7 @@ namespace QuickType
          [JsonRequired]
          [JsonPropertyName("union")]
 -        [JsonConverter(typeof(IndigoMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(HilariousMinMaxLengthCheckConverter))]
          public string Union { get; set; }
+     }
@@ -94,6 +99,33 @@ namespace QuickType
          };
+     }
 +    internal class PurpleMinMaxLengthCheckConverter : JsonConverter<string>
 +    {
 +        public override bool CanConvert(Type t) => t == typeof(string);
++
 +        public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 +        {
 +            var value = reader.GetString();
 +            if (value.Length <= 0)
 +            {
 +                return value;
 +            }
 +            throw new JsonException("Cannot unmarshal type string");
 +        }
++
 +        public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
 +        {
 +            if (value.Length <= 0)
 +            {
 +                JsonSerializer.Serialize(writer, value, options);
 +                return;
 +            }
 +            throw new NotSupportedException("Cannot marshal type string");
 +        }
++
 +        public static readonly PurpleMinMaxLengthCheckConverter Singleton = new PurpleMinMaxLengthCheckConverter();
 +    }
++
      internal class InUnionConverter : JsonConverter<InUnion>
+     {
          public override bool CanConvert(Type t) => t == typeof(InUnion);
@@ -137,7 +169,7 @@ namespace QuickType
          public static readonly InUnionConverter Singleton = new InUnionConverter();
+     }
 -    internal class PurpleMinMaxLengthCheckConverter : JsonConverter<string>
 +    internal class FluffyMinMaxLengthCheckConverter : JsonConverter<string>
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -161,10 +193,10 @@ namespace QuickType
              throw new NotSupportedException("Cannot marshal type string");
+         }
 -        public static readonly PurpleMinMaxLengthCheckConverter Singleton = new PurpleMinMaxLengthCheckConverter();
 +        public static readonly FluffyMinMaxLengthCheckConverter Singleton = new FluffyMinMaxLengthCheckConverter();
+     }
 -    internal class FluffyMinMaxLengthCheckConverter : JsonConverter<string>
 +    internal class TentacledMinMaxLengthCheckConverter : JsonConverter<string>
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -188,10 +220,10 @@ namespace QuickType
              throw new NotSupportedException("Cannot marshal type string");
+         }
 -        public static readonly FluffyMinMaxLengthCheckConverter Singleton = new FluffyMinMaxLengthCheckConverter();
 +        public static readonly TentacledMinMaxLengthCheckConverter Singleton = new TentacledMinMaxLengthCheckConverter();
+     }
 -    internal class TentacledMinMaxLengthCheckConverter : JsonConverter<string>
 +    internal class StickyMinMaxLengthCheckConverter : JsonConverter<string>
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -215,10 +247,37 @@ namespace QuickType
              throw new NotSupportedException("Cannot marshal type string");
+         }
 -        public static readonly TentacledMinMaxLengthCheckConverter Singleton = new TentacledMinMaxLengthCheckConverter();
 +        public static readonly StickyMinMaxLengthCheckConverter Singleton = new StickyMinMaxLengthCheckConverter();
+     }
 -    internal class StickyMinMaxLengthCheckConverter : JsonConverter<string>
 +    internal class IndigoMinMaxLengthCheckConverter : JsonConverter<string>
 +    {
 +        public override bool CanConvert(Type t) => t == typeof(string);
++
 +        public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 +        {
 +            var value = reader.GetString();
 +            if (value.Length >= 3 && value.Length <= 5)
 +            {
 +                return value;
 +            }
 +            throw new JsonException("Cannot unmarshal type string");
 +        }
++
 +        public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
 +        {
 +            if (value.Length >= 3 && value.Length <= 5)
 +            {
 +                JsonSerializer.Serialize(writer, value, options);
 +                return;
 +            }
 +            throw new NotSupportedException("Cannot marshal type string");
 +        }
++
 +        public static readonly IndigoMinMaxLengthCheckConverter Singleton = new IndigoMinMaxLengthCheckConverter();
 +    }
++
 +    internal class IndecentMinMaxLengthCheckConverter : JsonConverter<string>
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -242,10 +301,10 @@ namespace QuickType
              throw new NotSupportedException("Cannot marshal type string");
+         }
 -        public static readonly StickyMinMaxLengthCheckConverter Singleton = new StickyMinMaxLengthCheckConverter();
 +        public static readonly IndecentMinMaxLengthCheckConverter Singleton = new IndecentMinMaxLengthCheckConverter();
+     }
 -    internal class IndigoMinMaxLengthCheckConverter : JsonConverter<string>
 +    internal class HilariousMinMaxLengthCheckConverter : JsonConverter<string>
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -269,7 +328,7 @@ namespace QuickType
              throw new NotSupportedException("Cannot marshal type string");
+         }
 -        public static readonly IndigoMinMaxLengthCheckConverter Singleton = new IndigoMinMaxLengthCheckConverter();
 +        public static readonly HilariousMinMaxLengthCheckConverter Singleton = new HilariousMinMaxLengthCheckConverter();
+     }
      public class DateOnlyConverter : JsonConverter<DateOnly>

Mschema-csharpdefault / QuickType.cs+76 −16

@@ -25,34 +25,38 @@ namespace QuickType
      public partial class TopLevel
+     {
 +        [JsonProperty("emptyOnly", Required = Required.Always)]
 +        [JsonConverter(typeof(PurpleMinMaxLengthCheckConverter))]
 +        public string EmptyOnly { get; set; }
++
          [JsonProperty("intersection", Required = Required.Always)]
 -        [JsonConverter(typeof(FluffyMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(TentacledMinMaxLengthCheckConverter))]
          public string Intersection { get; set; }
          [JsonProperty("inUnion", Required = Required.Always)]
          public InUnion InUnion { get; set; }
          [JsonProperty("maxlength", Required = Required.Always)]
 -        [JsonConverter(typeof(TentacledMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(StickyMinMaxLengthCheckConverter))]
          public string Maxlength { get; set; }
          [JsonProperty("minlength", Required = Required.Always)]
 -        [JsonConverter(typeof(StickyMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(IndecentMinMaxLengthCheckConverter))]
          public string Minlength { get; set; }
          [JsonProperty("minMaxIntersection", Required = Required.Always)]
 -        [JsonConverter(typeof(PurpleMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(IndigoMinMaxLengthCheckConverter))]
          public string MinMaxIntersection { get; set; }
          [JsonProperty("minmaxlength", Required = Required.Always)]
 -        [JsonConverter(typeof(PurpleMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(FluffyMinMaxLengthCheckConverter))]
          public string Minmaxlength { get; set; }
          [JsonProperty("minMaxUnion", Required = Required.Always)]
          public string MinMaxUnion { get; set; }
          [JsonProperty("union", Required = Required.Always)]
 -        [JsonConverter(typeof(IndigoMinMaxLengthCheckConverter))]
 +        [JsonConverter(typeof(HilariousMinMaxLengthCheckConverter))]
          public string Union { get; set; }
+     }
@@ -89,6 +93,34 @@ namespace QuickType
          };
+     }
 +    internal class PurpleMinMaxLengthCheckConverter : JsonConverter
 +    {
 +        public override bool CanConvert(Type t) => t == typeof(string);
++
 +        public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
 +        {
 +            var value = serializer.Deserialize<string>(reader);
 +            if (value.Length <= 0)
 +            {
 +                return value;
 +            }
 +            throw new Exception("Cannot unmarshal type string");
 +        }
++
 +        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
 +        {
 +            var value = (string)untypedValue;
 +            if (value.Length <= 0)
 +            {
 +                serializer.Serialize(writer, value);
 +                return;
 +            }
 +            throw new Exception("Cannot marshal type string");
 +        }
++
 +        public static readonly PurpleMinMaxLengthCheckConverter Singleton = new PurpleMinMaxLengthCheckConverter();
 +    }
++
      internal class InUnionConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(InUnion) || t == typeof(InUnion?);
@@ -135,7 +167,7 @@ namespace QuickType
          public static readonly InUnionConverter Singleton = new InUnionConverter();
+     }
 -    internal class PurpleMinMaxLengthCheckConverter : JsonConverter
 +    internal class FluffyMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -160,10 +192,10 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly PurpleMinMaxLengthCheckConverter Singleton = new PurpleMinMaxLengthCheckConverter();
 +        public static readonly FluffyMinMaxLengthCheckConverter Singleton = new FluffyMinMaxLengthCheckConverter();
+     }
 -    internal class FluffyMinMaxLengthCheckConverter : JsonConverter
 +    internal class TentacledMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -188,10 +220,10 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly FluffyMinMaxLengthCheckConverter Singleton = new FluffyMinMaxLengthCheckConverter();
 +        public static readonly TentacledMinMaxLengthCheckConverter Singleton = new TentacledMinMaxLengthCheckConverter();
+     }
 -    internal class TentacledMinMaxLengthCheckConverter : JsonConverter
 +    internal class StickyMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -216,10 +248,38 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly TentacledMinMaxLengthCheckConverter Singleton = new TentacledMinMaxLengthCheckConverter();
 +        public static readonly StickyMinMaxLengthCheckConverter Singleton = new StickyMinMaxLengthCheckConverter();
+     }
 -    internal class StickyMinMaxLengthCheckConverter : JsonConverter
 +    internal class IndigoMinMaxLengthCheckConverter : JsonConverter
 +    {
 +        public override bool CanConvert(Type t) => t == typeof(string);
++
 +        public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
 +        {
 +            var value = serializer.Deserialize<string>(reader);
 +            if (value.Length >= 3 && value.Length <= 5)
 +            {
 +                return value;
 +            }
 +            throw new Exception("Cannot unmarshal type string");
 +        }
++
 +        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
 +        {
 +            var value = (string)untypedValue;
 +            if (value.Length >= 3 && value.Length <= 5)
 +            {
 +                serializer.Serialize(writer, value);
 +                return;
 +            }
 +            throw new Exception("Cannot marshal type string");
 +        }
++
 +        public static readonly IndigoMinMaxLengthCheckConverter Singleton = new IndigoMinMaxLengthCheckConverter();
 +    }
++
 +    internal class IndecentMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -244,10 +304,10 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly StickyMinMaxLengthCheckConverter Singleton = new StickyMinMaxLengthCheckConverter();
 +        public static readonly IndecentMinMaxLengthCheckConverter Singleton = new IndecentMinMaxLengthCheckConverter();
+     }
 -    internal class IndigoMinMaxLengthCheckConverter : JsonConverter
 +    internal class HilariousMinMaxLengthCheckConverter : JsonConverter
+     {
          public override bool CanConvert(Type t) => t == typeof(string);
@@ -272,7 +332,7 @@ namespace QuickType
              throw new Exception("Cannot marshal type string");
+         }
 -        public static readonly IndigoMinMaxLengthCheckConverter Singleton = new IndigoMinMaxLengthCheckConverter();
 +        public static readonly HilariousMinMaxLengthCheckConverter Singleton = new HilariousMinMaxLengthCheckConverter();
+     }
+ }
  #pragma warning restore CS8618

Mschema-dartdefault / TopLevel.dart+4 −0

@@ -9,6 +9,7 @@ TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
  String topLevelToJson(TopLevel data) => json.encode(data.toJson());
  class TopLevel {
 +    final String emptyOnly;
      final String intersection;
      final dynamic inUnion;
      final String maxlength;
@@ -19,6 +20,7 @@ class TopLevel {
      final String union;
      TopLevel({
 +        required this.emptyOnly,
          required this.intersection,
          required this.inUnion,
          required this.maxlength,
@@ -30,6 +32,7 @@ class TopLevel {
      });
      factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
 +        emptyOnly: json["emptyOnly"],
          intersection: json["intersection"],
          inUnion: json["inUnion"],
          maxlength: json["maxlength"],
@@ -41,6 +44,7 @@ class TopLevel {
      );
      Map<String, dynamic> toJson() => {
 +        "emptyOnly": emptyOnly,
          "intersection": intersection,
          "inUnion": inUnion,
          "maxlength": maxlength,

Mschema-elixirdefault / QuickType.ex+5 −2

@@ -6,10 +6,11 @@
  # Encode into a JSON string: TopLevel.to_json(struct)
  defmodule TopLevel do
 -  @enforce_keys [:intersection, :in_union, :maxlength, :minlength, :min_max_intersection, :minmaxlength, :min_max_union, :union]
 -  defstruct [:intersection, :in_union, :maxlength, :minlength, :min_max_intersection, :minmaxlength, :min_max_union, :union]
 +  @enforce_keys [:empty_only, :intersection, :in_union, :maxlength, :minlength, :min_max_intersection, :minmaxlength, :min_max_union, :union]
 +  defstruct [:empty_only, :intersection, :in_union, :maxlength, :minlength, :min_max_intersection, :minmaxlength, :min_max_union, :union]
    @type t :: %__MODULE__{
 +          empty_only: String.t(),
            intersection: String.t(),
            in_union: float() | String.t(),
            maxlength: String.t(),
@@ -22,6 +23,7 @@ defmodule TopLevel do
    def from_map(m) do
      %TopLevel{
 +      empty_only: m["emptyOnly"],
        intersection: m["intersection"],
        in_union: m["inUnion"],
        maxlength: m["maxlength"],
@@ -41,6 +43,7 @@ defmodule TopLevel do
    def to_map(struct) do
      %{
 +      "emptyOnly" => struct.empty_only,
        "intersection" => struct.intersection,
        "inUnion" => struct.in_union,
        "maxlength" => struct.maxlength,

Mschema-elmdefault / QuickType.elm+5 −2

@@ -24,7 +24,8 @@ import Json.Encode as Jenc
  import Dict exposing (Dict)
  type alias QuickType =
 -    { intersection : String
 +    { emptyOnly : String
 +    , intersection : String
      , inUnion : InUnion
      , maxlength : String
      , minlength : String
@@ -46,6 +47,7 @@ quickTypeToString r = Jenc.encode 0 (encodeQuickType r)
  quickType : Jdec.Decoder QuickType
  quickType =
      Jdec.succeed QuickType
 +        |> Jpipe.required "emptyOnly" Jdec.string
          |> Jpipe.required "intersection" Jdec.string
          |> Jpipe.required "inUnion" inUnion
          |> Jpipe.required "maxlength" Jdec.string
@@ -58,7 +60,8 @@ quickType =
  encodeQuickType : QuickType -> Jenc.Value
  encodeQuickType x =
      Jenc.object
 -        [ ("intersection", Jenc.string x.intersection)
 +        [ ("emptyOnly", Jenc.string x.emptyOnly)
 +        , ("intersection", Jenc.string x.intersection)
          , ("inUnion", encodeInUnion x.inUnion)
          , ("maxlength", Jenc.string x.maxlength)
          , ("minlength", Jenc.string x.minlength)

Mschema-flowdefault / TopLevel.js+2 −0

@@ -10,6 +10,7 @@
  // match the expected interface, even if the JSON is valid.
  export type TopLevel = {
 +    emptyOnly:          string;
      intersection:       string;
      inUnion:            InUnion;
      maxlength:          string;
@@ -188,6 +189,7 @@ function r(name: string) {
  const typeMap: any = {
      "TopLevel": o([
 +        { json: "emptyOnly", js: "emptyOnly", typ: "" },
          { json: "intersection", js: "intersection", typ: "" },
          { json: "inUnion", js: "inUnion", typ: u(3.14, "") },
          { json: "maxlength", js: "maxlength", typ: "" },

Mschema-golangdefault / quicktype.go+1 −0

@@ -22,6 +22,7 @@ func (r *TopLevel) Marshal() ([]byte, error) {
+ }
  type TopLevel struct {
 +	EmptyOnly          string   `json:"emptyOnly"`
  	Intersection       string   `json:"intersection"`
  	InUnion            *InUnion `json:"inUnion"`
  	Maxlength          string   `json:"maxlength"`

Mschema-haskelldefault / QuickType.hs+7 −4

@@ -14,7 +14,8 @@ import Data.HashMap.Strict (HashMap)
  import Data.Text (Text)
  data QuickType = QuickType
 -    { intersectionQuickType :: Text
 +    { emptyOnlyQuickType :: Text
 +    , intersectionQuickType :: Text
      , inUnionQuickType :: InUnion
      , maxlengthQuickType :: Text
      , minlengthQuickType :: Text
@@ -33,9 +34,10 @@ decodeTopLevel :: ByteString -> Maybe QuickType
  decodeTopLevel = decode
  instance ToJSON QuickType where
 -    toJSON (QuickType intersectionQuickType inUnionQuickType maxlengthQuickType minlengthQuickType minMaxIntersectionQuickType minmaxlengthQuickType minMaxUnionQuickType unionQuickType) =
 +    toJSON (QuickType emptyOnlyQuickType intersectionQuickType inUnionQuickType maxlengthQuickType minlengthQuickType minMaxIntersectionQuickType minmaxlengthQuickType minMaxUnionQuickType unionQuickType) =
          object
 -        [ "intersection" .= intersectionQuickType
 +        [ "emptyOnly" .= emptyOnlyQuickType
 +        , "intersection" .= intersectionQuickType
          , "inUnion" .= inUnionQuickType
          , "maxlength" .= maxlengthQuickType
          , "minlength" .= minlengthQuickType
@@ -47,7 +49,8 @@ instance ToJSON QuickType where
  instance FromJSON QuickType where
      parseJSON (Object v) = QuickType
 -        <$> v .: "intersection"
 +        <$> v .: "emptyOnly"
 +        <*> v .: "intersection"
          <*> v .: "inUnion"
          <*> v .: "maxlength"
          <*> v .: "minlength"

Mschema-java-datetime-legacydefault / src / main / java / io / quicktype / TopLevel.java+6 −0

@@ -3,6 +3,7 @@ package io.quicktype;
  import com.fasterxml.jackson.annotation.*;
  public class TopLevel {
 +    private String emptyOnly;
      private String intersection;
      private InUnion inUnion;
      private String maxlength;
@@ -12,6 +13,11 @@ public class TopLevel {
      private String minMaxUnion;
      private String union;
 +    @JsonProperty("emptyOnly")
 +    public String getEmptyOnly() { return emptyOnly; }
 +    @JsonProperty("emptyOnly")
 +    public void setEmptyOnly(String value) { this.emptyOnly = value; }
++
      @JsonProperty("intersection")
      public String getIntersection() { return intersection; }
      @JsonProperty("intersection")

Mschema-java-lombokdefault / src / main / java / io / quicktype / TopLevel.java+6 −0

@@ -3,6 +3,7 @@ package io.quicktype;
  import com.fasterxml.jackson.annotation.*;
  public class TopLevel {
 +    private String emptyOnly;
      private String intersection;
      private InUnion inUnion;
      private String maxlength;
@@ -12,6 +13,11 @@ public class TopLevel {
      private String minMaxUnion;
      private String union;
 +    @JsonProperty("emptyOnly")
 +    public String getEmptyOnly() { return emptyOnly; }
 +    @JsonProperty("emptyOnly")
 +    public void setEmptyOnly(String value) { this.emptyOnly = value; }
++
      @JsonProperty("intersection")
      public String getIntersection() { return intersection; }
      @JsonProperty("intersection")

Mschema-javadefault / src / main / java / io / quicktype / TopLevel.java+6 −0

@@ -3,6 +3,7 @@ package io.quicktype;
  import com.fasterxml.jackson.annotation.*;
  public class TopLevel {
 +    private String emptyOnly;
      private String intersection;
      private InUnion inUnion;
      private String maxlength;
@@ -12,6 +13,11 @@ public class TopLevel {
      private String minMaxUnion;
      private String union;
 +    @JsonProperty("emptyOnly")
 +    public String getEmptyOnly() { return emptyOnly; }
 +    @JsonProperty("emptyOnly")
 +    public void setEmptyOnly(String value) { this.emptyOnly = value; }
++
      @JsonProperty("intersection")
      public String getIntersection() { return intersection; }
      @JsonProperty("intersection")

Mschema-javascriptdefault / TopLevel.js+1 −0

@@ -172,6 +172,7 @@ function r(name) {
  const typeMap = {
      "TopLevel": o([
 +        { json: "emptyOnly", js: "emptyOnly", typ: "" },
          { json: "intersection", js: "intersection", typ: "" },
          { json: "inUnion", js: "inUnion", typ: u(3.14, "") },
          { json: "maxlength", js: "maxlength", typ: "" },

Mschema-kotlin-jacksondefault / TopLevel.kt+3 −0

@@ -31,6 +31,9 @@ val mapper = jacksonObjectMapper().apply {
+ }
  data class TopLevel (
 +    @get:JsonProperty(required=true)@field:JsonProperty(required=true)
 +    val emptyOnly: String,
++
      @get:JsonProperty(required=true)@field:JsonProperty(required=true)
      val intersection: String,

Mschema-kotlindefault / TopLevel.kt+1 −0

@@ -18,6 +18,7 @@ private val klaxon = Klaxon()
      .convert(InUnion::class, { InUnion.fromJson(it) }, { it.toJson() }, true)
  data class TopLevel (
 +    val emptyOnly: String,
      val intersection: String,
      val inUnion: InUnion,
      val maxlength: String,

Mschema-phpdefault / TopLevel.php+66 −12

@@ -4,6 +4,7 @@ declare(strict_types=1);
  // This is an autogenerated file:TopLevel
  class TopLevel {
 +    private string $emptyOnly; // json:emptyOnly Required
      private string $intersection; // json:intersection Required
      private float|string $inUnion; // json:inUnion Required
      private string $maxlength; // json:maxlength Required
@@ -14,6 +15,7 @@ class TopLevel {
      private string $union; // json:union Required
      /**
 +     * @param string $emptyOnly
       * @param string $intersection
       * @param float|string $inUnion
       * @param string $maxlength
@@ -23,7 +25,8 @@ class TopLevel {
       * @param string $minMaxUnion
       * @param string $union
       */
 -    public function __construct(string $intersection, float|string $inUnion, string $maxlength, string $minlength, string $minMaxIntersection, string $minmaxlength, string $minMaxUnion, string $union) {
 +    public function __construct(string $emptyOnly, string $intersection, float|string $inUnion, string $maxlength, string $minlength, string $minMaxIntersection, string $minmaxlength, string $minMaxUnion, string $union) {
 +        $this->emptyOnly = $emptyOnly;
          $this->intersection = $intersection;
          $this->inUnion = $inUnion;
          $this->maxlength = $maxlength;
@@ -34,6 +37,53 @@ class TopLevel {
          $this->union = $union;
+     }
 +    /**
 +     * @param string $value
 +     * @throws Exception
 +     * @return string
 +     */
 +    public static function fromEmptyOnly(string $value): string {
 +        return $value; /*string*/
 +    }
++
 +    /**
 +     * @throws Exception
 +     * @return string
 +     */
 +    public function toEmptyOnly(): string {
 +        if (TopLevel::validateEmptyOnly($this->emptyOnly))  {
 +            return $this->emptyOnly; /*string*/
 +        }
 +        throw new Exception('never get to this TopLevel::emptyOnly');
 +    }
++
 +    /**
 +     * @param string
 +     * @return bool
 +     * @throws Exception
 +     */
 +    public static function validateEmptyOnly(string $value): bool {
 +        return true;
 +    }
++
 +    /**
 +     * @throws Exception
 +     * @return string
 +     */
 +    public function getEmptyOnly(): string {
 +        if (TopLevel::validateEmptyOnly($this->emptyOnly))  {
 +            return $this->emptyOnly;
 +        }
 +        throw new Exception('never get to getEmptyOnly TopLevel::emptyOnly');
 +    }
++
 +    /**
 +     * @return string
 +     */
 +    public static function sampleEmptyOnly(): string {
 +        return 'TopLevel::emptyOnly::31'; /*31:emptyOnly*/
 +    }
++
      /**
       * @param string $value
       * @throws Exception
@@ -78,7 +128,7 @@ class TopLevel {
       * @return string
       */
      public static function sampleIntersection(): string {
 -        return 'TopLevel::intersection::31'; /*31:intersection*/
 +        return 'TopLevel::intersection::32'; /*32:intersection*/
+     }
      /**
@@ -148,7 +198,7 @@ class TopLevel {
       * @return float|string
       */
      public static function sampleInUnion(): float|string {
 -        return 32.032; /*32:inUnion*/
 +        return 33.033; /*33:inUnion*/
+     }
      /**
@@ -195,7 +245,7 @@ class TopLevel {
       * @return string
       */
      public static function sampleMaxlength(): string {
 -        return 'TopLevel::maxlength::33'; /*33:maxlength*/
 +        return 'TopLevel::maxlength::34'; /*34:maxlength*/
+     }
      /**
@@ -242,7 +292,7 @@ class TopLevel {
       * @return string
       */
      public static function sampleMinlength(): string {
 -        return 'TopLevel::minlength::34'; /*34:minlength*/
 +        return 'TopLevel::minlength::35'; /*35:minlength*/
+     }
      /**
@@ -289,7 +339,7 @@ class TopLevel {
       * @return string
       */
      public static function sampleMinMaxIntersection(): string {
 -        return 'TopLevel::minMaxIntersection::35'; /*35:minMaxIntersection*/
 +        return 'TopLevel::minMaxIntersection::36'; /*36:minMaxIntersection*/
+     }
      /**
@@ -336,7 +386,7 @@ class TopLevel {
       * @return string
       */
      public static function sampleMinmaxlength(): string {
 -        return 'TopLevel::minmaxlength::36'; /*36:minmaxlength*/
 +        return 'TopLevel::minmaxlength::37'; /*37:minmaxlength*/
+     }
      /**
@@ -383,7 +433,7 @@ class TopLevel {
       * @return string
       */
      public static function sampleMinMaxUnion(): string {
 -        return 'TopLevel::minMaxUnion::37'; /*37:minMaxUnion*/
 +        return 'TopLevel::minMaxUnion::38'; /*38:minMaxUnion*/
+     }
      /**
@@ -430,7 +480,7 @@ class TopLevel {
       * @return string
       */
      public static function sampleUnion(): string {
 -        return 'TopLevel::union::38'; /*38:union*/
 +        return 'TopLevel::union::39'; /*39:union*/
+     }
      /**
@@ -438,7 +488,8 @@ class TopLevel {
       * @return bool
       */
      public function validate(): bool {
 -        return TopLevel::validateIntersection($this->intersection)
 +        return TopLevel::validateEmptyOnly($this->emptyOnly)
 +        || TopLevel::validateIntersection($this->intersection)
          || TopLevel::validateInUnion($this->inUnion)
          || TopLevel::validateMaxlength($this->maxlength)
          || TopLevel::validateMinlength($this->minlength)
@@ -454,6 +505,7 @@ class TopLevel {
       */
      public function to(): stdClass  {
          $out = new stdClass();
 +        $out->{'emptyOnly'} = $this->toEmptyOnly();
          $out->{'intersection'} = $this->toIntersection();
          $out->{'inUnion'} = $this->toInUnion();
          $out->{'maxlength'} = $this->toMaxlength();
@@ -472,7 +524,8 @@ class TopLevel {
       */
      public static function from(stdClass $obj): TopLevel {
          return new TopLevel(
 -         TopLevel::fromIntersection($obj->{'intersection'})
 +         TopLevel::fromEmptyOnly($obj->{'emptyOnly'})
 +        ,TopLevel::fromIntersection($obj->{'intersection'})
          ,TopLevel::fromInUnion($obj->{'inUnion'})
          ,TopLevel::fromMaxlength($obj->{'maxlength'})
          ,TopLevel::fromMinlength($obj->{'minlength'})
@@ -488,7 +541,8 @@ class TopLevel {
       */
      public static function sample(): TopLevel {
          return new TopLevel(
 -         TopLevel::sampleIntersection()
 +         TopLevel::sampleEmptyOnly()
 +        ,TopLevel::sampleIntersection()
          ,TopLevel::sampleInUnion()
          ,TopLevel::sampleMaxlength()
          ,TopLevel::sampleMinlength()

Mschema-pikedefault / TopLevel.pmod+3 −0

@@ -13,6 +13,7 @@
  // match the expected interface, even if the JSON itself is valid.
  class TopLevel {
 +    string  empty_only;           // json: "emptyOnly"
      string  intersection;         // json: "intersection"
      InUnion in_union;             // json: "inUnion"
      string  maxlength;            // json: "maxlength"
@@ -24,6 +25,7 @@ class TopLevel {
      string encode_json() {
          mapping(string:mixed) json = ([
 +            "emptyOnly" : empty_only,
              "intersection" : intersection,
              "inUnion" : in_union,
              "maxlength" : maxlength,
@@ -41,6 +43,7 @@ class TopLevel {
  TopLevel TopLevel_from_JSON(mixed json) {
      TopLevel retval = TopLevel();
 +    retval.empty_only = json["emptyOnly"];
      retval.intersection = json["intersection"];
      retval.in_union = json["inUnion"];
      retval.maxlength = json["maxlength"];

Mschema-pythondefault / quicktype.py+4 −1

@@ -36,6 +36,7 @@ def to_class(c: Type[T], x: Any) -> dict:
  @dataclass
  class TopLevel:
 +    empty_only: str
      intersection: str
      in_union: float | str
      maxlength: str
@@ -48,6 +49,7 @@ class TopLevel:
      @staticmethod
      def from_dict(obj: Any) -> 'TopLevel':
          assert isinstance(obj, dict)
 +        empty_only = from_str(obj.get("emptyOnly"))
          intersection = from_str(obj.get("intersection"))
          in_union = from_union([from_float, from_str], obj.get("inUnion"))
          maxlength = from_str(obj.get("maxlength"))
@@ -56,10 +58,11 @@ class TopLevel:
          minmaxlength = from_str(obj.get("minmaxlength"))
          min_max_union = from_str(obj.get("minMaxUnion"))
          union = from_str(obj.get("union"))
 -        return TopLevel(intersection, in_union, maxlength, minlength, min_max_intersection, minmaxlength, min_max_union, union)
 +        return TopLevel(empty_only, intersection, in_union, maxlength, minlength, min_max_intersection, minmaxlength, min_max_union, union)
      def to_dict(self) -> dict:
          result: dict = {}
 +        result["emptyOnly"] = from_str(self.empty_only)
          result["intersection"] = from_str(self.intersection)
          result["inUnion"] = from_union([to_float, from_str], self.in_union)
          result["maxlength"] = from_str(self.maxlength)

Mschema-rubydefault / TopLevel.rb+4 −1

@@ -4,7 +4,7 @@
  # To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:
+ #
  #   top_level = TopLevel.from_json! "{…}"
 -#   puts top_level.intersection
 +#   puts top_level.empty_only
+ #
  # If from_json! succeeds, the value returned matches the schema.
@@ -52,6 +52,7 @@ class InUnion < Dry::Struct
  end
  class TopLevel < Dry::Struct
 +  attribute :empty_only,           Types::String
    attribute :intersection,         Types::String
    attribute :in_union,             Types.Instance(InUnion)
    attribute :maxlength,            Types::String
@@ -64,6 +65,7 @@ class TopLevel < Dry::Struct
    def self.from_dynamic!(d)
      d = Types::Hash[d]
      new(
 +      empty_only:           d.fetch("emptyOnly"),
        intersection:         d.fetch("intersection"),
        in_union:             InUnion.from_dynamic!(d.fetch("inUnion")),
        maxlength:            d.fetch("maxlength"),
@@ -81,6 +83,7 @@ class TopLevel < Dry::Struct
    def to_dynamic
+     {
 +      "emptyOnly"          => empty_only,
        "intersection"       => intersection,
        "inUnion"            => in_union.to_dynamic,
        "maxlength"          => maxlength,

Mschema-rustdefault / module_under_test.rs+2 −0

@@ -16,6 +16,8 @@ use serde::{Serialize, Deserialize};
  #[derive(Debug, Clone, Serialize, Deserialize)]
  #[serde(rename_all = "camelCase")]
  pub struct TopLevel {
 +    pub empty_only: String,
++
      pub intersection: String,
      pub in_union: InUnion,

Mschema-scala3-upickledefault / TopLevel.scala+1 −0

@@ -66,6 +66,7 @@ end JsonExt
  case class TopLevel (
 +    val emptyOnly : String,
      val intersection : String,
      val inUnion : InUnion,
      val maxlength : String,

Mschema-scala3default / TopLevel.scala+1 −0

@@ -8,6 +8,7 @@ import cats.syntax.functor._
  type NullValue = None.type
  case class TopLevel (
 +    val emptyOnly : String,
      val intersection : String,
      val inUnion : InUnion,
      val maxlength : String,

Mschema-schemadefault / TopLevel.schema+13 −4

@@ -6,10 +6,15 @@
              "type": "object",
              "additionalProperties": {},
              "properties": {
 +                "emptyOnly": {
 +                    "type": "string",
 +                    "maxLength": 0
 +                },
                  "intersection": {
                      "type": "string",
                      "minLength": 4,
 -                    "maxLength": 5
 +                    "maxLength": 5,
 +                    "pattern": "^[a-z]+$"
                  },
                  "inUnion": {
                      "$ref": "#/definitions/InUnion"
@@ -30,7 +35,8 @@
                  "minmaxlength": {
                      "type": "string",
                      "minLength": 3,
 -                    "maxLength": 5
 +                    "maxLength": 5,
 +                    "pattern": "^[a-z]+$"
                  },
                  "minMaxUnion": {
                      "type": "string"
@@ -38,10 +44,12 @@
                  "union": {
                      "type": "string",
                      "minLength": 3,
 -                    "maxLength": 6
 +                    "maxLength": 6,
 +                    "pattern": "^[a-z]+$"
+                 }
              },
              "required": [
 +                "emptyOnly",
                  "inUnion",
                  "intersection",
                  "maxlength",
@@ -61,7 +69,8 @@
+                 {
                      "type": "string",
                      "minLength": 3,
 -                    "maxLength": 5
 +                    "maxLength": 5,
 +                    "pattern": "^[a-z]+$"
+                 }
              ],
              "title": "InUnion"

Mschema-swiftdefault / quicktype.swift+4 −0

@@ -7,6 +7,7 @@ import Foundation
  // MARK: - TopLevel
  struct TopLevel: Codable {
 +    let emptyOnly: String
      let intersection: String
      let inUnion: InUnion
      let maxlength: String
@@ -17,6 +18,7 @@ struct TopLevel: Codable {
      let union: String
      enum CodingKeys: String, CodingKey {
 +        case emptyOnly = "emptyOnly"
          case intersection = "intersection"
          case inUnion = "inUnion"
          case maxlength = "maxlength"
@@ -47,6 +49,7 @@ extension TopLevel {
+     }
      func with(
 +        emptyOnly: String? = nil,
          intersection: String? = nil,
          inUnion: InUnion? = nil,
          maxlength: String? = nil,
@@ -57,6 +60,7 @@ extension TopLevel {
          union: String? = nil
      ) -> TopLevel {
          return TopLevel(
 +            emptyOnly: emptyOnly ?? self.emptyOnly,
              intersection: intersection ?? self.intersection,
              inUnion: inUnion ?? self.inUnion,
              maxlength: maxlength ?? self.maxlength,

Mschema-typescript-zoddefault / TopLevel.ts+8 −7

@@ -2,13 +2,14 @@ import * as z from "zod";
  export const TopLevelSchema = z.object({
 -    "intersection": z.string(),
 -    "inUnion": z.union([z.number(), z.string()]),
 -    "maxlength": z.string(),
 -    "minlength": z.string(),
 -    "minMaxIntersection": z.string(),
 -    "minmaxlength": z.string(),
 +    "emptyOnly": z.string().max(0),
 +    "intersection": z.string().min(4).max(5).regex(new RegExp("^[a-z]+$")),
 +    "inUnion": z.union([z.number(), z.string().min(3).max(5).regex(new RegExp("^[a-z]+$"))]),
 +    "maxlength": z.string().max(5),
 +    "minlength": z.string().min(3),
 +    "minMaxIntersection": z.string().min(3).max(5),
 +    "minmaxlength": z.string().min(3).max(5).regex(new RegExp("^[a-z]+$")),
      "minMaxUnion": z.string(),
 -    "union": z.string(),
 +    "union": z.string().min(3).max(6).regex(new RegExp("^[a-z]+$")),
  });
  export type TopLevel = z.infer<typeof TopLevelSchema>;

Mschema-typescriptdefault / TopLevel.ts+2 −0

@@ -8,6 +8,7 @@
  // match the expected interface, even if the JSON is valid.
  export interface TopLevel {
 +    emptyOnly:          string;
      intersection:       string;
      inUnion:            InUnion;
      maxlength:          string;
@@ -188,6 +189,7 @@ function r(name: string) {
  const typeMap: any = {
      "TopLevel": o([
 +        { json: "emptyOnly", js: "emptyOnly", typ: "" },
          { json: "intersection", js: "intersection", typ: "" },
          { json: "inUnion", js: "inUnion", typ: u(3.14, "") },
          { json: "maxlength", js: "maxlength", typ: "" },

Test case

test/inputs/schema/optional-const-ref.schema

1 generated file · +2 −2

Mschema-typescript-zoddefault / TopLevel.ts+2 −2

@@ -10,10 +10,10 @@ export type Coordinate = z.infer<typeof CoordinateSchema>;
  export const TopLevelSchema = z.object({
      "coordinates": z.array(CoordinateSchema).optional(),
      "count": z.number().optional(),
 -    "label": z.string().optional(),
 +    "label": z.string().min(2).max(16).optional(),
      "requiredCoordinates": z.array(CoordinateSchema),
      "requiredCount": z.number(),
 -    "requiredLabel": z.string(),
 +    "requiredLabel": z.string().min(2).max(16),
      "weight": z.number().optional(),
  });
  export type TopLevel = z.infer<typeof TopLevelSchema>;

Test case

test/inputs/schema/optional-constraints.schema

1 generated file · +2 −2

Mschema-typescript-zoddefault / TopLevel.ts+2 −2

@@ -4,8 +4,8 @@ import * as z from "zod";
  export const TopLevelSchema = z.object({
      "optDouble": z.number().optional(),
      "optInt": z.number().optional(),
 -    "optPattern": z.string().optional(),
 -    "optString": z.string().optional(),
 +    "optPattern": z.string().regex(new RegExp("^[a-z]+$")).optional(),
 +    "optString": z.string().min(3).max(10).optional(),
      "reqZeroMin": z.number(),
  });
  export type TopLevel = z.infer<typeof TopLevelSchema>;

Test case

test/inputs/schema/pattern.schema

28 generated files · +158 −20

Mschema-cplusplusdefault / quicktype.hpp+9 −0

@@ -165,6 +165,7 @@ namespace quicktype {
      class TopLevel {
          public:
          TopLevel() :
 +            escaped_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::string("^\\d+\\.[a-z]+$")),
              pattern1_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::string("a[.]*")),
              pattern2_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::string("b[.]*")),
              union_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::string("(b[.]*)|(c[.]*)"))
@@ -172,6 +173,8 @@ namespace quicktype {
          virtual ~TopLevel() = default;
          private:
 +        std::string escaped;
 +        ClassMemberConstraints escaped_constraint;
          std::string pattern1;
          ClassMemberConstraints pattern1_constraint;
          std::string pattern2;
@@ -180,6 +183,10 @@ namespace quicktype {
          ClassMemberConstraints union_constraint;
          public:
 +        const std::string & get_escaped() const { return escaped; }
 +        std::string & get_mutable_escaped() { return escaped; }
 +        void set_escaped(const std::string & value) { CheckConstraint("escaped", escaped_constraint, value); this->escaped = value; }
++
          const std::string & get_pattern1() const { return pattern1; }
          std::string & get_mutable_pattern1() { return pattern1; }
          void set_pattern1(const std::string & value) { CheckConstraint("pattern1", pattern1_constraint, value); this->pattern1 = value; }
@@ -199,6 +206,7 @@ namespace quicktype {
      void to_json(json & j, const TopLevel & x);
      inline void from_json(const json & j, TopLevel& x) {
 +        x.set_escaped(j.at("escaped").get<std::string>());
          x.set_pattern1(j.at("pattern1").get<std::string>());
          x.set_pattern2(j.at("pattern2").get<std::string>());
          x.set_top_level_union(j.at("union").get<std::string>());
@@ -206,6 +214,7 @@ namespace quicktype {
      inline void to_json(json & j, const TopLevel & x) {
          j = json::object();
 +        j["escaped"] = x.get_escaped();
          j["pattern1"] = x.get_pattern1();
          j["pattern2"] = x.get_pattern2();
          j["union"] = x.get_top_level_union();

Mschema-csharp-recordsdefault / QuickType.cs+3 −0

@@ -25,6 +25,9 @@ namespace QuickType
      public partial record TopLevel
+     {
 +        [JsonProperty("escaped", Required = Required.Always)]
 +        public string Escaped { get; set; }
++
          [JsonProperty("pattern1", Required = Required.Always)]
          public string Pattern1 { get; set; }

Mschema-csharp-SystemTextJsondefault / QuickType.cs+4 −0

@@ -22,6 +22,10 @@ namespace QuickType
      public partial class TopLevel
+     {
 +        [JsonRequired]
 +        [JsonPropertyName("escaped")]
 +        public string Escaped { get; set; }
++
          [JsonRequired]
          [JsonPropertyName("pattern1")]
          public string Pattern1 { get; set; }

Mschema-csharpdefault / QuickType.cs+3 −0

@@ -25,6 +25,9 @@ namespace QuickType
      public partial class TopLevel
+     {
 +        [JsonProperty("escaped", Required = Required.Always)]
 +        public string Escaped { get; set; }
++
          [JsonProperty("pattern1", Required = Required.Always)]
          public string Pattern1 { get; set; }

Mschema-dartdefault / TopLevel.dart+4 −0

@@ -9,23 +9,27 @@ TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
  String topLevelToJson(TopLevel data) => json.encode(data.toJson());
  class TopLevel {
 +    final String escaped;
      final String pattern1;
      final String pattern2;
      final String union;
      TopLevel({
 +        required this.escaped,
          required this.pattern1,
          required this.pattern2,
          required this.union,
      });
      factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
 +        escaped: json["escaped"],
          pattern1: json["pattern1"],
          pattern2: json["pattern2"],
          union: json["union"],
      );
      Map<String, dynamic> toJson() => {
 +        "escaped": escaped,
          "pattern1": pattern1,
          "pattern2": pattern2,
          "union": union,

Mschema-elixirdefault / QuickType.ex+5 −2

@@ -6,10 +6,11 @@
  # Encode into a JSON string: TopLevel.to_json(struct)
  defmodule TopLevel do
 -  @enforce_keys [:pattern1, :pattern2, :union]
 -  defstruct [:pattern1, :pattern2, :union]
 +  @enforce_keys [:escaped, :pattern1, :pattern2, :union]
 +  defstruct [:escaped, :pattern1, :pattern2, :union]
    @type t :: %__MODULE__{
 +          escaped: String.t(),
            pattern1: String.t(),
            pattern2: String.t(),
            union: String.t()
@@ -17,6 +18,7 @@ defmodule TopLevel do
    def from_map(m) do
      %TopLevel{
 +      escaped: m["escaped"],
        pattern1: m["pattern1"],
        pattern2: m["pattern2"],
        union: m["union"],
@@ -31,6 +33,7 @@ defmodule TopLevel do
    def to_map(struct) do
      %{
 +      "escaped" => struct.escaped,
        "pattern1" => struct.pattern1,
        "pattern2" => struct.pattern2,
        "union" => struct.union,

Mschema-elmdefault / QuickType.elm+5 −2

@@ -23,7 +23,8 @@ import Json.Encode as Jenc
  import Dict exposing (Dict)
  type alias QuickType =
 -    { pattern1 : String
 +    { escaped : String
 +    , pattern1 : String
      , pattern2 : String
      , union : String
+     }
@@ -36,6 +37,7 @@ quickTypeToString r = Jenc.encode 0 (encodeQuickType r)
  quickType : Jdec.Decoder QuickType
  quickType =
      Jdec.succeed QuickType
 +        |> Jpipe.required "escaped" Jdec.string
          |> Jpipe.required "pattern1" Jdec.string
          |> Jpipe.required "pattern2" Jdec.string
          |> Jpipe.required "union" Jdec.string
@@ -43,7 +45,8 @@ quickType =
  encodeQuickType : QuickType -> Jenc.Value
  encodeQuickType x =
      Jenc.object
 -        [ ("pattern1", Jenc.string x.pattern1)
 +        [ ("escaped", Jenc.string x.escaped)
 +        , ("pattern1", Jenc.string x.pattern1)
          , ("pattern2", Jenc.string x.pattern2)
          , ("union", Jenc.string x.union)
+         ]

Mschema-flowdefault / TopLevel.js+2 −0

@@ -10,6 +10,7 @@
  // match the expected interface, even if the JSON is valid.
  export type TopLevel = {
 +    escaped:  string;
      pattern1: string;
      pattern2: string;
      union:    string;
@@ -181,6 +182,7 @@ function r(name: string) {
  const typeMap: any = {
      "TopLevel": o([
 +        { json: "escaped", js: "escaped", typ: "" },
          { json: "pattern1", js: "pattern1", typ: "" },
          { json: "pattern2", js: "pattern2", typ: "" },
          { json: "union", js: "union", typ: "" },

Mschema-golangdefault / quicktype.go+1 −0

@@ -19,6 +19,7 @@ func (r *TopLevel) Marshal() ([]byte, error) {
+ }
  type TopLevel struct {
 +	Escaped  string `json:"escaped"`
  	Pattern1 string `json:"pattern1"`
  	Pattern2 string `json:"pattern2"`
  	Union    string `json:"union"`

Mschema-haskelldefault / QuickType.hs+7 −4

@@ -13,7 +13,8 @@ import Data.HashMap.Strict (HashMap)
  import Data.Text (Text)
  data QuickType = QuickType
 -    { pattern1QuickType :: Text
 +    { escapedQuickType :: Text
 +    , pattern1QuickType :: Text
      , pattern2QuickType :: Text
      , unionQuickType :: Text
      } deriving (Show)
@@ -22,15 +23,17 @@ decodeTopLevel :: ByteString -> Maybe QuickType
  decodeTopLevel = decode
  instance ToJSON QuickType where
 -    toJSON (QuickType pattern1QuickType pattern2QuickType unionQuickType) =
 +    toJSON (QuickType escapedQuickType pattern1QuickType pattern2QuickType unionQuickType) =
          object
 -        [ "pattern1" .= pattern1QuickType
 +        [ "escaped" .= escapedQuickType
 +        , "pattern1" .= pattern1QuickType
          , "pattern2" .= pattern2QuickType
          , "union" .= unionQuickType
+         ]
  instance FromJSON QuickType where
      parseJSON (Object v) = QuickType
 -        <$> v .: "pattern1"
 +        <$> v .: "escaped"
 +        <*> v .: "pattern1"
          <*> v .: "pattern2"
          <*> v .: "union"

Mschema-java-datetime-legacydefault / src / main / java / io / quicktype / TopLevel.java+6 −0

@@ -3,10 +3,16 @@ package io.quicktype;
  import com.fasterxml.jackson.annotation.*;
  public class TopLevel {
 +    private String escaped;
      private String pattern1;
      private String pattern2;
      private String union;
 +    @JsonProperty("escaped")
 +    public String getEscaped() { return escaped; }
 +    @JsonProperty("escaped")
 +    public void setEscaped(String value) { this.escaped = value; }
++
      @JsonProperty("pattern1")
      public String getPattern1() { return pattern1; }
      @JsonProperty("pattern1")

Mschema-java-lombokdefault / src / main / java / io / quicktype / TopLevel.java+6 −0

@@ -3,10 +3,16 @@ package io.quicktype;
  import com.fasterxml.jackson.annotation.*;
  public class TopLevel {
 +    private String escaped;
      private String pattern1;
      private String pattern2;
      private String union;
 +    @JsonProperty("escaped")
 +    public String getEscaped() { return escaped; }
 +    @JsonProperty("escaped")
 +    public void setEscaped(String value) { this.escaped = value; }
++
      @JsonProperty("pattern1")
      public String getPattern1() { return pattern1; }
      @JsonProperty("pattern1")

Mschema-javadefault / src / main / java / io / quicktype / TopLevel.java+6 −0

@@ -3,10 +3,16 @@ package io.quicktype;
  import com.fasterxml.jackson.annotation.*;
  public class TopLevel {
 +    private String escaped;
      private String pattern1;
      private String pattern2;
      private String union;
 +    @JsonProperty("escaped")
 +    public String getEscaped() { return escaped; }
 +    @JsonProperty("escaped")
 +    public void setEscaped(String value) { this.escaped = value; }
++
      @JsonProperty("pattern1")
      public String getPattern1() { return pattern1; }
      @JsonProperty("pattern1")

Mschema-javascriptdefault / TopLevel.js+1 −0

@@ -172,6 +172,7 @@ function r(name) {
  const typeMap = {
      "TopLevel": o([
 +        { json: "escaped", js: "escaped", typ: "" },
          { json: "pattern1", js: "pattern1", typ: "" },
          { json: "pattern2", js: "pattern2", typ: "" },
          { json: "union", js: "union", typ: "" },

Mschema-kotlin-jacksondefault / TopLevel.kt+3 −0

@@ -19,6 +19,9 @@ val mapper = jacksonObjectMapper().apply {
+ }
  data class TopLevel (
 +    @get:JsonProperty(required=true)@field:JsonProperty(required=true)
 +    val escaped: String,
++
      @get:JsonProperty(required=true)@field:JsonProperty(required=true)
      val pattern1: String,

Mschema-kotlindefault / TopLevel.kt+1 −0

@@ -9,6 +9,7 @@ import com.beust.klaxon.*
  private val klaxon = Klaxon()
  data class TopLevel (
 +    val escaped: String,
      val pattern1: String,
      val pattern2: String,
      val union: String

Mschema-kotlinxdefault / TopLevel.kt+1 −0

@@ -12,6 +12,7 @@ import kotlinx.serialization.encoding.*
  @Serializable
  data class TopLevel (
 +    val escaped: String,
      val pattern1: String,
      val pattern2: String,
      val union: String

Mschema-phpdefault / TopLevel.php+61 −7

@@ -4,21 +4,71 @@ declare(strict_types=1);
  // This is an autogenerated file:TopLevel
  class TopLevel {
 +    private string $escaped; // json:escaped Required
      private string $pattern1; // json:pattern1 Required
      private string $pattern2; // json:pattern2 Required
      private string $union; // json:union Required
      /**
 +     * @param string $escaped
       * @param string $pattern1
       * @param string $pattern2
       * @param string $union
       */
 -    public function __construct(string $pattern1, string $pattern2, string $union) {
 +    public function __construct(string $escaped, string $pattern1, string $pattern2, string $union) {
 +        $this->escaped = $escaped;
          $this->pattern1 = $pattern1;
          $this->pattern2 = $pattern2;
          $this->union = $union;
+     }
 +    /**
 +     * @param string $value
 +     * @throws Exception
 +     * @return string
 +     */
 +    public static function fromEscaped(string $value): string {
 +        return $value; /*string*/
 +    }
++
 +    /**
 +     * @throws Exception
 +     * @return string
 +     */
 +    public function toEscaped(): string {
 +        if (TopLevel::validateEscaped($this->escaped))  {
 +            return $this->escaped; /*string*/
 +        }
 +        throw new Exception('never get to this TopLevel::escaped');
 +    }
++
 +    /**
 +     * @param string
 +     * @return bool
 +     * @throws Exception
 +     */
 +    public static function validateEscaped(string $value): bool {
 +        return true;
 +    }
++
 +    /**
 +     * @throws Exception
 +     * @return string
 +     */
 +    public function getEscaped(): string {
 +        if (TopLevel::validateEscaped($this->escaped))  {
 +            return $this->escaped;
 +        }
 +        throw new Exception('never get to getEscaped TopLevel::escaped');
 +    }
++
 +    /**
 +     * @return string
 +     */
 +    public static function sampleEscaped(): string {
 +        return 'TopLevel::escaped::31'; /*31:escaped*/
 +    }
++
      /**
       * @param string $value
       * @throws Exception
@@ -63,7 +113,7 @@ class TopLevel {
       * @return string
       */
      public static function samplePattern1(): string {
 -        return 'TopLevel::pattern1::31'; /*31:pattern1*/
 +        return 'TopLevel::pattern1::32'; /*32:pattern1*/
+     }
      /**
@@ -110,7 +160,7 @@ class TopLevel {
       * @return string
       */
      public static function samplePattern2(): string {
 -        return 'TopLevel::pattern2::32'; /*32:pattern2*/
 +        return 'TopLevel::pattern2::33'; /*33:pattern2*/
+     }
      /**
@@ -157,7 +207,7 @@ class TopLevel {
       * @return string
       */
      public static function sampleUnion(): string {
 -        return 'TopLevel::union::33'; /*33:union*/
 +        return 'TopLevel::union::34'; /*34:union*/
+     }
      /**
@@ -165,7 +215,8 @@ class TopLevel {
       * @return bool
       */
      public function validate(): bool {
 -        return TopLevel::validatePattern1($this->pattern1)
 +        return TopLevel::validateEscaped($this->escaped)
 +        || TopLevel::validatePattern1($this->pattern1)
          || TopLevel::validatePattern2($this->pattern2)
          || TopLevel::validateUnion($this->union);
+     }
@@ -176,6 +227,7 @@ class TopLevel {
       */
      public function to(): stdClass  {
          $out = new stdClass();
 +        $out->{'escaped'} = $this->toEscaped();
          $out->{'pattern1'} = $this->toPattern1();
          $out->{'pattern2'} = $this->toPattern2();
          $out->{'union'} = $this->toUnion();
@@ -189,7 +241,8 @@ class TopLevel {
       */
      public static function from(stdClass $obj): TopLevel {
          return new TopLevel(
 -         TopLevel::fromPattern1($obj->{'pattern1'})
 +         TopLevel::fromEscaped($obj->{'escaped'})
 +        ,TopLevel::fromPattern1($obj->{'pattern1'})
          ,TopLevel::fromPattern2($obj->{'pattern2'})
          ,TopLevel::fromUnion($obj->{'union'})
          );
@@ -200,7 +253,8 @@ class TopLevel {
       */
      public static function sample(): TopLevel {
          return new TopLevel(
 -         TopLevel::samplePattern1()
 +         TopLevel::sampleEscaped()
 +        ,TopLevel::samplePattern1()
          ,TopLevel::samplePattern2()
          ,TopLevel::sampleUnion()
          );

Mschema-pikedefault / TopLevel.pmod+3 −0

@@ -13,12 +13,14 @@
  // match the expected interface, even if the JSON itself is valid.
  class TopLevel {
 +    string escaped;  // json: "escaped"
      string pattern1; // json: "pattern1"
      string pattern2; // json: "pattern2"
      string union;    // json: "union"
      string encode_json() {
          mapping(string:mixed) json = ([
 +            "escaped" : escaped,
              "pattern1" : pattern1,
              "pattern2" : pattern2,
              "union" : union,
@@ -31,6 +33,7 @@ class TopLevel {
  TopLevel TopLevel_from_JSON(mixed json) {
      TopLevel retval = TopLevel();
 +    retval.escaped = json["escaped"];
      retval.pattern1 = json["pattern1"];
      retval.pattern2 = json["pattern2"];
      retval.union = json["union"];

Mschema-pythondefault / quicktype.py+4 −1

@@ -17,6 +17,7 @@ def to_class(c: Type[T], x: Any) -> dict:
  @dataclass
  class TopLevel:
 +    escaped: str
      pattern1: str
      pattern2: str
      union: str
@@ -24,13 +25,15 @@ class TopLevel:
      @staticmethod
      def from_dict(obj: Any) -> 'TopLevel':
          assert isinstance(obj, dict)
 +        escaped = from_str(obj.get("escaped"))
          pattern1 = from_str(obj.get("pattern1"))
          pattern2 = from_str(obj.get("pattern2"))
          union = from_str(obj.get("union"))
 -        return TopLevel(pattern1, pattern2, union)
 +        return TopLevel(escaped, pattern1, pattern2, union)
      def to_dict(self) -> dict:
          result: dict = {}
 +        result["escaped"] = from_str(self.escaped)
          result["pattern1"] = from_str(self.pattern1)
          result["pattern2"] = from_str(self.pattern2)
          result["union"] = from_str(self.union)

Mschema-rubydefault / TopLevel.rb+4 −1

@@ -4,7 +4,7 @@
  # To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:
+ #
  #   top_level = TopLevel.from_json! "{…}"
 -#   puts top_level.pattern1
 +#   puts top_level.escaped
+ #
  # If from_json! succeeds, the value returned matches the schema.
@@ -20,6 +20,7 @@ module Types
  end
  class TopLevel < Dry::Struct
 +  attribute :escaped,  Types::String
    attribute :pattern1, Types::String
    attribute :pattern2, Types::String
    attribute :union,    Types::String
@@ -27,6 +28,7 @@ class TopLevel < Dry::Struct
    def self.from_dynamic!(d)
      d = Types::Hash[d]
      new(
 +      escaped:  d.fetch("escaped"),
        pattern1: d.fetch("pattern1"),
        pattern2: d.fetch("pattern2"),
        union:    d.fetch("union"),
@@ -39,6 +41,7 @@ class TopLevel < Dry::Struct
    def to_dynamic
+     {
 +      "escaped"  => escaped,
        "pattern1" => pattern1,
        "pattern2" => pattern2,
        "union"    => union,

Mschema-rustdefault / module_under_test.rs+2 −0

@@ -15,6 +15,8 @@ use serde::{Serialize, Deserialize};
  #[derive(Debug, Clone, Serialize, Deserialize)]
  pub struct TopLevel {
 +    pub escaped: String,
++
      pub pattern1: String,
      pub pattern2: String,

Mschema-scala3-upickledefault / TopLevel.scala+1 −0

@@ -66,6 +66,7 @@ end JsonExt
  case class TopLevel (
 +    val escaped : String,
      val pattern1 : String,
      val pattern2 : String,
      val union : String

Mschema-scala3default / TopLevel.scala+1 −0

@@ -8,6 +8,7 @@ import cats.syntax.functor._
  type NullValue = None.type
  case class TopLevel (
 +    val escaped : String,
      val pattern1 : String,
      val pattern2 : String,
      val union : String

Mschema-schemadefault / TopLevel.schema+5 −0

@@ -6,6 +6,10 @@
              "type": "object",
              "additionalProperties": {},
              "properties": {
 +                "escaped": {
 +                    "type": "string",
 +                    "pattern": "^\\d+\\.[a-z]+$"
 +                },
                  "pattern1": {
                      "type": "string",
                      "pattern": "a[.]*"
@@ -20,6 +24,7 @@
+                 }
              },
              "required": [
 +                "escaped",
                  "pattern1",
                  "pattern2",
                  "union"

Mschema-swiftdefault / quicktype.swift+4 −0

@@ -7,11 +7,13 @@ import Foundation
  // MARK: - TopLevel
  struct TopLevel: Codable {
 +    let escaped: String
      let pattern1: String
      let pattern2: String
      let union: String
      enum CodingKeys: String, CodingKey {
 +        case escaped = "escaped"
          case pattern1 = "pattern1"
          case pattern2 = "pattern2"
          case union = "union"
@@ -37,11 +39,13 @@ extension TopLevel {
+     }
      func with(
 +        escaped: String? = nil,
          pattern1: String? = nil,
          pattern2: String? = nil,
          union: String? = nil
      ) -> TopLevel {
          return TopLevel(
 +            escaped: escaped ?? self.escaped,
              pattern1: pattern1 ?? self.pattern1,
              pattern2: pattern2 ?? self.pattern2,
              union: union ?? self.union

Mschema-typescript-zoddefault / TopLevel.ts+4 −3

@@ -2,8 +2,9 @@ import * as z from "zod";
  export const TopLevelSchema = z.object({
 -    "pattern1": z.string(),
 -    "pattern2": z.string(),
 -    "union": z.string(),
 +    "escaped": z.string().regex(new RegExp("^\\d+\\.[a-z]+$")),
 +    "pattern1": z.string().regex(new RegExp("a[.]*")),
 +    "pattern2": z.string().regex(new RegExp("b[.]*")),
 +    "union": z.string().regex(new RegExp("(b[.]*)|(c[.]*)")),
  });
  export type TopLevel = z.infer<typeof TopLevelSchema>;

Mschema-typescriptdefault / TopLevel.ts+2 −0

@@ -8,6 +8,7 @@
  // match the expected interface, even if the JSON is valid.
  export interface TopLevel {
 +    escaped:  string;
      pattern1: string;
      pattern2: string;
      union:    string;
@@ -181,6 +182,7 @@ function r(name: string) {
  const typeMap: any = {
      "TopLevel": o([
 +        { json: "escaped", js: "escaped", typ: "" },
          { json: "pattern1", js: "pattern1", typ: "" },
          { json: "pattern2", js: "pattern2", typ: "" },
          { json: "union", js: "union", typ: "" },

Test case

test/inputs/schema/renaming-bug.schema

1 generated file · +3 −3

Mschema-typescript-zoddefault / TopLevel.ts+3 −3

@@ -78,7 +78,7 @@ export type Geometry = z.infer<typeof GeometrySchema>;
  export const VehicleSchema = z.object({
      "brand": z.string().optional(),
 -    "id": z.string().optional(),
 +    "id": z.string().min(1).optional(),
      "speed": SpeedSchema.optional(),
      "subModule": z.boolean().optional(),
      "type": VehicleTypeSchema.optional(),
@@ -94,7 +94,7 @@ export type Shape = z.infer<typeof ShapeSchema>;
  export const BerrySchema = z.object({
      "color": ColorSchema.optional(),
 -    "name": z.string().optional(),
 +    "name": z.string().min(1).optional(),
      "shapes": z.array(ShapeSchema).optional(),
  });
  export type Berry = z.infer<typeof BerrySchema>;
@@ -107,7 +107,7 @@ export const FruitSchema = z.object({
  export type Fruit = z.infer<typeof FruitSchema>;
  export const TopLevelSchema = z.object({
 -    "version": z.string().optional(),
 +    "version": z.string().regex(new RegExp("^\\d{1,5}.{1}\\d{1,5}.{1}\\d{1,5}$")).optional(),
      "fruits": z.array(FruitSchema).optional(),
      "vehicles": z.array(VehicleSchema).optional(),
  });

Test case

test/inputs/schema/schema-constraints.schema

1 generated file · +1 −1

Mschema-typescript-zoddefault / TopLevel.ts+1 −1

@@ -2,7 +2,7 @@ import * as z from "zod";
  export const TopLevelSchema = z.object({
 -    "minMaxLength": z.string(),
 +    "minMaxLength": z.string().min(5).max(5),
      "percent": z.number(),
  });
  export type TopLevel = z.infer<typeof TopLevelSchema>;

No generated files match these filters.