dynamicAnchor behaviour

[SorinGFS]

Context

• latest currently available json-schema version draft/2020-12
• not taking into consideration anything about proposed changes in the draft/next

Samples

Sample #1 from draft/2020-12 appendix C (// tree schema, extensible)

{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "$id": "https://example.com/tree",
    "$dynamicAnchor": "node",

    "type": "object",
    "properties": {
        "data": true,
        "children": {
            "type": "array",
            "items": {
                "$dynamicRef": "#node"
            }
        }
    }
}

Sample #2

{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "$id": "https://example.com/tree",
    "type": "object",
    "properties": {
        "node": {
            "type": "object",
            "properties": {
                "data": true,
                "children": {
                    "type": "array",
                    "items": {
                        "$ref": "#node"
                    }
                }
            }
        }
    }
}

Questions

1. Is the Sample #2 a perfectly valid schema in the mentioned context ?
2. Is the Sample #2 the absolute equivalent of Sample #1?

[gregsdennis]

Sample 2 is a valid schema, but the $ref: #node will fail to resolve.

They are not equivalent.

[SorinGFS]

In no way does a dynamic anchor "lock" an $id.

Can you define multiple $dynamicAnchors for the same $id?

[SorinGFS]

That first schema is not @gregsdennis's solution and it's not correct (this is his solution). It's trying to reference an anchor that doesn't exist.

And I only changed the path to match to the one in your example... Same logic.

[SorinGFS]

@jdesrosiers

Some of the questions may look unbelieveble stupid to you. Sorry, but I will keep asking stupid questions because I simply don't want to assume anything, my quest to undestand json-schema proved that things looking trivial to me in fact were complicated, and viceversa. You can hang me, but I still don't get why the term meta is used for example, because every schema can be a meta when referenced into another schema! I also struggle to understand why two paralel linking systems must coexist ($anchor,$ref - $dynamicAnchor,$dynamicRef). There is no such thing in html. IMHO this is a problem in json-schema's reference system. Let's say I want to share via messenger a location inside a schema, to reach this content, the link I share should probably look like this: https://json-schema.org/draft/2020-12/meta/validation#meta#/$defs/stringArray (assuming a server would do the internal recursion). Do you think that is looking normal or odd to anyone not familiar with json-schema?
Therefore please bear with me, all these stupid questions helped me to understand in one day more than I did understood by reading specification files over and over again multiple days. It's sad that I need to write my own implementation, but it is what it is. I cannot rely on existing implementations because I need to be able to read any kind of schema written by others, in my understanding that is the real purpose of json-schema (if I were writing a validator for my own codes I could do it in a hundred ways). I'm not even Microsoft with tons of devs who couldn't implement $dynamicRef, so this kind of stupid questions may help others too...

[jdesrosiers]

Can you define multiple $dynamicAnchors for the same $id?

Yes. See that SO answer I linked to previously for an example. The schema with "$id": "https://example.com/schemas/base-tree" has two dynamic anchors: "leaf" and "branch".

Some of the questions may look unbelieveble stupid to you.

I'm sorry that my response came off that way. I didn't mean to insinuate that they were stupid questions. I sincerely want to help you understand these concepts or I wouldn't have responded at all. I have noticed that you have a very direct communication style. We have that in common, so I didn't think you would mind me being very direct as well. Please continue to ask questions.

I also struggle to understand why two paralel linking systems must coexist ($anchor,$ref - $dynamicAnchor,$dynamicRef). There is no such thing in html.

I don't think it's correct to call them parallel systems. They're more like serial systems. One picks up where the other leaves off. While $anchor/$ref work exactly like the HTML, there are things that can't be expressed using just that mechanism. $dynamicAnchor/$dynamicRef were introduced to be able to cover those cases. The SO answer I linked to explains more.

Let's say I want to share via messenger a location inside a schema, to reach this content, the link I share should probably look like this: https://json-schema.org/draft/2020-12/meta/validation#meta#/$defs/stringArray (assuming a server would do the internal recursion).

That's not a URI that would be understood in JSON Schema. You seem to be mixing anchors and pointers, which isn't allowed. The #meta part doesn't belong and isn't necessary to reference that location in the schema. This would be the correct link, https://json-schema.org/draft/2020-12/meta/validation#/$defs/stringArray.

[SorinGFS]

Please continue to ask questions.

Thank you.

This would be the correct link, https://json-schema.org/draft/2020-12/meta/validation#/$defs/stringArray

I also realized in the meantime

The #meta part doesn't belong and isn't necessary to reference that location in the schema.

For this I will have a question in the future, I connect it with another unsolved puzzle of mine related to $vocabulary and the other schema content placed inside the same object.

Yes. See that SO answer I linked to previously for an example. The schema with "$id": "https://example.com/schemas/base-tree" has two dynamic anchors: "leaf" and "branch".

I will also have a question about this. Is late now here, I need to rest.

[jdesrosiers]

I cannot rely on existing implementations because I need to be able to read any kind of schema written by others, in my understanding that is the real purpose of json-schema

Yes, that is the purpose of JSON Schema. Any implementation of JSON Schema should be able to read any kind of schema written by others. That's what a JSON Schema implementation is. We're getting a bit off topic here, but I would like to learn more about what existing implementations don't provide that you need.

[SorinGFS]

We're getting a bit off topic here, but I would like to learn more about what existing implementations don't provide that you need.

I am a lone developer, I don't have a team to work with, that's why I plan the development keeping in mind not to be obliged to maintain or update often. In order to be able to read other people's schemas, it must be taken into account that they can be from draft-04 to draft/2020-12, not to mention that draft/next is also coming, which for now has no implementation. The implementations I have analyzed are based on javascript, and all require the loading of separate libraries for one or more drafts. For them, some kind of router must be written that will say: draft-04 goes here, draft/2020-12 goes there, plus some kind of middleware must be interspersed to preread the schema to see what version it is. All these loaded resources, the extra code, plus the processing that follows make the processing time increase considerably. From what I have observed, most of this time is consumed by reading/resolving the schema. Therefore, the solution I thought of is to have an object in which all the schemas saved on the disk are pre-read and the references are interconnected. When an external schema is loaded, it will be disassembled and emerged in the context. The project is still at the beginning, there is still a lot of work, but if you want to get an idea the constructed context which will then have interconnected references it will look like this. The schemas saved on the disk are all the json-schema versions plus some small tests, I will try in a little while after I solve all the problems to load all the schemas from the schema store, just to see if errors appear.
As for the implementations that I analyzed, the most notable is ajv, but I also know your hyperjump.io project. I found cfworker/json-schema the most interesting.

[jdesrosiers]

In order to be able to read other people's schemas, it must be taken into account that they can be from draft-04 to draft/2020-12

Ok, now I think I understand what you were talking about.

The implementations I have analyzed are based on javascript, and all require the loading of separate libraries for one or more drafts. For them, some kind of router must be written that will say: draft-04 goes here, draft/2020-12 goes there, plus some kind of middleware must be interspersed to preread the schema to see what version it is.

I've definitely seen implementations that work that way, but I that's not entirely true of any of the implementations you listed. With @hyperjump/json-schema you load support for whatever implementation you want to support and pass it any schema. The implementation determines the dialect and evaluates the schema using that dialect. It supports draft-04 through 2020-12 and two OpenAPI dialect, so you'd be unlikely to encounter a schema using a dialect that isn't supported.

import { addSchema, validate } from "@hyperjump/json-schema";
import "@hyperjump/json-schema/draft-2020-12";
import "@hyperjump/json-schema/draft-2019-09";
import "@hyperjump/json-schema/draft-07";
import "@hyperjump/json-schema/draft-06";
import "@hyperjump/json-schema/draft-04";
import "@hyperjump/json-schema/openapi-3-1";
import "@hyperjump/json-schema/openapi-3-0";


addSchema({ /* ... pass me anything. I can handle it ... */ }, "http://example.com/schema");

const output = await validate("http://example.com/schema", instance);

I'm not 100% sure anymore, but I'm pretty sure ajv can mostly do the same with some limitations. I'm also pretty sure cfworker/json-schema works similarly to mine except support for all the dialects are included automatically.

From what I have observed, most of this time is consumed by reading/resolving the schema.

Possibly. If none of the existing options meet your performance needs, that would be a good reason to try to build your own if you think you can do better. Have a look at @exodus/schemasafe if you haven't evaluated it yet. It's the fastest JavaScript implementation out there and supports draft-04 through 2020-12 with the automatic dialect detection you need.

Therefore, the solution I thought of is to have an object in which all the schemas saved on the disk are pre-read and the references are interconnected. When an external schema is loaded, it will be disassembled and emerged in the context.

That's very similar to what the "compile" step does in @hyperjump/json-schema. It walks the schema, resolves references and does whatever pre-processing of the schema that is possible without an instance and stores the information in an AST-like structure. Then when validating an instance it just walks the AST. I only build an AST for one validation at a time, but it could easily be tweaked to compile a bunch of schemas into one AST. The result would be very similar to what you're working on.

[SorinGFS]

Possibly. If none of the existing options meet your performance needs, that would be a good reason to try to build your own if you think you can do better.

I chose the hard way a few months ago. I don't regret it. This course helped me find solutions for how to integrate the schema management in what I do. And what I'm trying to build is a web platform capable to manage multiple machines having web servers, websites, web files, web access configurations, so on... json-schema will be the central part of it, everything will begin with schema-first design and will continue by managing the endpoints created using json-schema. Imagine an internal website (electron app maybe) trough which configurations are passed to the created endpoints via SSH, and which will natively interconnect all the existing enpoints. The structure of the static json-schema context I build in my project has this capability and is location agnostic, the only thing that will matter will be the merging order.
In every project there are good things and not so good things, I like to analize projects to see how they solved some problems and to acquire what is good from them. But what I hate is using several projects for the same concern. I also hate to analize some project few weeks then to realize that there is a flaw which either makes me use some patch, or drop the idea of using it. And I also hate projects whose code is not easy to read (abbreviated vars or messy logic). I prefer not to fill my head to remember which is which but to have a quick read even for my own code. Most of the time that's why I end up in writing my own code. And json-schema will help me to find quickly where do I need to add something, for example that internal website I mention will be connected to the context containing everything added before (is basically a network sitemap) and by navigating to desired location I will be able to add extra things, like docs, configurations, etc... As long as schemas would have the appropriate tested design would be probably impossible to make mistakes.
Anyway, still there is a lot to do, this is just my vision of what should come out.
NB: I almost forgot, programmatic form generation is another need, existing projects in this area usually are based on a single implementation, mostly ajv...

[SorinGFS]

@jdesrosiers

So, what I understand so far about "$dynamicAnchor" is this: when a $dynamicRef is encountered should search for $dynamicAnchor within the $id is encountered. For that, should literally parse every deep node until it founds it. Right? The odd thing I didn't get is the $dynamicAnchor in the object root, and then if there is another $dynamicAnchor inside the same $id this should basically mean not just that a $dynamicAnchor may contain another $dynamicAnchor's in it, but if a $dynamicAnchor is in the object root all the rest of $dynamicAnchor's are part of the one in the root. Is like in html an anchor would be defined in the <head>. You said:

In no way does a dynamic anchor "lock" an $id.

I explained why I was thinking that the $dynamicAnchor in the root basically locks that $id. It didn't cross my mind that an anchor can be defined in another anchor, and still doesn't look right to me. This is not all, if a $dynamicAnchor is defined in the root, and the "leaf" is defined in $defs/leaf/$dynamicAnchor is a dynamic anchor within a regular anchor (which is $defs) within another dynamic anchor in the root! Really odd! Why did you choose this schema extension mechanism? Why you didn't make an $dynamicAnchors (or even better, $dynamicReferences) object and put in it keys as name and references to actual target as value? Would look like $defs or $vocabulary, distinct, and having an obvious place where they belong. Having this $dynamicAnchor defined like this I imagine it can create a lot of overhead for searching large schemas...
I wonder, a mechanism like the $vocabulary extension mechanism couldn't provide same needs as for $dynamicAnchors ?

[jdesrosiers]

The published draft 2020-12 can be extended?

The specification itself can't be changed, but it does include an extension mechanism we call the Vocabulary System.

I ask this because I wonder if the $dynamicAnchor and $dynamicReferences used inside of those specs couldn't be in fact avoided...

I'm not sure what you mean by this. These are not optional features. You'd have to implement them in order to be compliant with the specification. If you're asking if a schema author could always avoid them, the answer is no. There are things that are only possible with dynamic references such as extending a recursive schema. When you need to express those things, there's no workaround to avoid using them. However, the cases where dynamic references are needed are very few. Schema authors aren't likely to need them often.

[SorinGFS]

Just like <a id="foo"> can be anywhere in the HTML document,

anywhere... except within another <a> tag!
I think I understood now how they supose to work, but the analogy with <a> tag in html (which I made too) doesn't fit.

Just for my curiosity I tried to download all the schemastore schemas, only 87 of them passed trough my parser as it sits now, but in them do you know how many $dynamicRef I found? None! Many of schemastore schemas has reference errors, I will refine my parser to be able to load as many as I can, and I will try to get some statistics from them.

Here a dynamic anchor is set that maps foo to https://example.com/schema2#/$defs/foo. It then follows the $ref to the schema from previous example which makes a dynamic reference to foo. We use the mapping we have for foo and evaluation continues at https://example.com/schema2#/$defs/foo. In this case, the dynamic anchor in https://example.com/schema (from the previous example) is ignored because we already have mapping for the foo dynamic anchor.

Thank you for explanations, now I understand that making an implementation without solving this problem wouldn't be possible, so I will refine mine until works properly. There are some challenges in this task... because I decentralize schemas into small pieces. But should be possible eventually...

[SorinGFS]

The specification itself can't be changed, but it does include an extension mechanism we call the Vocabulary System.

That was my guess too.

There are things that are only possible with dynamic references such as extending a recursive schema. When you need to express those things, there's no workaround to avoid using them.

I didn't intend to avoid using them, I was wondering if they are crucial into the specs, but you gave me the answer for that.

[jdesrosiers]

anywhere... except within another <a> tag!

There's still something not quite right about your understanding of anchors because that statement doesn't make sense. An anchor is just an alias to a location, there is no inside for another anchor to be defined within.

the analogy with <a> tag in html (which I made too) doesn't fit.

It fits perfectly. I promise. I think there's still something off with you understanding of anchors.

There are some challenges in this task... because I decentralize schemas into small pieces. But should be possible eventually...

Since your decentralized schemas is similar to my ASTs, I expect you will end up with a similar implementation. I found dynamic references hard to understand, but in the end the code to support it was quite simple. I think you'll find the same to be true.

[SorinGFS]

Some more questions:

• a regular $ref is it allowed to access a $dynamicAnchor ?
• a $dynamicRef is it allowed to access an $anchor ?
• can $dynamicRef access external resources ?
• what is the scope of $dynamicRef ? E.g., if $dynamicRef is created in $id: "http://domain/first/second" can it access a $dynamicAnchor created in $id: "http://domain/first" ?
• what should be the behaviour for $dynamicRef if the correspondent $dynamicAnchor does not exist ?
• what should be the behaviour for $ref if the reference cannot be resolved ?

[jdesrosiers]

a regular $ref is it allowed to access a $dynamicAnchor ?

Technically, yes, but there's is no good reason for a schema author to do so. I expect that to change in a future release so that you can only reference a dynamic anchor with a dynamic reference.

a $dynamicRef is it allowed to access an $anchor ?

No

can $dynamicRef access external resources ?

Yes. In fact, there's no reason to use a dynamic reference if it's not expected to resolve to external resource in at least some cases.

what is the scope of $dynamicRef ? E.g., if $dynamicRef is created in $id: "http://domain/first/second" can it access a $dynamicAnchor created in $id: "http://domain/first" ?

As you are evaluating a schema, you may end up in multiple schema documents as you follow references. At the time the dynamic reference is evaluated, any schema documents that you've visited while evaluating the schema up to that point is in scope. We call this set of visited schemas the "dynamic scope".

So, to answer the question directly, the dynamic reference in http://domain/first/second can only access the dynamic anchor in http://domain/first if evaluation passed through http://domain/first before it got to the dynamic reference in http://domain/first/second.

what should be the behaviour for $dynamicRef if the correspondent $dynamicAnchor does not exist ?

Throw an error.

what should be the behaviour for $ref if the reference cannot be resolved ?

Throw an error.

[SorinGFS]

@jdesrosiers

a regular $ref is it allowed to access a $dynamicAnchor ?

Technically, yes, but there's is no good reason for a schema author to do so. I expect that to change in a future release so that you can only reference a dynamic anchor with a dynamic reference.

There is a way to enforce the correct behaviour. A very nice one... You can combine the functionalities of $anchor with $dynamicAnchor and $ref with $dynamicRef and introduce a prefix sign to distinguish the dynamic ones, like this:

// tree schema, extensible

{
    "$id": "https://example.com/tree",
    "$anchor": "_node",

    "type": "object",
    "properties": {
        "data": true,
        "children": {
            "type": "array",
            "items": {
                "$ref": "#_node"
            }
        }
    }
}

// strict-tree schema, guards against misspelled properties

{
    "$id": "https://example.com/strict-tree",
    "$anchor": "_node",

    "$ref": "tree",
    "unevaluatedProperties": false
}

Having the functionalities combined would be 100% garantied that a dynamic reference cannot access a regular anchor and a regular reference would not access a dynamic anchor. From the performance perspective would also be a gain because unwanted anchors are excluded automatically from search.

This technique is also used in other dynamic searches like text fragment which uses a prefix after # optionally followed by a search syntax.

[jdesrosiers]

Here's an example that might help you understand what Greg is saying. In this example, I'm using a type as the "conflicting" keyword rather than default because I think it will help illustrate the behavior better.

{
  "type": "object",
  "properties": {
    "foo": {
      "$ref": "#/$defs/string",
      "type": "number"
    }
  },

  "$defs": {
    "string": { "type": "string" }
  }
}

Here, you might think that the /properties/foo schema would merge and one of the values for type must override the other. What actually happens is that they both must apply.

Here's another schema that shows how the reference effectively evaluates. There is no merge. The referenced schema is still its own independent schema.

{
  "type": "object",
  "properties": {
    "foo": {
      "allOf": [{ "type": "string" }],
      "type": "number"
    }
  }
}

In both of these schemas, both type: "string" and type: "number" apply. Since it's not possible for JSON instance to be a string and a number at the same time, any value at /properties/foo will fail validation. Obviously, that's not a useful schema, but hopefully it helps illustrate how JSON Schema operates without merging or ambiguity.

[SorinGFS]

@jdesrosiers

there are many replays folded, I don't know why github does that. Please see this one, from official docs

[jdesrosiers]

The spec allows for applications to make their own decisions about how to deal with multiple annotations (not validating keywords) for the same location.

In that example, there are two default annotations for location 0/enabled: true and null. The JSON Schema implementation still needs to return both annotations. This part of the spec says that applications that make use of those annotations may choose to decide to use one or the other. That part of the spec isn't telling you how JSON Schema works, it's telling you how applications are allowed to use the annotation results produced by a JSON Schema implementation.

[SorinGFS]

@jdesrosiers

Ok. I think it wouldn't harm to write few words in understanding json-schema about the fact that $ref result is not merged, and if its location contains similar keywords may result an error. The existing explanation regarding drafts 4-7 left me with the question about what happen in newer drafts, that's why I was searching the specs.

[SorinGFS]

@gregsdennis

I have a great reply to this, but I'm not going to discuss it here.

I suspect it would be related to single point of definition vs cloning parts of schemas...

If so, I think both ways are equally important, there are situations in which it is preferable not to link the schemas but to use modified versions of them. Besides that, $ref is very limited compared to $include.

[SorinGFS]

@jdesrosiers

So, to answer the question directly, the dynamic reference in http://domain/first/second can only access the dynamic anchor in http://domain/first if evaluation passed through http://domain/first before it got to the dynamic reference in http://domain/first/second.

The quote is from selected answer. I think I got this very wrong. You were talking (as I understand now) about a single $id as a jsonPointer passing trough its properties (second nested in first). In my mind were two separate $ids each having own properties, anchors, so on. Like this:

{
    "$id": "http://example/first",
    "properties": {"...":"..."}
}

{
    "$id": "http://example/first/second",
    "properties": {"...":"..."}
}

This would be a totally different thing since in a dynamic scope could end up even hundreds of records in that lookup table, while if is just a single json-pointer (for one dynamicRef) the max length of lookup table would be the object depth. I hope I got this right now 😄 , that would be fast of course.

There are some extra questions now...

[jdesrosiers]

I'm not sure I'm understanding what you're asking. I think what that's showing is that you're trying to determine where a dynamic reference is going to resolve to and include that mapping in your compiled representation. That will work most of the time, but not always. The same $dynamicRef could resolve to different locations depending on the JSON instance being validated. You can't implement dynamic references this way. You need to resolve them dynamically.

[SorinGFS]

The same $dynamicRef could resolve to different locations depending on the JSON instance being validated.

Not a problem in my case, links are absolute, I think there is no way to resolve to wrong location.

If you want to take a look how it is:

{
    "http://example.com/schema#_test": {
        "$ref": "#/http:~1~1example.com~1schema/properties/foo"
    },
    "http://example.com/schema#baz": {
        "$ref": "#/http:~1~1example.com~1schema~1$defs~1bar"
    },
    "http://example.com/schema": {
        "properties": {
            "foo": {
                "type": "string"
            }
        }
    },
    "http://example.com/schema/$defs/bar": {
        "type": "string"
    },
    "http://json-schema.org/draft-04/schema": {
        "default": {},
        "dependencies": {
            "exclusiveMaximum": [
                "maximum"
            ],
            "exclusiveMinimum": [
                "minimum"
            ]
        },
        "description": "Core schema meta-schema",
        "properties": {
            "additionalItems": {
                "anyOf": [
                    {
                        "type": "boolean"
                    },
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema"
                    }
                ],
                "default": {}
            },
            "additionalProperties": {
                "anyOf": [
                    {
                        "type": "boolean"
                    },
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema"
                    }
                ],
                "default": {}
            },
            "allOf": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1schemaArray"
            },
            "anyOf": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1schemaArray"
            },
            "default": {},
            "dependencies": {
                "additionalProperties": {
                    "anyOf": [
                        {
                            "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema"
                        },
                        {
                            "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1stringArray"
                        }
                    ]
                },
                "type": "object"
            },
            "description": {
                "type": "string"
            },
            "enum": {
                "minItems": 1,
                "type": "array",
                "uniqueItems": true
            },
            "exclusiveMaximum": {
                "default": false,
                "type": "boolean"
            },
            "exclusiveMinimum": {
                "default": false,
                "type": "boolean"
            },
            "format": {
                "type": "string"
            },
            "items": {
                "anyOf": [
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema"
                    },
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1schemaArray"
                    }
                ],
                "default": {}
            },
            "maxItems": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1positiveInteger"
            },
            "maxLength": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1positiveInteger"
            },
            "maxProperties": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1positiveInteger"
            },
            "maximum": {
                "type": "number"
            },
            "minItems": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1positiveIntegerDefault0"
            },
            "minLength": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1positiveIntegerDefault0"
            },
            "minProperties": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1positiveIntegerDefault0"
            },
            "minimum": {
                "type": "number"
            },
            "multipleOf": {
                "exclusiveMinimum": true,
                "minimum": 0,
                "type": "number"
            },
            "not": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema"
            },
            "oneOf": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1schemaArray"
            },
            "pattern": {
                "format": "regex",
                "type": "string"
            },
            "patternProperties": {
                "additionalProperties": {
                    "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema"
                },
                "default": {},
                "type": "object"
            },
            "properties": {
                "additionalProperties": {
                    "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema"
                },
                "default": {},
                "type": "object"
            },
            "required": {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1stringArray"
            },
            "title": {
                "type": "string"
            },
            "type": {
                "anyOf": [
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1simpleTypes"
                    },
                    {
                        "items": {
                            "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1simpleTypes"
                        },
                        "minItems": 1,
                        "type": "array",
                        "uniqueItems": true
                    }
                ]
            },
            "uniqueItems": {
                "default": false,
                "type": "boolean"
            }
        },
        "type": "object"
    },
    "http://json-schema.org/draft-04/schema/definitions/positiveInteger": {
        "minimum": 0,
        "type": "integer"
    },
    "http://json-schema.org/draft-04/schema/definitions/positiveIntegerDefault0": {
        "allOf": [
            {
                "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema~1definitions~1positiveInteger"
            },
            {
                "default": 0
            }
        ]
    },
    "http://json-schema.org/draft-04/schema/definitions/schemaArray": {
        "items": {
            "$ref": "#/http:~1~1json-schema.org~1draft-04~1schema"
        },
        "minItems": 1,
        "type": "array"
    },
    "http://json-schema.org/draft-04/schema/definitions/simpleTypes": {
        "enum": [
            "array",
            "boolean",
            "integer",
            "null",
            "number",
            "object",
            "string"
        ]
    },
    "http://json-schema.org/draft-04/schema/definitions/stringArray": {
        "items": {
            "type": "string"
        },
        "minItems": 1,
        "type": "array",
        "uniqueItems": true
    },
    "http://json-schema.org/draft-06/schema": {
        "default": {},
        "properties": {
            "$ref": {
                "format": "uri-reference",
                "type": "string"
            },
            "additionalItems": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
            },
            "additionalProperties": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
            },
            "allOf": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1schemaArray"
            },
            "anyOf": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1schemaArray"
            },
            "const": {},
            "contains": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
            },
            "default": {},
            "dependencies": {
                "additionalProperties": {
                    "anyOf": [
                        {
                            "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
                        },
                        {
                            "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1stringArray"
                        }
                    ]
                },
                "type": "object"
            },
            "description": {
                "type": "string"
            },
            "enum": {
                "minItems": 1,
                "type": "array",
                "uniqueItems": true
            },
            "examples": {
                "items": {},
                "type": "array"
            },
            "exclusiveMaximum": {
                "type": "number"
            },
            "exclusiveMinimum": {
                "type": "number"
            },
            "format": {
                "type": "string"
            },
            "items": {
                "anyOf": [
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
                    },
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1schemaArray"
                    }
                ],
                "default": {}
            },
            "maxItems": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1nonNegativeInteger"
            },
            "maxLength": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1nonNegativeInteger"
            },
            "maxProperties": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1nonNegativeInteger"
            },
            "maximum": {
                "type": "number"
            },
            "minItems": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1nonNegativeIntegerDefault0"
            },
            "minLength": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1nonNegativeIntegerDefault0"
            },
            "minProperties": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1nonNegativeIntegerDefault0"
            },
            "minimum": {
                "type": "number"
            },
            "multipleOf": {
                "exclusiveMinimum": 0,
                "type": "number"
            },
            "not": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
            },
            "oneOf": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1schemaArray"
            },
            "pattern": {
                "format": "regex",
                "type": "string"
            },
            "patternProperties": {
                "additionalProperties": {
                    "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
                },
                "default": {},
                "propertyNames": {
                    "format": "regex"
                },
                "type": "object"
            },
            "properties": {
                "additionalProperties": {
                    "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
                },
                "default": {},
                "type": "object"
            },
            "propertyNames": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
            },
            "required": {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1stringArray"
            },
            "title": {
                "type": "string"
            },
            "type": {
                "anyOf": [
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1simpleTypes"
                    },
                    {
                        "items": {
                            "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1simpleTypes"
                        },
                        "minItems": 1,
                        "type": "array",
                        "uniqueItems": true
                    }
                ]
            },
            "uniqueItems": {
                "default": false,
                "type": "boolean"
            }
        },
        "title": "Core schema meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "http://json-schema.org/draft-06/schema/definitions/nonNegativeInteger": {
        "minimum": 0,
        "type": "integer"
    },
    "http://json-schema.org/draft-06/schema/definitions/nonNegativeIntegerDefault0": {
        "allOf": [
            {
                "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema~1definitions~1nonNegativeInteger"
            },
            {
                "default": 0
            }
        ]
    },
    "http://json-schema.org/draft-06/schema/definitions/schemaArray": {
        "items": {
            "$ref": "#/http:~1~1json-schema.org~1draft-06~1schema"
        },
        "minItems": 1,
        "type": "array"
    },
    "http://json-schema.org/draft-06/schema/definitions/simpleTypes": {
        "enum": [
            "array",
            "boolean",
            "integer",
            "null",
            "number",
            "object",
            "string"
        ]
    },
    "http://json-schema.org/draft-06/schema/definitions/stringArray": {
        "default": [],
        "items": {
            "type": "string"
        },
        "type": "array",
        "uniqueItems": true
    },
    "http://json-schema.org/draft-07/schema": {
        "default": true,
        "properties": {
            "$ref": {
                "format": "uri-reference",
                "type": "string"
            },
            "additionalItems": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
            },
            "additionalProperties": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
            },
            "allOf": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1schemaArray"
            },
            "anyOf": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1schemaArray"
            },
            "const": true,
            "contains": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
            },
            "contentEncoding": {
                "type": "string"
            },
            "contentMediaType": {
                "type": "string"
            },
            "default": true,
            "dependencies": {
                "additionalProperties": {
                    "anyOf": [
                        {
                            "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
                        },
                        {
                            "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1stringArray"
                        }
                    ]
                },
                "type": "object"
            },
            "description": {
                "type": "string"
            },
            "else": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
            },
            "enum": {
                "items": true,
                "minItems": 1,
                "type": "array",
                "uniqueItems": true
            },
            "examples": {
                "items": true,
                "type": "array"
            },
            "exclusiveMaximum": {
                "type": "number"
            },
            "exclusiveMinimum": {
                "type": "number"
            },
            "format": {
                "type": "string"
            },
            "if": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
            },
            "items": {
                "anyOf": [
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
                    },
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1schemaArray"
                    }
                ],
                "default": true
            },
            "maxItems": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1nonNegativeInteger"
            },
            "maxLength": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1nonNegativeInteger"
            },
            "maxProperties": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1nonNegativeInteger"
            },
            "maximum": {
                "type": "number"
            },
            "minItems": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1nonNegativeIntegerDefault0"
            },
            "minLength": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1nonNegativeIntegerDefault0"
            },
            "minProperties": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1nonNegativeIntegerDefault0"
            },
            "minimum": {
                "type": "number"
            },
            "multipleOf": {
                "exclusiveMinimum": 0,
                "type": "number"
            },
            "not": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
            },
            "oneOf": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1schemaArray"
            },
            "pattern": {
                "format": "regex",
                "type": "string"
            },
            "patternProperties": {
                "additionalProperties": {
                    "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
                },
                "default": {},
                "propertyNames": {
                    "format": "regex"
                },
                "type": "object"
            },
            "properties": {
                "additionalProperties": {
                    "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
                },
                "default": {},
                "type": "object"
            },
            "propertyNames": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
            },
            "readOnly": {
                "default": false,
                "type": "boolean"
            },
            "required": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1stringArray"
            },
            "then": {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
            },
            "title": {
                "type": "string"
            },
            "type": {
                "anyOf": [
                    {
                        "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1simpleTypes"
                    },
                    {
                        "items": {
                            "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1simpleTypes"
                        },
                        "minItems": 1,
                        "type": "array",
                        "uniqueItems": true
                    }
                ]
            },
            "uniqueItems": {
                "default": false,
                "type": "boolean"
            },
            "writeOnly": {
                "default": false,
                "type": "boolean"
            }
        },
        "title": "Core schema meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "http://json-schema.org/draft-07/schema/definitions/nonNegativeInteger": {
        "minimum": 0,
        "type": "integer"
    },
    "http://json-schema.org/draft-07/schema/definitions/nonNegativeIntegerDefault0": {
        "allOf": [
            {
                "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema~1definitions~1nonNegativeInteger"
            },
            {
                "default": 0
            }
        ]
    },
    "http://json-schema.org/draft-07/schema/definitions/schemaArray": {
        "items": {
            "$ref": "#/http:~1~1json-schema.org~1draft-07~1schema"
        },
        "minItems": 1,
        "type": "array"
    },
    "http://json-schema.org/draft-07/schema/definitions/simpleTypes": {
        "enum": [
            "array",
            "boolean",
            "integer",
            "null",
            "number",
            "object",
            "string"
        ]
    },
    "http://json-schema.org/draft-07/schema/definitions/stringArray": {
        "default": [],
        "items": {
            "type": "string"
        },
        "type": "array",
        "uniqueItems": true
    },
    "https://json-schema.org/draft/2019-09/meta/applicator#_": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator"
    },
    "https://json-schema.org/draft/2019-09/meta/applicator": {
        "properties": {
            "additionalItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            },
            "additionalProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            },
            "allOf": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator~1$defs~1schemaArray"
            },
            "anyOf": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator~1$defs~1schemaArray"
            },
            "contains": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            },
            "dependentSchemas": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
                },
                "type": "object"
            },
            "else": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            },
            "if": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            },
            "items": {
                "anyOf": [
                    {
                        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
                    },
                    {
                        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator~1$defs~1schemaArray"
                    }
                ]
            },
            "not": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            },
            "oneOf": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator~1$defs~1schemaArray"
            },
            "patternProperties": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
                },
                "default": {},
                "propertyNames": {
                    "format": "regex"
                },
                "type": "object"
            },
            "properties": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
                },
                "default": {},
                "type": "object"
            },
            "propertyNames": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            },
            "then": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            },
            "unevaluatedItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            },
            "unevaluatedProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
            }
        },
        "title": "Applicator vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2019-09/meta/applicator/$defs/schemaArray": {
        "items": {
            "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator#_"
        },
        "minItems": 1,
        "type": "array"
    },
    "https://json-schema.org/draft/2019-09/meta/content#_": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1content"
    },
    "https://json-schema.org/draft/2019-09/meta/content": {
        "properties": {
            "contentEncoding": {
                "type": "string"
            },
            "contentMediaType": {
                "type": "string"
            },
            "contentSchema": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1content#_"
            }
        },
        "title": "Content vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2019-09/meta/core#_": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1core"
    },
    "https://json-schema.org/draft/2019-09/meta/core": {
        "properties": {
            "$ref": {
                "format": "uri-reference",
                "type": "string"
            }
        },
        "title": "Core vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2019-09/meta/format#_": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1format"
    },
    "https://json-schema.org/draft/2019-09/meta/format": {
        "properties": {
            "format": {
                "type": "string"
            }
        },
        "title": "Format vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2019-09/meta/meta-data#_": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1meta-data"
    },
    "https://json-schema.org/draft/2019-09/meta/meta-data": {
        "properties": {
            "default": true,
            "deprecated": {
                "default": false,
                "type": "boolean"
            },
            "description": {
                "type": "string"
            },
            "examples": {
                "items": true,
                "type": "array"
            },
            "readOnly": {
                "default": false,
                "type": "boolean"
            },
            "title": {
                "type": "string"
            },
            "writeOnly": {
                "default": false,
                "type": "boolean"
            }
        },
        "title": "Meta-data vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2019-09/meta/validation#_": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation"
    },
    "https://json-schema.org/draft/2019-09/meta/validation": {
        "properties": {
            "const": true,
            "dependentRequired": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1stringArray"
                },
                "type": "object"
            },
            "enum": {
                "items": true,
                "type": "array"
            },
            "exclusiveMaximum": {
                "type": "number"
            },
            "exclusiveMinimum": {
                "type": "number"
            },
            "maxContains": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maxItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maxLength": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maxProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maximum": {
                "type": "number"
            },
            "minContains": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1nonNegativeInteger",
                "default": 1
            },
            "minItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1nonNegativeIntegerDefault0"
            },
            "minLength": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1nonNegativeIntegerDefault0"
            },
            "minProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1nonNegativeIntegerDefault0"
            },
            "minimum": {
                "type": "number"
            },
            "multipleOf": {
                "exclusiveMinimum": 0,
                "type": "number"
            },
            "pattern": {
                "format": "regex",
                "type": "string"
            },
            "required": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1stringArray"
            },
            "type": {
                "anyOf": [
                    {
                        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1simpleTypes"
                    },
                    {
                        "items": {
                            "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1simpleTypes"
                        },
                        "minItems": 1,
                        "type": "array",
                        "uniqueItems": true
                    }
                ]
            },
            "uniqueItems": {
                "default": false,
                "type": "boolean"
            }
        },
        "title": "Validation vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2019-09/meta/validation/$defs/nonNegativeInteger": {
        "minimum": 0,
        "type": "integer"
    },
    "https://json-schema.org/draft/2019-09/meta/validation/$defs/nonNegativeIntegerDefault0": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1nonNegativeInteger",
        "default": 0
    },
    "https://json-schema.org/draft/2019-09/meta/validation/$defs/simpleTypes": {
        "enum": [
            "array",
            "boolean",
            "integer",
            "null",
            "number",
            "object",
            "string"
        ]
    },
    "https://json-schema.org/draft/2019-09/meta/validation/$defs/stringArray": {
        "default": [],
        "items": {
            "type": "string"
        },
        "type": "array",
        "uniqueItems": true
    },
    "https://json-schema.org/draft/2019-09/schema#_": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1schema"
    },
    "https://json-schema.org/draft/2019-09/schema": {
        "allOf": [
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1core"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1applicator"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1meta-data"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1format"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1content"
            }
        ],
        "properties": {
            "dependencies": {
                "additionalProperties": {
                    "anyOf": [
                        {
                            "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1schema#_"
                        },
                        {
                            "$ref": "#/https:~1~1json-schema.org~1draft~12019-09~1meta~1validation~1$defs~1stringArray"
                        }
                    ]
                },
                "type": "object"
            }
        },
        "title": "Core and Validation specifications meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/applicator#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator"
    },
    "https://json-schema.org/draft/2020-12/meta/applicator": {
        "properties": {
            "additionalProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
            },
            "allOf": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator~1$defs~1schemaArray"
            },
            "anyOf": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator~1$defs~1schemaArray"
            },
            "contains": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
            },
            "dependentSchemas": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
                },
                "default": {},
                "type": "object"
            },
            "else": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
            },
            "if": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
            },
            "items": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
            },
            "not": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
            },
            "oneOf": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator~1$defs~1schemaArray"
            },
            "patternProperties": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
                },
                "default": {},
                "propertyNames": {
                    "format": "regex"
                },
                "type": "object"
            },
            "prefixItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator~1$defs~1schemaArray"
            },
            "properties": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
                },
                "default": {},
                "type": "object"
            },
            "propertyNames": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
            },
            "then": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
            }
        },
        "title": "Applicator vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/applicator/$defs/schemaArray": {
        "items": {
            "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator#_meta"
        },
        "minItems": 1,
        "type": "array"
    },
    "https://json-schema.org/draft/2020-12/meta/content#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1content"
    },
    "https://json-schema.org/draft/2020-12/meta/content": {
        "properties": {
            "contentEncoding": {
                "type": "string"
            },
            "contentMediaType": {
                "type": "string"
            },
            "contentSchema": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1content#_meta"
            }
        },
        "title": "Content vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/core#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1core"
    },
    "https://json-schema.org/draft/2020-12/meta/core": {
        "properties": {
            "$ref": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1core~1$defs~1uriReferenceString"
            }
        },
        "title": "Core vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/core/$defs/anchorString": {
        "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$",
        "type": "string"
    },
    "https://json-schema.org/draft/2020-12/meta/core/$defs/uriReferenceString": {
        "format": "uri-reference",
        "type": "string"
    },
    "https://json-schema.org/draft/2020-12/meta/core/$defs/uriString": {
        "format": "uri",
        "type": "string"
    },
    "https://json-schema.org/draft/2020-12/meta/format-annotation#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1format-annotation"
    },
    "https://json-schema.org/draft/2020-12/meta/format-annotation": {
        "properties": {
            "format": {
                "type": "string"
            }
        },
        "title": "Format vocabulary meta-schema for annotation results",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/format-assertion#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1format-assertion"
    },
    "https://json-schema.org/draft/2020-12/meta/format-assertion": {
        "properties": {
            "format": {
                "type": "string"
            }
        },
        "title": "Format vocabulary meta-schema for assertion results",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/meta-data#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1meta-data"
    },
    "https://json-schema.org/draft/2020-12/meta/meta-data": {
        "properties": {
            "default": true,
            "deprecated": {
                "default": false,
                "type": "boolean"
            },
            "description": {
                "type": "string"
            },
            "examples": {
                "items": true,
                "type": "array"
            },
            "readOnly": {
                "default": false,
                "type": "boolean"
            },
            "title": {
                "type": "string"
            },
            "writeOnly": {
                "default": false,
                "type": "boolean"
            }
        },
        "title": "Meta-data vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/unevaluated#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1unevaluated"
    },
    "https://json-schema.org/draft/2020-12/meta/unevaluated": {
        "properties": {
            "unevaluatedItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1unevaluated#_meta"
            },
            "unevaluatedProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1unevaluated#_meta"
            }
        },
        "title": "Unevaluated applicator vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/validation#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation"
    },
    "https://json-schema.org/draft/2020-12/meta/validation": {
        "properties": {
            "const": true,
            "dependentRequired": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1stringArray"
                },
                "type": "object"
            },
            "enum": {
                "items": true,
                "type": "array"
            },
            "exclusiveMaximum": {
                "type": "number"
            },
            "exclusiveMinimum": {
                "type": "number"
            },
            "maxContains": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maxItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maxLength": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maxProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maximum": {
                "type": "number"
            },
            "minContains": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1nonNegativeInteger",
                "default": 1
            },
            "minItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1nonNegativeIntegerDefault0"
            },
            "minLength": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1nonNegativeIntegerDefault0"
            },
            "minProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1nonNegativeIntegerDefault0"
            },
            "minimum": {
                "type": "number"
            },
            "multipleOf": {
                "exclusiveMinimum": 0,
                "type": "number"
            },
            "pattern": {
                "format": "regex",
                "type": "string"
            },
            "required": {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1stringArray"
            },
            "type": {
                "anyOf": [
                    {
                        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1simpleTypes"
                    },
                    {
                        "items": {
                            "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1simpleTypes"
                        },
                        "minItems": 1,
                        "type": "array",
                        "uniqueItems": true
                    }
                ]
            },
            "uniqueItems": {
                "default": false,
                "type": "boolean"
            }
        },
        "title": "Validation vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/validation/$defs/nonNegativeInteger": {
        "minimum": 0,
        "type": "integer"
    },
    "https://json-schema.org/draft/2020-12/meta/validation/$defs/nonNegativeIntegerDefault0": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1nonNegativeInteger",
        "default": 0
    },
    "https://json-schema.org/draft/2020-12/meta/validation/$defs/simpleTypes": {
        "enum": [
            "array",
            "boolean",
            "integer",
            "null",
            "number",
            "object",
            "string"
        ]
    },
    "https://json-schema.org/draft/2020-12/meta/validation/$defs/stringArray": {
        "default": [],
        "items": {
            "type": "string"
        },
        "type": "array",
        "uniqueItems": true
    },
    "https://json-schema.org/draft/2020-12/schema#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1schema"
    },
    "https://json-schema.org/draft/2020-12/schema": {
        "allOf": [
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1core"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1applicator"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1unevaluated"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1meta-data"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1format-annotation"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1content"
            }
        ],
        "properties": {
            "dependencies": {
                "additionalProperties": {
                    "anyOf": [
                        {
                            "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1schema#_meta"
                        },
                        {
                            "$ref": "#/https:~1~1json-schema.org~1draft~12020-12~1meta~1validation~1$defs~1stringArray"
                        }
                    ]
                },
                "default": {},
                "deprecated": true,
                "type": "object"
            }
        },
        "title": "Core and Validation specifications meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/next/meta/applicator#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator"
    },
    "https://json-schema.org/draft/next/meta/applicator": {
        "properties": {
            "additionalProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
            },
            "allOf": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator~1$defs~1schemaArray"
            },
            "anyOf": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator~1$defs~1schemaArray"
            },
            "contains": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
            },
            "dependentSchemas": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
                },
                "default": {},
                "type": "object"
            },
            "else": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
            },
            "if": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
            },
            "items": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
            },
            "maxContains": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator~1$defs~1nonNegativeInteger"
            },
            "minContains": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator~1$defs~1nonNegativeInteger",
                "default": 1
            },
            "not": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
            },
            "oneOf": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator~1$defs~1schemaArray"
            },
            "patternProperties": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
                },
                "default": {},
                "propertyNames": {
                    "format": "regex"
                },
                "type": "object"
            },
            "prefixItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator~1$defs~1schemaArray"
            },
            "properties": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
                },
                "default": {},
                "type": "object"
            },
            "propertyDependencies": {
                "additionalProperties": {
                    "additionalProperties": {
                        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
                    },
                    "default": {},
                    "type": "object"
                },
                "default": {},
                "type": "object"
            },
            "propertyNames": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
            },
            "then": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
            }
        },
        "title": "Applicator vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/next/meta/applicator/$defs/nonNegativeInteger": {
        "minimum": 0,
        "type": "integer"
    },
    "https://json-schema.org/draft/next/meta/applicator/$defs/schemaArray": {
        "items": {
            "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator#_meta"
        },
        "minItems": 1,
        "type": "array"
    },
    "https://json-schema.org/draft/next/meta/content#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1content"
    },
    "https://json-schema.org/draft/next/meta/content": {
        "properties": {
            "contentEncoding": {
                "type": "string"
            },
            "contentMediaType": {
                "type": "string"
            },
            "contentSchema": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1content#_meta"
            }
        },
        "title": "Content vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/next/meta/core#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1core"
    },
    "https://json-schema.org/draft/next/meta/core": {
        "properties": {
            "$ref": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1core~1$defs~1iriReferenceString"
            }
        },
        "title": "Core vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/next/meta/core/$defs/anchorString": {
        "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$",
        "type": "string"
    },
    "https://json-schema.org/draft/next/meta/core/$defs/iriReferenceString": {
        "format": "iri-reference",
        "type": "string"
    },
    "https://json-schema.org/draft/next/meta/core/$defs/iriString": {
        "format": "iri",
        "type": "string"
    },
    "https://json-schema.org/draft/next/meta/format-annotation#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1format-annotation"
    },
    "https://json-schema.org/draft/next/meta/format-annotation": {
        "properties": {
            "format": {
                "type": "string"
            }
        },
        "title": "Format vocabulary meta-schema for annotation results",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/next/meta/format-assertion#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1format-assertion"
    },
    "https://json-schema.org/draft/next/meta/format-assertion": {
        "properties": {
            "format": {
                "type": "string"
            }
        },
        "title": "Format vocabulary meta-schema for assertion results",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/next/meta/meta-data#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1meta-data"
    },
    "https://json-schema.org/draft/next/meta/meta-data": {
        "properties": {
            "default": true,
            "deprecated": {
                "default": false,
                "type": "boolean"
            },
            "description": {
                "type": "string"
            },
            "examples": {
                "items": true,
                "type": "array"
            },
            "readOnly": {
                "default": false,
                "type": "boolean"
            },
            "title": {
                "type": "string"
            },
            "writeOnly": {
                "default": false,
                "type": "boolean"
            }
        },
        "title": "Meta-data vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/next/meta/unevaluated#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1unevaluated"
    },
    "https://json-schema.org/draft/next/meta/unevaluated": {
        "properties": {
            "unevaluatedItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1unevaluated#_meta"
            },
            "unevaluatedProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1unevaluated#_meta"
            }
        },
        "title": "Unevaluated applicator vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/next/meta/validation#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation"
    },
    "https://json-schema.org/draft/next/meta/validation": {
        "properties": {
            "const": true,
            "dependentRequired": {
                "additionalProperties": {
                    "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1stringArray"
                },
                "type": "object"
            },
            "enum": {
                "items": true,
                "type": "array"
            },
            "exclusiveMaximum": {
                "type": "number"
            },
            "exclusiveMinimum": {
                "type": "number"
            },
            "maxItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maxLength": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maxProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1nonNegativeInteger"
            },
            "maximum": {
                "type": "number"
            },
            "minItems": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1nonNegativeIntegerDefault0"
            },
            "minLength": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1nonNegativeIntegerDefault0"
            },
            "minProperties": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1nonNegativeIntegerDefault0"
            },
            "minimum": {
                "type": "number"
            },
            "multipleOf": {
                "exclusiveMinimum": 0,
                "type": "number"
            },
            "pattern": {
                "format": "regex",
                "type": "string"
            },
            "required": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1stringArray"
            },
            "type": {
                "anyOf": [
                    {
                        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1simpleTypes"
                    },
                    {
                        "items": {
                            "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1simpleTypes"
                        },
                        "minItems": 1,
                        "type": "array",
                        "uniqueItems": true
                    }
                ]
            },
            "uniqueItems": {
                "default": false,
                "type": "boolean"
            }
        },
        "title": "Validation vocabulary meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    },
    "https://json-schema.org/draft/next/meta/validation/$defs/nonNegativeInteger": {
        "minimum": 0,
        "type": "integer"
    },
    "https://json-schema.org/draft/next/meta/validation/$defs/nonNegativeIntegerDefault0": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1nonNegativeInteger",
        "default": 0
    },
    "https://json-schema.org/draft/next/meta/validation/$defs/simpleTypes": {
        "enum": [
            "array",
            "boolean",
            "integer",
            "null",
            "number",
            "object",
            "string"
        ]
    },
    "https://json-schema.org/draft/next/meta/validation/$defs/stringArray": {
        "default": [],
        "items": {
            "type": "string"
        },
        "type": "array",
        "uniqueItems": true
    },
    "https://json-schema.org/draft/next/output/schema": {
        "anyOf": [
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1output~1schema~1$defs~1flag"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1output~1schema~1$defs~1list"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1output~1schema~1$defs~1hierarchical"
            }
        ],
        "description": "A schema that validates the minimum requirements for validation output"
    },
    "https://json-schema.org/draft/next/output/schema/$defs/flag": {
        "properties": {
            "valid": {
                "type": "boolean"
            }
        },
        "required": [
            "valid"
        ]
    },
    "https://json-schema.org/draft/next/output/schema/$defs/hierarchical": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1output~1schema~1$defs~1outputUnit"
    },
    "https://json-schema.org/draft/next/output/schema/$defs/list": {
        "properties": {
            "nested": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1output~1schema~1$defs~1outputUnitArray"
            },
            "valid": {
                "type": "boolean"
            }
        },
        "required": [
            "valid",
            "nested"
        ]
    },
    "https://json-schema.org/draft/next/output/schema/$defs/outputUnit": {
        "allOf": [
            {
                "if": {
                    "anyOf": [
                        {
                            "required": [
                                "errors"
                            ]
                        },
                        {
                            "required": [
                                "droppedAnnotations"
                            ]
                        }
                    ]
                },
                "then": {
                    "properties": {
                        "valid": {
                            "const": false
                        }
                    }
                }
            },
            {
                "if": {
                    "required": [
                        "annotations"
                    ]
                },
                "then": {
                    "properties": {
                        "valid": {
                            "const": true
                        }
                    }
                }
            }
        ],
        "properties": {
            "annotations": {
                "additionalProperties": true,
                "type": "object"
            },
            "droppedAnnotations": {
                "additionalProperties": true,
                "type": "object"
            },
            "errors": {
                "additionalProperties": {
                    "type": "string"
                },
                "type": "object"
            },
            "evaluationPath": {
                "format": "json-pointer",
                "type": "string"
            },
            "instanceLocation": {
                "format": "json-pointer",
                "type": "string"
            },
            "nested": {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1output~1schema~1$defs~1outputUnitArray"
            },
            "schemaLocation": {
                "format": "uri",
                "type": "string"
            },
            "valid": {
                "type": "boolean"
            }
        },
        "required": [
            "valid",
            "evaluationPath",
            "schemaLocation",
            "instanceLocation"
        ]
    },
    "https://json-schema.org/draft/next/output/schema/$defs/outputUnitArray": {
        "items": {
            "$ref": "#/https:~1~1json-schema.org~1draft~1next~1output~1schema~1$defs~1outputUnit"
        },
        "type": "array"
    },
    "https://json-schema.org/draft/next/schema#_meta": {
        "$ref": "#/https:~1~1json-schema.org~1draft~1next~1schema"
    },
    "https://json-schema.org/draft/next/schema": {
        "allOf": [
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1core"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1applicator"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1unevaluated"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1meta-data"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1format-annotation"
            },
            {
                "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1content"
            }
        ],
        "properties": {
            "dependencies": {
                "additionalProperties": {
                    "anyOf": [
                        {
                            "$ref": "#/https:~1~1json-schema.org~1draft~1next~1schema#_meta"
                        },
                        {
                            "$ref": "#/https:~1~1json-schema.org~1draft~1next~1meta~1validation~1$defs~1stringArray"
                        }
                    ]
                },
                "default": {},
                "deprecated": true,
                "type": "object"
            }
        },
        "title": "Core and Validation specifications meta-schema",
        "type": [
            "object",
            "boolean"
        ]
    }
}

If you load it in vscode you can walk manually from every point by following the jsonPointers

[jdesrosiers]

I don't think you're understanding me. Absolute URIs aren't a solution to this problem.

But, maybe you're doing something I don't understand. Did you look at the test from the test suite that Greg linked to earlier? If your implementation can pass those tests correctly, then it's handling the problem I'm talking about.

[SorinGFS]

@jdesrosiers

In fact what I wanted to understand is if there is some other behaviour that you achieve using that mechanism in order not to skip. Apparently there isn't. The final built will look very different than this, I will use $include to combine all the old drafts starting from 04 into a single piece. There are 64 keywords in total, minus 8 core keyords which are already proccessed. The original files will remain untouched, from this internal representation I extracted the unneccessary parts for the parser.

[SorinGFS]

@jdesrosiers

Did you look at the test from the test suite that Greg linked to earlier ...

I know the test suite, is not the case yet, I don't have any validator yet. At this stage the right walk of AST like tree is the matter.

Also, the external schemas will be converted to the same internal model and loaded into the context. There will also be another piece which will be a link between schemas. A lot of work to do, but I think the final result will be awesome.