quicktype throws ' quicktype cannot infer this type because there is no data about it in the input.'

[retiredracer]

A bit of noob here with JSON and schema (I grew up in the XML realm....).

I have two very simple JSON schema files - address.json and person.json (attached).

Here's the 'quicktype' cmd:

c:\programs\quicktype\quicktype ^
--debug=print-schema-resolving ^
--src-lang schema --lang cpp ^
--namespace myapp ^
--type-style pascal-case ^
--member-style camel-case ^
--enum-type enum-class ^
--include-location global-include ^
--source-style multi-source ^
-o output/models.hpp ^
person.json address.json

At the end of the quicktype run, it throws the following message:

Issue in line 18: quicktype cannot infer this type because there is no data about it in the input.
18: using Address = nlohmann::json;

this is in the 'output/models.hpp' file - the only real line of code in that file.

1. is this a problem? the code compiles and works. Although the real 'Address' class is named 'HomeAddressClass', which is weird...
2. The Interwebs provide a solution to this (to the 'address.json' file). I've also attached a copy of that as 'address.fix.json'.

In the end I have a good-sized pile of JSON schema files, they all follow the pattern of the original 'address.json' file.

What to do? thanks!

address.json
person.json
address.fix.json

[retiredracer]

Ok, figgered this out. There's a longer story here about updating/refreshing existing applications and those applications currently use XML with XSD schema defs and they're being updated to use JSON and JSON schema defs, blah, blah, blah.

I started on this project with a big pile of already generated JSON schema files and attempted to create C++ and Java classes from them for the application upgrade. QuickType had some problems with that pile of JSON schema files so I started from scratch (from the XSD schema files and created my own JSON schema files).

I'll post samples of what I produced and how I invoke QuickType, but first some notes:

1. In the JSON schema files, the 'title' attribute is your friend. Use it everywhere.
2. I have a number of 'top level' structures so I created a 'scheamDocument.json' (schema) file and just reference those within that document and have QuickType start with that 'schemaDocument'. With this pattern, a single 'Generators.hpp' is created with all of the serialization/deserialization methods for all of the true types. In the end, the C++ and Java code will never use the 'schemaDocument' class.
3. Non-sentient developers (you know, Claude) are your friends.

Here's my 'schemaDocument.json', which just references the real top level structures.

{
  "$id": "schemaDocument.json",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "schemaDocument",
  "description": "Root document schema wrapping a bunch of true top-level structures.",
  "type": "object",
  "properties": {
    "topLevelType1":   { "$ref": "topLevelType1.json#" }
  },
  "additionalProperties": false
}

'topLevelType1.json':

{
  "$id": "topLevelType1.json",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "description": "Definition of a top level type 1",
  "title": "topLevelType1",
  "$defs": {

    "defType1": {
      "title": "defType1",
      "description": "Defined type 1",
      "type": "object",
      "properties": {
        "x":      { "type": "integer" },
        "y":      { "type": "integer" }
      },
      "required": ["x", "y"],
      "additionalProperties": false
    }
  },

  "type": "object",
  "properties": {
    "name":              { "type": "string" },
    "prop2":             { "type": "string" },
    "location":          { "$ref": "#/$defs/defType1" }
  },
  "required": ["name", "prop2", "location"],
  "additionalProperties": false
}

quickType invocation (using CMake):

get_filename_component(C2_SCHEMA_DIR
  "${CMAKE_CURRENT_SOURCE_DIR}/../../resource/json"
  ABSOLUTE
)

# Note: plain GLOB is evaluated at configure time, so adding a new schema file
# requires re-running cmake before it's picked up.
file(GLOB JSON_SCHEMA_SOURCES ${C2_SCHEMA_DIR}/*.json)

add_custom_command(
  OUTPUT ${GENERATED_SCHEMA_HEADERS}
  COMMAND ${CMAKE_COMMAND} -E make_directory ${GENERATED_SCHEMA_INC_DIR}
  COMMAND ${QUICKTYPE_EXECUTABLE}
    --src-lang schema
    --lang cpp
    --type-style pascal-case
    --member-style camel-case
    --enum-type enum-class
    --include-location global-include
    --namespace "com::xxxx::schema"
    --code-format with-getter-setter
    --const-style west-const
    --out ${GENERATED_SCHEMA_INC_DIR}/SchemaDocument.hpp
    --source-style multi-source
    --top-level schemaDocument
    schemaDocument.json
  WORKING_DIRECTORY ${C2_SCHEMA_DIR}
  DEPENDS ${JSON_SCHEMA_SOURCES}
  COMMENT "Generating C++ model classes from JSON Schema (quicktype)"
  VERBATIM
)

Party on.