[Docs] [txt|pdf|xml|html] [Tracker] [Email] [Diff1] [Diff2] [Nits]

Versions: (draft-zyp-json-schema) 00 01

Internet Engineering Task Force                           A. Wright, Ed.
Internet-Draft                                          October 13, 2016
Intended status: Informational
Expires: April 16, 2017


        JSON Schema: A Media Type for Describing JSON Documents
                      draft-wright-json-schema-00

Abstract

   JSON Schema defines the media type "application/schema+json", a JSON
   based format for describing the structure of JSON data.  JSON Schema
   asserts what a JSON document must look like, ways to extract
   information from it, and how to interact with it, ideal for
   annotating existing JSON APIs that would not otherwise have
   hypermedia controls or be machine-readable.

Note to Readers

   The issues list for this draft can be found at <https://github.com/
   json-schema-org/json-schema-spec/issues>.

   For additional information, see <http://json-schema.org/>.

   To provide feedback, use this issue tracker, the communication
   methods listed on the homepage, or email the document editors.

Status of This Memo

   This Internet-Draft is submitted in full conformance with the
   provisions of BCP 78 and BCP 79.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF).  Note that other groups may also distribute
   working documents as Internet-Drafts.  The list of current Internet-
   Drafts is at http://datatracker.ietf.org/drafts/current/.

   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet-Drafts as reference
   material or to cite them other than as "work in progress."

   This Internet-Draft will expire on April 16, 2017.







Wright                   Expires April 16, 2017                 [Page 1]


Internet-Draft                 JSON Schema                  October 2016


Copyright Notice

   Copyright (c) 2016 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   (http://trustee.ietf.org/license-info) in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

Table of Contents

   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   3
   2.  Conventions and Terminology . . . . . . . . . . . . . . . . .   3
   3.  Overview  . . . . . . . . . . . . . . . . . . . . . . . . . .   3
     3.1.  Validation  . . . . . . . . . . . . . . . . . . . . . . .   3
     3.2.  Hypermedia and linking  . . . . . . . . . . . . . . . . .   4
   4.  Definitions . . . . . . . . . . . . . . . . . . . . . . . . .   4
     4.1.  JSON document . . . . . . . . . . . . . . . . . . . . . .   4
     4.2.  instance  . . . . . . . . . . . . . . . . . . . . . . . .   4
     4.3.  instance equality . . . . . . . . . . . . . . . . . . . .   5
     4.4.  JSON Schema document  . . . . . . . . . . . . . . . . . .   5
     4.5.  Root schema and subschemas  . . . . . . . . . . . . . . .   6
   5.  General considerations  . . . . . . . . . . . . . . . . . . .   6
     5.1.  Range of JSON values  . . . . . . . . . . . . . . . . . .   6
     5.2.  Programming language independence . . . . . . . . . . . .   6
     5.3.  Mathematical integers . . . . . . . . . . . . . . . . . .   7
     5.4.  Extending JSON Schema . . . . . . . . . . . . . . . . . .   7
   6.  The "$schema" keyword . . . . . . . . . . . . . . . . . . . .   7
     6.1.  Purpose . . . . . . . . . . . . . . . . . . . . . . . . .   7
   7.  Schema references with $ref . . . . . . . . . . . . . . . . .   7
   8.  Base URI and dereferencing  . . . . . . . . . . . . . . . . .   8
     8.1.  Initial base URI  . . . . . . . . . . . . . . . . . . . .   8
     8.2.  The "id" keyword  . . . . . . . . . . . . . . . . . . . .   8
       8.2.1.  Internal references . . . . . . . . . . . . . . . . .   9
       8.2.2.  External references . . . . . . . . . . . . . . . . .  10
   9.  Usage for hypermedia  . . . . . . . . . . . . . . . . . . . .  10
     9.1.  Linking to a schema . . . . . . . . . . . . . . . . . . .  11
     9.2.  Describing a profile of JSON  . . . . . . . . . . . . . .  11
     9.3.  Usage over HTTP . . . . . . . . . . . . . . . . . . . . .  12
   10. Security considerations . . . . . . . . . . . . . . . . . . .  12
   11. IANA Considerations . . . . . . . . . . . . . . . . . . . . .  13
   12. References  . . . . . . . . . . . . . . . . . . . . . . . . .  13



Wright                   Expires April 16, 2017                 [Page 2]


Internet-Draft                 JSON Schema                  October 2016


     12.1.  Normative References . . . . . . . . . . . . . . . . . .  13
     12.2.  Informative References . . . . . . . . . . . . . . . . .  13
   Appendix A.  Acknowledgments  . . . . . . . . . . . . . . . . . .  15
   Appendix B.  ChangeLog  . . . . . . . . . . . . . . . . . . . . .  15
   Author's Address  . . . . . . . . . . . . . . . . . . . . . . . .  16

1.  Introduction

   JSON Schema is a JSON media type for defining the structure of JSON
   data.  JSON Schema is intended to define validation, documentation,
   hyperlink navigation, and interaction control of JSON data.

   This specification defines JSON Schema core terminology and
   mechanisms, including pointing to another JSON Schema by reference,
   dereferencing a JSON Schema reference, specifying the vocabulary
   being used, and declaring the minimum functionality necessary for
   processing an instance against a schema.

   Other specifications define the vocabularies that perform assertions
   about validation, linking, annotation, navigation, and interaction.

2.  Conventions and Terminology

   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
   "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
   document are to be interpreted as described in RFC 2119 [RFC2119].

   The terms "JSON", "JSON text", "JSON value", "member", "element",
   "object", "array", "number", "string", "boolean", "true", "false",
   and "null" in this document are to be interpreted as defined in RFC
   7159 [RFC7159].

3.  Overview

   This document proposes a new media type "application/schema+json" to
   identify JSON Schema for describing JSON data.  JSON Schemas are
   themselves written in JSON.  This, and related specifications, define
   keywords allowing to describe this data in terms of allowable values,
   textual descriptions and interpreting relations with other resources.
   The following sections are a summary of features defined by related
   specifications.

3.1.  Validation

   JSON Schema describes the structure of a JSON document (for instance,
   required properties and length limitations).  Applications can use
   this information to validate instances (check that constraints are




Wright                   Expires April 16, 2017                 [Page 3]


Internet-Draft                 JSON Schema                  October 2016


   met), or inform interfaces to collect user input such that the
   constraints are satisfied.

   Validation behaviour and keywords are specified in a separate
   document [json-schema-validation].

3.2.  Hypermedia and linking

   JSON Hyper-Schema describes the hypertext structure of a JSON
   document.  This includes link relations from the instance to other
   resources, interpretation of instances as multimedia data, and
   submission data required to use an API.

   Hyper-schema behaviour and keywords are specified in a separate
   document [json-hyper-schema].

4.  Definitions

4.1.  JSON document

   A JSON document is an information resource (series of octets)
   described by the application/json media type.

   In JSON Schema, the terms "JSON document", "JSON text", and "JSON
   value" are interchangable because of the data model it defines.

4.2.  instance

   JSON Schema interperts documents according to a data model.  A JSON
   value interperted according to this data model is called an
   "instance".

   An instance has one of six primitive types, and a range of possible
   values depending on the type:

   null  A JSON "null" production

   boolean  A "true" or "false" value, from the JSON "true" or "false"
      productions

   object  An unordered set of properties mapping a string to an
      instance, from the JSON "object" production

   array  An ordered list of instances, from the JSON "array" production

   number  An arbitrary-precision, base-10 decimal number value, from
      the JSON "number" production




Wright                   Expires April 16, 2017                 [Page 4]


Internet-Draft                 JSON Schema                  October 2016


   string  A string of Unicode code points, from the JSON "string"
      production

   Whitespace and formatting conserns are thus outside the scope of JSON
   Schema.

   Since an object cannot have two properties with the same key,
   behavior for a JSON document that tries to define two properties (the
   "member" production) with the same key (the "string" production) in a
   single object is undefined.

4.3.  instance equality

   Two JSON instances are said to be equal if and only if they are of
   the same type and have the same value according to the data model.
   Specifically, this means:

      both are null; or

      both are true; or

      both are false; or

      both are strings, and are the same codepoint-for-codepoint; or

      both are numbers, and have the same mathematical value; or

      both are arrays, and have an equal value item-for-item; or

      both are objects, and each property in one has exactly one
      property with an equal key the other, and that other property has
      an equal value.

   Implied in this definition is that arrays must be the same length,
   objects must have the same number of members, properties in objects
   are unordered, there is no way to define multiple properties with the
   same key, and mere formatting differences (indentation, placement of
   commas, trailing zeros) are insignificant.

4.4.  JSON Schema document

   A JSON Schema document, or simply a schema, is a JSON document used
   to describe an instance.  A schema is itself interperted as an
   instance.  A JSON schema MUST be an object.

   Properties that are used to describe the instance are called
   keywords, or schema keywords.  The meaning of properties is specified
   by the vocabulary that the schema is using.



Wright                   Expires April 16, 2017                 [Page 5]


Internet-Draft                 JSON Schema                  October 2016


   A JSON Schema MAY contain properties which are not schema keywords.
   Unknown keywords SHOULD be ignored.

   A schema that itself describes a schema is called a meta-schema.
   Meta-schemas are used to validate JSON Schemas and specify which
   vocabulary it is using.

   An empty schema is a JSON Schema with no properties, or only unknown
   properties.

4.5.  Root schema and subschemas

   The root schema is the schema that comprises the entire JSON document
   in question.

   Some keywords take schemas themselves, allowing JSON Schemas to be
   nested:


   {
       "title": "root",
       "items": {
           "title": "array item"
       }
   }


   In this example document, the schema titled "array item" is a
   subschema, and the schema titled "root" is the root schema.

5.  General considerations

5.1.  Range of JSON values

   An instance may be any valid JSON value as defined by JSON [RFC7159].
   JSON Schema imposes no restrictions on type: JSON Schema can describe
   any JSON value, including, for example, null.

5.2.  Programming language independence

   JSON Schema is programming language agnostic, and supports the full
   range of values described in the data model.  Be aware, however, that
   some languages and JSON parsers may not be able to represent in
   memory the full range of values describable by JSON.







Wright                   Expires April 16, 2017                 [Page 6]


Internet-Draft                 JSON Schema                  October 2016


5.3.  Mathematical integers

   Some programming languages and parsers use different internal
   representations for floating point numbers than they do for integers.

   For constistency, integer JSON numbers SHOULD NOT be encoded with a
   fractional part.

5.4.  Extending JSON Schema

   Implementations MAY define additional keywords to JSON Schema.  Save
   for explicit agreement, schema authors SHALL NOT expect these
   additional keywords to be supported by peer implementations.
   Implementations SHOULD ignore keywords they do not support.

   Authors of extensions to JSON Schema are encouraged to write their
   own meta-schemas, which extend the existing meta-schemas using
   "allOf".  This extended meta-schema SHOULD be referenced using the
   "$schema" keyword, to allow tools to follow the correct behaviour.

6.  The "$schema" keyword

6.1.  Purpose

   The "$schema" keyword is both used as a JSON Schema version
   identifier and the location of a resource which is itself a JSON
   Schema, which describes any schema written for this particular
   version.

   The root schema of a JSON Schema document SHOULD use this keyword.
   The value of this keyword MUST be a URI [RFC3986] (an "absolute"
   URI), and this URI MUST be normalized.  The current schema MUST be
   valid against the meta-schema identified by this URI.

   Values for this property are defined in other documents and by other
   parties.  JSON Schema implementations SHOULD implement support for
   current and previous published drafts of JSON Schema vocabularies as
   deemed reasonable.

7.  Schema references with $ref

   Any time a subschema is expected, a schema may instead use an object
   containing a "$ref" property.  The value of the $ref is a URI
   Reference.  Resolved against the current URI base, it identifies the
   URI of a schema to use.  All other properties in a "$ref" object MUST
   be ignored.





Wright                   Expires April 16, 2017                 [Page 7]


Internet-Draft                 JSON Schema                  October 2016


   The URI is not a network locator, only an identifier.  A schema need
   not be downloadable from the address if it is a network-addressible
   URL, and implementations SHOULD NOT assume they should perform a
   network operation when they encounter a network-addressible URI.

   A schema MUST NOT be run into an infinite loop against a schema.  For
   example, if two schemas "#alice" and "#bob" both have an "allOf"
   property that refers to the other, a naive validator might get stuck
   in an infinite recursive loop trying to validate the instance.
   Schemas SHOULD NOT make use of infinite recursive nesting like this,
   the behavior is undefined.

8.  Base URI and dereferencing

8.1.  Initial base URI

   RFC3986 Section 5.1 [RFC3986] defines how to determine the default
   base URI of a document.

   Informatively, the initial base URI of a schema is the URI it was
   found at, or a suitable substitute URI if none is known.

8.2.  The "id" keyword

   The "id" keyword defines a URI for the schema, and the base URI that
   other URI references within the schema are resolved against.  The
   "id" keyword itself is resolved against the base URI that the object
   as a whole appears in.

   If present, the value for this keyword MUST be a string, and MUST
   represent a valid URI-reference [RFC3986].  This value SHOULD be
   normalized, and SHOULD NOT be an empty fragment <#> or an empty
   string <>.

   The root schema of a JSON Schema document SHOULD contain an "id"
   keyword with an absolute-URI (containing a scheme, but no fragment).

   To name subschemas in a JSON Schema document, subschemas can use "id"
   to give themselves a document-local identifier.  This form of "id"
   keyword MUST begin with a hash ("#") to identify it as a fragment URI
   reference, followed by a letter ([A-Za-z]), followed by any number of
   letters, digits ([0-9]), hyphens ("-"), underscores ("_"), colons
   (":"), or periods (".").

   For example:






Wright                   Expires April 16, 2017                 [Page 8]


Internet-Draft                 JSON Schema                  October 2016


   {
       "id": "http://example.com/root.json",
       "definitions": {
           "A": { "id": "#foo" },
           "B": {
               "id": "other.json",
               "definitions": {
                   "X": { "id": "#bar" },
                   "Y": { "id": "t/inner.json" }
               }
           },
           "C": {
               "id": "urn:uuid:ee564b8a-7a87-4125-8c96-e9f123d6766f"
           }
       }
   }


   The schemas at the following URI-encoded JSON Pointers [RFC6901]
   (relative to the root schema) have the following base URIs, and are
   identifiable by either URI:

   # (document root)  http://example.com/root.json#

   #/definitions/A  http://example.com/root.json#foo

   #/definitions/B  http://example.com/other.json

   #/definitions/B/definitions/X  http://example.com/other.json#bar

   #/definitions/B/definitions/Y  http://example.com/t/inner.json

   #/definitions/C  urn:uuid:ee564b8a-7a87-4125-8c96-e9f123d6766f

8.2.1.  Internal references

   Schemas can be identified by any URI that has been given to them,
   including a JSON Pointer or their URI given directly by "id".

   Tools SHOULD take note of the URIs that schemas, including
   subschemas, provide for themselves using "id".  This is known as
   "Internal referencing".

   For example, consider this schema:







Wright                   Expires April 16, 2017                 [Page 9]


Internet-Draft                 JSON Schema                  October 2016


   {
       "id": "http://example.net/root.json",
       "items": {
           "type": "array",
           "items": { "$ref": "#item" }
       },
       "definitions": {
           "single": {
               "id": "#item",
               "type": "integer"
           },
       }
   }


   When an implementation encounters the <#/definitions/single> schema,
   it resolves the "id" URI reference against the current base URI to
   form <http://example.net/root.json#item>.

   When an implementation then looks inside the <#/items> schema, it
   encounters the <#item> reference, and resolves this to
   <http://example.net/root.json#item> which is understood as the schema
   defined elsewhere in the same document.

8.2.2.  External references

   To differentiate schemas between each other in a vast ecosystem,
   schemas are identified by URI.  As specified above, this does not
   necessarially mean anything is downloaded, but instead JSON Schema
   implementations SHOULD already understand the schemas they will be
   using, including the URIs that identify them.

   Implementations SHOULD be able to associate arbritrary URIs with an
   arbritrary schema and/or automatically associate a schema's "id"-
   given URI, depending on the trust that the the validator has in the
   schema.

   A schema MAY (and likely will) have multiple URIs, but there is no
   way for a URI to identify more than one schema.  When multiple
   schemas try to identify with the same URI, validators SHOULD raise an
   error condition.

9.  Usage for hypermedia

   One of the largest adoptors of JSON has been HTTP servers for
   automated APIs and robots.  This section describes how to enhance
   processing of JSON documents in a more RESTful manner when used with
   protocols that support media types and Web linking [RFC5988].



Wright                   Expires April 16, 2017                [Page 10]


Internet-Draft                 JSON Schema                  October 2016


9.1.  Linking to a schema

   It is RECOMMENDED that instances described by a schema/profile
   provide a link to a downloadable JSON Schema using the link relation
   "describedby", as defined by Linked Data Protocol 1.0, section 8.1
   [W3C.REC-ldp-20150226].

   In HTTP, such links can be attached to any response using the Link
   header [RFC5988].  An example of such a header would be:


   Link: <http://example.com/my-hyper-schema#>; rel="describedby"


9.2.  Describing a profile of JSON

   Instances MAY specify a "profile" as described in The 'profile' Link
   Relation [RFC6906].  When used as a media-type parameter, HTTP
   servers gain the ability to perform Content-Type Negotiation based on
   profile.  The media-type parameter MUST be a whitespace-separated
   list of URIs (i.e. relative references are invalid).

   The profile URI is opaque and SHOULD NOT automatically be
   dereferenced.  If the implementation does not understand the
   semantics of the provided profile, the implementation can instead
   follow the "describedby" links, if any, which may provide information
   on how to handle the profile.  Since "profile" doesn't necessarily
   point to a network location, the "describedby" relation is used for
   linking to a downloadable schema.  However, for simplicity, schema
   authors should make these URIs point to the same resource when
   possible.

   In HTTP, the media-type parameter would be sent inside the Content-
   Type header:


   Content-Type: application/json;
             profile="http://example.com/my-hyper-schema#"


   Multiple profiles are whitespace seperated:


   Content-Type: application/json;
             profile="http://example.com/alice http://example.com/bob"






Wright                   Expires April 16, 2017                [Page 11]


Internet-Draft                 JSON Schema                  October 2016


   HTTP can also send the "profile" in a Link, though this may impact
   media-type semantics and Content-Type negotiation if this replaces
   the media-type parameter entirely:


   Link: </alice>;rel="profile", </bob>;rel="profile"


9.3.  Usage over HTTP

   When used for hypermedia systems over a network, HTTP [RFC7231] is
   frequently the protocol of choice for distributing schemas.
   Misbehaved clients can pose problems for server maintainers if they
   pull a schema over the network more frequently than necessary, when
   it's instead possible to cache a schema for a long period of time.

   HTTP servers SHOULD set long-lived caching headers on JSON Schemas.
   HTTP clients SHOULD observe caching headers and not re-request
   documents within their freshness period.  Distributed systems SHOULD
   make use of a shared cache and/or caching proxy.

   Clients SHOULD set or prepend a User-Agent header specific to the
   JSON Schema implementation or software product.  Since symbols are
   listed in decreasing order of significance, the JSON Schema library
   name/version goes first, then the more generic HTTP library name (if
   any).  For example:


   User-Agent: so-cool-json-schema/1.0.2 curl/7.43.0


   Clients SHOULD be able to make requests with a "From" header so that
   server operators can contact the owner of a potentially misbehaving
   script.

10.  Security considerations

   Both schemas and instances are JSON values.  As such, all security
   considerations defined in RFC 7159 [RFC7159] apply.

   Instances and schemas are both frequently witten by untrusted third
   parties, to be deployed on public Internet servers.  Validators
   should take care that the parsing of schemas doesn't consume
   excessive system resources.  Validators MUST NOT fall into an
   infinite loop.






Wright                   Expires April 16, 2017                [Page 12]


Internet-Draft                 JSON Schema                  October 2016


   Servers need to take care that malicious parties can't change the
   functionality of existing schemas by uploading a schema with an pre-
   existing or very similar "id".

   Individual JSON Schema vocabularies are liable to also have their own
   security considerations.  Consult the respective specifications for
   more information.

11.  IANA Considerations

   The proposed MIME media type for JSON Schema is defined as follows:

      type name: application;

      subtype name: schema+json.

12.  References

12.1.  Normative References

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/
              RFC2119, March 1997,
              <http://www.rfc-editor.org/info/rfc2119>.

   [RFC3986]  Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform
              Resource Identifier (URI): Generic Syntax", STD 66, RFC
              3986, DOI 10.17487/RFC3986, January 2005,
              <http://www.rfc-editor.org/info/rfc3986>.

   [RFC7159]  Bray, T., Ed., "The JavaScript Object Notation (JSON) Data
              Interchange Format", RFC 7159, DOI 10.17487/RFC7159, March
              2014, <http://www.rfc-editor.org/info/rfc7159>.

   [W3C.REC-ldp-20150226]
              Speicher, S., Arwe, J., and A. Malhotra, "Linked Data
              Platform 1.0", World Wide Web Consortium Recommendation
              REC-ldp-20150226, February 2015,
              <http://www.w3.org/TR/2015/REC-ldp-20150226>.

12.2.  Informative References

   [RFC5988]  Nottingham, M., "Web Linking", RFC 5988, DOI 10.17487/
              RFC5988, October 2010,
              <http://www.rfc-editor.org/info/rfc5988>.






Wright                   Expires April 16, 2017                [Page 13]


Internet-Draft                 JSON Schema                  October 2016


   [RFC6901]  Bryan, P., Ed., Zyp, K., and M. Nottingham, Ed.,
              "JavaScript Object Notation (JSON) Pointer", RFC 6901, DOI
              10.17487/RFC6901, April 2013,
              <http://www.rfc-editor.org/info/rfc6901>.

   [RFC6906]  Wilde, E., "The 'profile' Link Relation Type", RFC 6906,
              DOI 10.17487/RFC6906, March 2013,
              <http://www.rfc-editor.org/info/rfc6906>.

   [RFC7231]  Fielding, R., Ed. and J. Reschke, Ed., "Hypertext Transfer
              Protocol (HTTP/1.1): Semantics and Content", RFC 7231, DOI
              10.17487/RFC7231, June 2014,
              <http://www.rfc-editor.org/info/rfc7231>.

   [json-schema-validation]
              Wright, A. and G. Luff, "JSON Schema Validation: A
              Vocabulary for Structural Validation of JSON", draft-
              wright-json-schema-validation-00 (work in progress),
              October 2016.

   [json-hyper-schema]
              Wright, A. and G. Luff, "JSON Hyper-Schema: A Vocabulary
              for Hypermedia Annotation of JSON", draft-wright-json-
              schema-hyperschema-00 (work in progress), October 2016.



























Wright                   Expires April 16, 2017                [Page 14]


Internet-Draft                 JSON Schema                  October 2016


Appendix A.  Acknowledgments

   Thanks to Gary Court, Francis Galiegue, Kris Zyp, and Geraint Luff
   for their work on the initial drafts of JSON Schema.

   Thanks to Jason Desrosiers, Daniel Perrett, Erik Wilde, Ben Hutton,
   Evgeny Poberezkin, and Henry H.  Andrews for their submissions and
   patches to the document.

Appendix B.  ChangeLog

   [[CREF1: This section to be removed before leaving Internet-Draft
   status.]]

   draft-wright-json-schema-00

      *  Updated references to JSON

      *  Updated references to HTTP

      *  Updated references to JSON Pointer

      *  Behavior for "id" is now specified in terms of RFC3986

      *  Aligned vocabulary usage for URIs with RFC3986

      *  Removed reference to draft-pbryan-zyp-json-ref-03

      *  Limited use of "$ref" to wherever a schema is expected

      *  Added definition of the "JSON Schema data model"

      *  Added additional security considerations

      *  Defined use of subschema identifiers for "id"

      *  Rewrote section on usage with HTTP

      *  Rewrote section on usage with rel="describedBy" and
         rel="profile"

      *  Fixed numerous invalid examples

   draft-zyp-json-schema-04

      *  Split validation keywords into separate document

   draft-zyp-json-schema-00



Wright                   Expires April 16, 2017                [Page 15]


Internet-Draft                 JSON Schema                  October 2016


      *  Initial draft.

      *  Salvaged from draft v3.

      *  Mandate the use of JSON Reference, JSON Pointer.

      *  Define the role of "id".  Define URI resolution scope.

      *  Add interoperability considerations.

Author's Address

   Austin Wright (editor)

   EMail: aaa@bzfx.net




































Wright                   Expires April 16, 2017                [Page 16]


Html markup produced by rfcmarkup 1.124, available from https://tools.ietf.org/tools/rfcmarkup/