The json-schema Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The json-schema Reference Manual

This is the json-schema Reference Manual, version 2.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Sun May 15 05:06:00 2022 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

.. image:: https://travis-ci.org/fisxoj/json-schema.svg?branch=master
   :target: https://travis-ci.org/fisxoj/json-schema
   :alt: Travis CI status badge
.. image:: https://coveralls.io/repos/github/fisxoj/json-schema/badge.svg?branch=master
   :target: https://coveralls.io/github/fisxoj/json-schema?branch=master
   :alt: Coveralls status badge
.. image:: https://img.shields.io/badge/Contributor%20Covenant-v1.4%20adopted-ff69b4.svg
   :alt: Contributor Covenant
   :target: CODE_OF_CONDUCT.md


:Source: `https://github.com/fisxoj/json-schema `_
:Docs:  `https://fisxoj.github.io/json-schema/ `_

json-schema is a validator for drafts 4, 6, 7, and 2019-09 of the `JSON Schema `_ standard.  It is (mostly) compliant with the `common test suite `_.  The exceptions are

**Draft 2019-09:**

- ``unevaluatedItems`` and ``unevaluatedProperties`` are unimplemented

**Drafts 4, 6, 7:**

- ``$ref`` does not override any sibling keywords

-------
Example
-------

The main entry point to the library is :function:`json-schema:validate`, which takes a schema to validate against, the data to validate against it and a draft version to use for interpreting the schema.  The default version is currently draft7.

**Validating a simple type**

Passing
::

   (json-schema:validate 3 :schema (json-schema.parse:parse "{\"type\":\"integer\"}"))
   ;; => T
   ;;    NIL

Failing (note the error messages in the second argument)
::

   (json-schema:validate 13 :schema (json-schema.parse:parse "{\"type\":\"integer\",\"maximum\":10}"))
   ;; => NIL
   ;;    ("13 must be less than or equal to 10")


**Validating an object**
::

   (setf schema (json-schema.parse:parse
              "{\"properties\":{\"foo\\nbar\":{\"type\":\"number\"},\"foo\\\"bar\":{\"type\":\"number\"},\"foo\\\\bar\":{\"type\":\"number\"},\"foo\\rbar\":{\"type\":\"number\"},\"foo\\tbar\":{\"type\":\"number\"},\"foo\\fbar\":{\"type\":\"number\"}}}"))

Passing
::

   (json-schema:validate
     (json-schema.parse:parse
       "{\"foo\\nbar\":1,\"foo\\\"bar\":1,\"foo\\\\bar\":1,\"foo\\rbar\":1,\"foo\\tbar\":1,\"foo\\fbar\":1}") :schema schema)
   ;; => T
   ;;    NIL

Failing
::

   (json-schema:validate
     (json-schema.parse:parse
       "{\"foo\\nbar\":\"1\",\"foo\\\"bar\":\"1\",\"foo\\\\bar\":\"1\",\"foo\\rbar\":\"1\",\"foo\\tbar\":\"1\",\"foo\\fbar\":\"1\"}") :schema schema)
   ;; => NIL
   ;; ("got errors validating properties
   ;;
   ;; Additionally:
   ;; - Value 1 is not of type \"number\".
   ;; - Value 1 is not of type \"number\".
   ;; - Value 1 is not of type \"number\".
   ;; - Value 1 is not of type \"number\".
   ;; - Value 1 is not of type \"number\".
   ;; - Value 1 is not of type \"number\".
   ;; ")

**Validating a document with a referenced schema**

If your data contains a top-level ``$schema`` key, you don't need to pass a schema along.  It will be fetched and validated against automatically.  This works with, for example, the `draft2019-09 meta-schema `_.

-----------
Usage Notes
-----------

~~~~~~~~
Contexts
~~~~~~~~

A context is a reusable set of state that contains all of the fetched network resources (if your schema references external resources) and resolved ids.  By storing that all, you can reuse the validation context multiple times without fetching/resolving everything again.
::
   (ql:quickload '(trivial-benchmark json-schema))

   (defvar *schema* (json-schema.parse:parse #P"~/Downloads/schema"))

   ;; schema is the json-schema meta schema document from:
   ;; https://json-schema.org/specification-links.html#draft-2019-09-formerly-known-as-draft-8

   (defvar *context*
     (json-schema:make-context
      *schema*
      :draft2019-09))

   ;;; Cached

   (let ((data (json-schema.parse:parse "{\"type\": \"string\"}")))
     (trivial-benchmark:with-timing (1000)
       (json-schema:validate data
                             :context *context*)))

   ;; -                SAMPLES  TOTAL      MINIMUM  MAXIMUM   MEDIAN    AVERAGE    DEVIATION
   ;; REAL-TIME        1000     0.826      0        0.022     0.001     0.000826   0.000797
   ;; RUN-TIME         1000     0.826      0        0.022     0.001     0.000826   0.0008
   ;; USER-RUN-TIME    1000     0.781011   0        0.020644  0.000745  0.000781   0.000665
   ;; SYSTEM-RUN-TIME  1000     0.049933   0        0.000986  0         0.00005    0.000184
   ;; PAGE-FAULTS      1000     0          0        0         0         0          0.0
   ;; GC-RUN-TIME      1000     0.02       0        0.02      0         0.00002    0.000632
   ;; BYTES-CONSED     1000     213753664  195344   228976    228032    213753.66  16221.591
   ;; EVAL-CALLS       1000     0          0        0         0         0          0.0


   ;;; Uncached

   (let ((data (json-schema.parse:parse "{\"type\": \"string\"}")))
     (trivial-benchmark:with-timing (1000)
       (json-schema:validate data
                             :schema *schema*
                             :schema-version :draft2019-09)))

   ;; -                SAMPLES  TOTAL      MINIMUM   MAXIMUM   MEDIAN    AVERAGE   DEVIATION
   ;; REAL-TIME        1000     203.185    0.148     1.471     0.185     0.203185  0.112807
   ;; RUN-TIME         1000     9.25       0.006     0.04      0.009     0.00925   0.002294
   ;; USER-RUN-TIME    1000     8.145081   0.003368  0.039067  0.008105  0.008145  0.002317
   ;; SYSTEM-RUN-TIME  1000     1.107377   0         0.004927  0.000994  0.001107  0.000967
   ;; PAGE-FAULTS      1000     0          0         0         0         0         0.0
   ;; GC-RUN-TIME      1000     0.08       0         0.03      0         0.00008   0.001464
   ;; BYTES-CONSED     1000     719780512  707728    751424    718160    719780.5  11026.181
   ;; EVAL-CALLS       1000     0          0         0         0         0         0.0


So, for this trivial example, the cached version is around a 245x speedup!  Note, though, that json-schema evaluates these things lazily, so not every reference is necessarily resolved when the context is created.  They are mutable, though, and will build up state as they go.

Thank you to `Raymond Wiker `_ for contributing the initial implementation.

~~~~~~~~~~~~~
Decoding JSON
~~~~~~~~~~~~~

json-schema operates mostly on :class:`cl:hash-table` objects.  It requires them to have the ``:test`` argument set to :function:`cl:equal`, so that they work with string keys.  Further, it expects ``:true`` and ``:false`` as the boolean values and ``:null`` as the decoded Javascript ``null``.  Javascrpit arrays should be rendered as lists.  This behavior is provided behind the scenes by `st-json `_.  The :function:`json-schema.parse:parse` function provides this functionality over strings, streams, and pathnames for you.


~~~~~~~~~~~~~~
Network access
~~~~~~~~~~~~~~

JSON Schema allows schemas to reference other documents over the network.  This library will fetch them automatically, by default.  If you don't want this to be allowed, you should set :variable:`json-schema.reference:*resolve-remote-references*` to ``nil``.  If a schema references a remote one, it will raise a :class:`json-schema.reference:fetching-not-allowed-error` instead of fetching it when fetching references is disallowed.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 json-schema

Author

Matt Novenstern <fisxoj@gmail.com>

Home Page

https://fisxoj.github.io/json-schema/

License

LLGPL

Description

JSON schema validation

Long Description

.. image:: https://travis-ci.org/fisxoj/json-schema.svg?branch=master
:target: https://travis-ci.org/fisxoj/json-schema
:alt: Travis CI status badge
.. image:: https://coveralls.io/repos/github/fisxoj/json-schema/badge.svg?branch=master
:target: https://coveralls.io/github/fisxoj/json-schema?branch=master
:alt: Coveralls status badge
.. image:: https://img.shields.io/badge/Contributor%20Covenant-v1.4%20adopted-ff69b4.svg
:alt: Contributor Covenant
:target: CODE_OF_CONDUCT.md

:Source: ‘https://github.com/fisxoj/json-schema <https://github.com/fisxoj/json-schema>‘_
:Docs: ‘https://fisxoj.github.io/json-schema/ <https://fisxoj.github.io/json-schema/>‘_

json-schema is a validator for drafts 4, 6, 7, and 2019-09 of the ‘JSON Schema <https://json-schema.org/>‘_ standard. It is (mostly) compliant with the ‘common test suite <https://github.com/json-schema-org/JSON-Schema-Test-Suite>‘_. The exceptions are

**Draft 2019-09:**

- “unevaluatedItems“ and “unevaluatedProperties“ are unimplemented

**Drafts 4, 6, 7:**

- “$ref“ does not override any sibling keywords

——-
Example
——-

The main entry point to the library is :function:‘json-schema:validate‘, which takes a schema to validate against, the data to validate against it and a draft version to use for interpreting the schema. The default version is currently draft7.

**Validating a simple type**

Passing
::

(json-schema:validate 3 :schema (json-schema.parse:parse "{\"type\":\"integer\"}"))
;; => T
;; NIL

Failing (note the error messages in the second argument)
::

(json-schema:validate 13 :schema (json-schema.parse:parse "{\"type\":\"integer\",\"maximum\":10}"))
;; => NIL
;; ("13 must be less than or equal to 10")

**Validating an object**
::

(setf schema (json-schema.parse:parse
"{\"properties\":{\"foo\\nbar\":{\"type\":\"number\"},\"foo\\\"bar\":{\"type\":\"number\"},\"foo\\\\bar\":{\"type\":\"number\"},\"foo\\rbar\":{\"type\":\"number\"},\"foo\\tbar\":{\"type\":\"number\"},\"foo\\fbar\":{\"type\":\"number\"}}}"))

Passing
::

(json-schema:validate
(json-schema.parse:parse
"{\"foo\\nbar\":1,\"foo\\\"bar\":1,\"foo\\\\bar\":1,\"foo\\rbar\":1,\"foo\\tbar\":1,\"foo\\fbar\":1}") :schema schema)
;; => T
;; NIL

Failing
::

(json-schema:validate
(json-schema.parse:parse
"{\"foo\\nbar\":\"1\",\"foo\\\"bar\":\"1\",\"foo\\\\bar\":\"1\",\"foo\\rbar\":\"1\",\"foo\\tbar\":\"1\",\"foo\\fbar\":\"1\"}") :schema schema)
;; => NIL
;; ("got errors validating properties
;;
;; Additionally:
;; - Value 1 is not of type \"number\".
;; - Value 1 is not of type \"number\".
;; - Value 1 is not of type \"number\".
;; - Value 1 is not of type \"number\".
;; - Value 1 is not of type \"number\".
;; - Value 1 is not of type \"number\".
;; ")

**Validating a document with a referenced schema**

If your data contains a top-level “$schema“ key, you don’t need to pass a schema along. It will be fetched and validated against automatically. This works with, for example, the ‘draft2019-09 meta-schema <https://json-schema.org/draft/2019-09/schema>‘_.

———–
Usage Notes
———–

~~~~~~~~
Contexts
~~~~~~~~

A context is a reusable set of state that contains all of the fetched network resources (if your schema references external resources) and resolved ids. By storing that all, you can reuse the validation context multiple times without fetching/resolving everything again.
::
(ql:quickload ’(trivial-benchmark json-schema))

(defvar *schema* (json-schema.parse:parse #P"~/Downloads/schema"))

;; schema is the json-schema meta schema document from:
;; https://json-schema.org/specification-links.html#draft-2019-09-formerly-known-as-draft-8

(defvar *context*
(json-schema:make-context
*schema*
:draft2019-09))

;;; Cached

(let ((data (json-schema.parse:parse "{\"type\": \"string\"}")))
(trivial-benchmark:with-timing (1000)
(json-schema:validate data
:context *context*)))

;; - SAMPLES TOTAL MINIMUM MAXIMUM MEDIAN AVERAGE DEVIATION
;; REAL-TIME 1000 0.826 0 0.022 0.001 0.000826 0.000797
;; RUN-TIME 1000 0.826 0 0.022 0.001 0.000826 0.0008
;; USER-RUN-TIME 1000 0.781011 0 0.020644 0.000745 0.000781 0.000665
;; SYSTEM-RUN-TIME 1000 0.049933 0 0.000986 0 0.00005 0.000184
;; PAGE-FAULTS 1000 0 0 0 0 0 0.0
;; GC-RUN-TIME 1000 0.02 0 0.02 0 0.00002 0.000632
;; BYTES-CONSED 1000 213753664 195344 228976 228032 213753.66 16221.591
;; EVAL-CALLS 1000 0 0 0 0 0 0.0

;;; Uncached

(let ((data (json-schema.parse:parse "{\"type\": \"string\"}")))
(trivial-benchmark:with-timing (1000)
(json-schema:validate data
:schema *schema*
:schema-version :draft2019-09)))

;; - SAMPLES TOTAL MINIMUM MAXIMUM MEDIAN AVERAGE DEVIATION
;; REAL-TIME 1000 203.185 0.148 1.471 0.185 0.203185 0.112807
;; RUN-TIME 1000 9.25 0.006 0.04 0.009 0.00925 0.002294
;; USER-RUN-TIME 1000 8.145081 0.003368 0.039067 0.008105 0.008145 0.002317
;; SYSTEM-RUN-TIME 1000 1.107377 0 0.004927 0.000994 0.001107 0.000967
;; PAGE-FAULTS 1000 0 0 0 0 0 0.0
;; GC-RUN-TIME 1000 0.08 0 0.03 0 0.00008 0.001464
;; BYTES-CONSED 1000 719780512 707728 751424 718160 719780.5 11026.181
;; EVAL-CALLS 1000 0 0 0 0 0 0.0

So, for this trivial example, the cached version is around a 245x speedup! Note, though, that json-schema evaluates these things lazily, so not every reference is necessarily resolved when the context is created. They are mutable, though, and will build up state as they go.

Thank you to ‘Raymond Wiker <https://github.com/rwiker>‘_ for contributing the initial implementation.

~~~~~~~~~~~~~
Decoding JSON
~~~~~~~~~~~~~

json-schema operates mostly on :class:‘cl:hash-table‘ objects. It requires them to have the “:test“ argument set to :function:‘cl:equal‘, so that they work with string keys. Further, it expects “:true“ and “:false“ as the boolean values and “:null“ as the decoded Javascript “null“. Javascrpit arrays should be rendered as lists. This behavior is provided behind the scenes by ‘st-json <https://marijnhaverbeke.nl/st-json/>‘_. The :function:‘json-schema.parse:parse‘ function provides this functionality over strings, streams, and pathnames for you.

~~~~~~~~~~~~~~
Network access
~~~~~~~~~~~~~~

JSON Schema allows schemas to reference other documents over the network. This library will fetch them automatically, by default. If you don’t want this to be allowed, you should set :variable:‘json-schema.reference:*resolve-remote-references*‘ to “nil“. If a schema references a remote one, it will raise a :class:‘json-schema.reference:fetching-not-allowed-error‘ instead of fetching it when fetching references is disallowed.

Version

2.0.0

Dependencies
Source

json-schema.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 json-schema.asd

Location

/home/quickref/quicklisp/dists/quicklisp/software/json-schema-20220220-git/json-schema.asd

Systems

json-schema (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 json-schema/utils.lisp

Parent

json-schema (system)

Location

utils.lisp

Packages

json-schema.utils

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 json-schema/parse.lisp

Parent

json-schema (system)

Location

parse.lisp

Packages

json-schema.parse

Exported Definitions

parse (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 json-schema/types.lisp

Parent

json-schema (system)

Location

types.lisp

Packages

json-schema.types

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 json-schema/reference.lisp

Parent

json-schema (system)

Location

reference.lisp

Packages

json-schema.reference

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 json-schema/formats.lisp

Parent

json-schema (system)

Location

formats.lisp

Packages

json-schema.formats

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.7 json-schema/validators.lisp

Parent

json-schema (system)

Location

validators.lisp

Packages

json-schema.validators

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.8 json-schema/json-schema.lisp

Parent

json-schema (system)

Location

json-schema.lisp

Packages

json-schema

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 json-schema.utils

Source

utils.lisp (file)

Use List
Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.2 json-schema.parse

Source

parse.lisp (file)

Use List
Exported Definitions

parse (function)


Next: , Previous: , Up: Packages   [Contents][Index]

4.3 json-schema.types

Source

types.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.4 json-schema.reference

Source

reference.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.5 json-schema.formats

Source

formats.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.6 json-schema.validators

Source

validators.lisp (file)

Use List
Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

4.7 json-schema

Source

json-schema.lisp (file)

Use List
Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *http-connect-timeout*

Number of seconds before a :class:‘remote-reference-error‘ will be signaled while trying to connect to a remote schema.

Package

json-schema.reference

Source

reference.lisp (file)

Special Variable: *http-read-timeout*

Number of seconds before a :class:‘remote-reference-error‘ will be signaled while trying to read a remote schema.

Package

json-schema.reference

Source

reference.lisp (file)

Special Variable: *resolve-remote-references*

Whether to download other schemas for references. Will error if another uri is referenced in a schema and this var is set to “nil“.

Package

json-schema.reference

Source

reference.lisp (file)

Special Variable: *schema-version*
Package

json-schema

Source

json-schema.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: with-context (CONTEXT) &body BODY
Package

json-schema.reference

Source

reference.lisp (file)

Macro: with-pushed-id (ID) &body BODY
Package

json-schema.reference

Source

reference.lisp (file)

Macro: with-resolved-ref (REF RESOLVED-SCHEMA &optional ID-FUN) &body BODY
Package

json-schema.reference

Source

reference.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: context-root-schema INSTANCE
Function: (setf context-root-schema) VALUE INSTANCE
Package

json-schema.reference

Source

reference.lisp (file)

Function: context-schema-version INSTANCE
Function: (setf context-schema-version) VALUE INSTANCE
Package

json-schema.reference

Source

reference.lisp (file)

Function: draft2019-09 VALUE TYPE
Package

json-schema.types

Source

types.lisp (file)

Function: draft2019-09 VALUE TYPE
Package

json-schema.formats

Source

formats.lisp (file)

Function: draft3 VALUE TYPE
Package

json-schema.types

Source

types.lisp (file)

Function: draft3 VALUE TYPE
Package

json-schema.formats

Source

formats.lisp (file)

Function: draft4 VALUE TYPE
Package

json-schema.types

Source

types.lisp (file)

Function: draft4 VALUE TYPE
Package

json-schema.formats

Source

formats.lisp (file)

Function: draft6 VALUE TYPE
Package

json-schema.types

Source

types.lisp (file)

Function: draft6 VALUE TYPE
Package

json-schema.formats

Source

formats.lisp (file)

Function: draft7 VALUE TYPE
Package

json-schema.types

Source

types.lisp (file)

Function: draft7 VALUE TYPE
Package

json-schema.formats

Source

formats.lisp (file)

Function: empty-object-p OBJECT
Package

json-schema.utils

Source

utils.lisp (file)

Function: fetch-schema URI

Fetches a remote document or raises an error depending on the value of :variable:‘*resolve-remote-references*‘.

Package

json-schema.reference

Source

reference.lisp (file)

Function: get-id-fun-for-schema-version SCHEMA-VERSION

Selects an id function that’s appropriate for each schema draft.

Package

json-schema.reference

Source

reference.lisp (file)

Function: json-equal-p THING1 THING2

A generic comparison function for comparing anything that might be a json value.

Package

json-schema.utils

Source

utils.lisp (file)

Function: json-pretty-printer STREAM JSON-OBJECT AT COLON
Package

json-schema.utils

Source

utils.lisp (file)

Function: make-context SCHEMA SCHEMA-VERSION

Given a root schema document :param:‘schema‘ and a json schema version :param:‘schema-version‘, create a reusable context object that will cache all schema data including remote references that get fetched.

Package

json-schema.reference

Source

reference.lisp (file)

Function: make-empty-object ()
Package

json-schema.utils

Source

utils.lisp (file)

Function: object-equal-p OBJECT1 OBJECT2
Package

json-schema.utils

Source

utils.lisp (file)

Function: object-get KEY OBJECT &optional DEFAULT
Package

json-schema.utils

Source

utils.lisp (file)

Function: object-keys OBJECT
Package

json-schema.utils

Source

utils.lisp (file)

Function: parse INPUT
Package

json-schema.parse

Source

parse.lisp (file)

Function: relative-reference-p REFERENCE
Package

json-schema.reference

Source

reference.lisp (file)

Function: resolve REF

Resolves a reference schema object to the referred-to schema.

Package

json-schema.reference

Source

reference.lisp (file)

Function: validate SCHEMA DATA &optional SCHEMA-VERSION IGNORE-ID
Package

json-schema.validators

Source

validators.lisp (file)

Function: validate DATA &key SCHEMA-VERSION PRETTY-ERRORS-P SCHEMA CONTEXT

The primary validation function for json-schema. Takes data: which can be a simple value or an object as a hash table, and then optionally accepts a schema (if the data doesn’t contain a top-level “$schema“ key), schema version and pretty-errors-p deterimines whether the second return value is exception objects or strings of the rendered errors (strings by default).

The third return value is a :class:‘json-schema.reference::context‘, which contains all of the state stored in processing a schema including caching network resources and all of the resolved ids.

Package

json-schema

Source

json-schema.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Conditions

Condition: fetching-not-allowed-error ()
Package

json-schema.reference

Source

reference.lisp (file)

Direct superclasses

reference-error (condition)

Direct slots
Slot: remote-uri
Initargs

:uri

Condition: nested-reference-error ()
Package

json-schema.reference

Source

reference.lisp (file)

Direct superclasses

reference-error (condition)

Condition: reference-error ()
Package

json-schema.reference

Source

reference.lisp (file)

Direct superclasses

error (condition)

Direct subclasses
Direct slots
Slot: message
Initargs

:message

Condition: remote-reference-error ()
Package

json-schema.reference

Source

reference.lisp (file)

Direct superclasses

reference-error (condition)

Direct slots
Slot: remote-uri
Initargs

:uri

Condition: validation-failed-error ()
Package

json-schema.validators

Source

validators.lisp (file)

Direct superclasses

error (condition)

Direct slots
Slot: error-message
Initargs

:error-message

Slot: property-name
Initargs

:property-name

Initform

(quote nil)

Slot: sub-errors
Initargs

:sub-errors

Initform

(quote nil)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Types

Type: json-array ()
Package

json-schema.utils

Source

utils.lisp (file)

Type: json-boolean ()
Package

json-schema.utils

Source

utils.lisp (file)

Type: json-null ()
Package

json-schema.utils

Source

utils.lisp (file)

Type: object ()
Package

json-schema.utils

Source

utils.lisp (file)

Type: schema ()
Package

json-schema.utils

Source

utils.lisp (file)

Type: schema-version ()
Package

json-schema.utils

Source

utils.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Constants

Constant: +hostname-regex+
Package

json-schema.formats

Source

formats.lisp (file)

Constant: +unreserved-uri-characters+
Package

json-schema.formats

Source

formats.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Special variables

Special Variable: *context*

The lookup context for references.

Package

json-schema.reference

Source

reference.lisp (file)

Special Variable: *current-lookup-depth*

Dynamic variable for tracking reference nesting depth.

Package

json-schema.reference

Source

reference.lisp (file)

Special Variable: *id-fun*

A default function for getting ids from schemas. Should return (values id found-p) like gethash.

Package

json-schema.reference

Source

reference.lisp (file)

Special Variable: *schema-version*
Package

json-schema.validators

Source

validators.lisp (file)

Special Variable: +max-lookup-depth+

Maximum number of nested references to allow before throwing a :class:‘nested-reference-error‘.

Package

json-schema.reference

Source

reference.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Macros

Macro: def-checker NAME &rest TYPES-PLIST
Package

json-schema.types

Source

types.lisp (file)

Macro: def-checker NAME &rest TYPES-PLIST
Package

json-schema.formats

Source

formats.lisp (file)

Macro: def-validator NAME &rest KEYS-PLIST
Package

json-schema.validators

Source

validators.lisp (file)

Macro: defvfun NAME VALIDATION-FIELD &body BODY
Package

json-schema.validators

Source

validators.lisp (file)

Macro: with-lookup-depth-tracking &body BODY
Package

json-schema.reference

Source

reference.lisp (file)

Macro: with-pushed-context (SCHEMA) &body BODY
Package

json-schema.reference

Source

reference.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Functions

Function: $ref SCHEMA REFERENCE DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: %make-context &key (ROOT-SCHEMA ROOT-SCHEMA) (SCHEMA-VERSION SCHEMA-VERSION) (URI-STACK URI-STACK) (REFERENCES REFERENCES) (NAMED-REFERENCES NAMED-REFERENCES)
Package

json-schema.reference

Source

reference.lisp (file)

Function: absolute-uri REFERENCE

Return an absolute URI for the reference in the current context.

Package

json-schema.reference

Source

reference.lisp (file)

Function: additional-items SCHEMA ADDITIONAL-ITEMS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: additional-properties SCHEMA VALUE DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: all-of SCHEMA SUB-SCHEMAS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: any-of SCHEMA SUB-SCHEMAS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: any-p VALUE
Package

json-schema.types

Source

types.lisp (file)

Function: array-p VALUE

Arrays are valid, but not strings.

Package

json-schema.types

Source

types.lisp (file)

Function: boolean-p VALUE
Package

json-schema.types

Source

types.lisp (file)

Function: check-dependencies PROPERTY-NAME DEPENDENCIES DATA &key ALLOW-ARRAYS ALLOW-OBJECTS
Package

json-schema.validators

Source

validators.lisp (file)

Function: collect-subschemas SCHEMA &key ID-FUN CURRENT-URI PROPERTIES-P

Collect all named subschemas into an alist of (name . schema-object).

Package

json-schema.reference

Source

reference.lisp (file)

Function: const SCHEMA CONST DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: contains SCHEMA CONTAINS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: context-named-references INSTANCE
Function: (setf context-named-references) VALUE INSTANCE
Package

json-schema.reference

Source

reference.lisp (file)

Function: context-p OBJECT
Package

json-schema.reference

Source

reference.lisp (file)

Function: context-references INSTANCE
Function: (setf context-references) VALUE INSTANCE
Package

json-schema.reference

Source

reference.lisp (file)

Function: context-uri-stack INSTANCE
Function: (setf context-uri-stack) VALUE INSTANCE
Package

json-schema.reference

Source

reference.lisp (file)

Function: copy-context INSTANCE
Package

json-schema.reference

Source

reference.lisp (file)

Function: date-time-p VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: datep VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: default-id-fun SCHEMA
Package

json-schema.reference

Source

reference.lisp (file)

Function: dependencies SCHEMA DEPENDENCIES DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: dependent-required SCHEMA DEPENDENCIES DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: dependent-schemas SCHEMA SCHEMAS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: description SCHEMA DESCRIPTION DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: draft2019-09 SCHEMA FIELD VALUE DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: draft2019-09-id-fun SCHEMA

An id extraction function that also pays attention to $anchor properties which provide only location-independent references.

Package

json-schema.reference

Source

reference.lisp (file)

Function: draft3-timep VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: draft4 SCHEMA FIELD VALUE DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: draft4-id-fun SCHEMA

Like the default, but id doesn’t have a $ prefix.

Package

json-schema.reference

Source

reference.lisp (file)

Function: draft6 SCHEMA FIELD VALUE DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: draft7 SCHEMA FIELD VALUE DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: durationp VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: emailp VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: enum SCHEMA MEMBERS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: escape STRING
Package

json-schema.reference

Source

reference.lisp (file)

Function: exclusive-maximum SCHEMA MAXIMUM DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: exclusive-minimum SCHEMA MINIMUM DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: fetch-reference URI

Fetches a schema and adds it to the current context as a side effect.

Package

json-schema.reference

Source

reference.lisp (file)

Function: format-validator SCHEMA TYPE DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: get-current-schema ()
Package

json-schema.reference

Source

reference.lisp (file)

Function: get-current-uri ()
Package

json-schema.reference

Source

reference.lisp (file)

Function: get-ref SPEC
Package

json-schema.reference

Source

reference.lisp (file)

Function: hostnamep VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: if-validator SCHEMA CONDITION-SCHEMA DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: integer-p VALUE

JSON Schema considers anything without a fractional part an integer, ie. 1.0d0 is an integer. 🤷

Package

json-schema.types

Source

types.lisp (file)

Function: ip-v4-address-p VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: ip-v6-address-p VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: items SCHEMA ITEMS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: json-pointer-p VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: lookup REFERENCE

Look up a schema by reference in the “*context*“. Returns “(values schema new-context-p)“. “new-context-p“ indicates that this schema is a new document that should be pushed to the context stack when visited.

Package

json-schema.reference

Source

reference.lisp (file)

Function: make-reference REFERENCE-STRING
Package

json-schema.reference

Source

reference.lisp (file)

Function: make-relative-path-list RELATIVE-PATH-STRING
Package

json-schema.reference

Source

reference.lisp (file)

Function: make-uri-without-fragment URI
Package

json-schema.reference

Source

reference.lisp (file)

Function: max-items SCHEMA LENGTH DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: max-length SCHEMA LENGTH DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: max-properties SCHEMA COUNT DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: maximum SCHEMA MAXIMUM DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: maximum-draft4 SCHEMA MAXIMUM DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: min-items SCHEMA LENGTH DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: min-length SCHEMA LENGTH DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: min-properties SCHEMA COUNT DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: minimum SCHEMA MINIMUM DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: minimum-draft4 SCHEMA MINIMUM DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: multiple-of SCHEMA DIVISOR DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: noop SCHEMA PROPERTY DATA

This exists to say we have taken care of a property, but we should do nothing with it. Likely because this property is actually handled by other things. “else“ and “then“ are handled by :function:‘if-validator‘, &c.

Package

json-schema.validators

Source

validators.lisp (file)

Function: not-validator SCHEMA SUB-SCHEMA DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: null-p VALUE
Package

json-schema.types

Source

types.lisp (file)

Function: object-p VALUE
Package

json-schema.types

Source

types.lisp (file)

Function: one-of SCHEMA SUB-SCHEMAS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: pattern SCHEMA PATTERN DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: pattern-properties SCHEMA PATTERNS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: pop-context ()
Package

json-schema.reference

Source

reference.lisp (file)

Function: populate-named-references-for-schema SCHEMA &key ID-FUN URI

Takes an alist of (uri . schema) and populates the appropriate hash tables in the named references slot of the context. Takes the output from collect subschemas, which may return named references for many uri’s, since documents are allowed to insist they have whatever uri they want whenever they want.

Package

json-schema.reference

Source

reference.lisp (file)

Function: properties SCHEMA PROPERTIES DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: property-names SCHEMA NAMES-SCHEMA DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: push-context SCHEMA &optional ID-FUN
Package

json-schema.reference

Source

reference.lisp (file)

Function: ref-p SPEC

A spec is a reference if it has only one key which is “$ref“.

Package

json-schema.reference

Source

reference.lisp (file)

Function: reference-eq REFERENCE1 REFERENCE2
Package

json-schema.reference

Source

reference.lisp (file)

Function: regexp VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: required SCHEMA REQUIRED-FIELDS DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: timep VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: type-validator SCHEMA TYPE DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: unescape STRING

Unescape a string to replace ~0 and ~1 with ~ and /.

Package

json-schema.reference

Source

reference.lisp (file)

Function: unevaluated-properties SCHEMA UNEVALUATED-PROPERTIES DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: unique-items SCHEMA UNIQUE DATA
Package

json-schema.validators

Source

validators.lisp (file)

Function: uri VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: uri-reference VALUE
Package

json-schema.formats

Source

formats.lisp (file)

Function: validate-type SCHEMA TYPE DATA

This is a tool for checking type validation, but isn’t a validator itself. It’s used by many of the validator functions to decide wether they can have an opinion on the data being validated, but is also used by :function:‘type-validator‘.

Package

json-schema.validators

Source

validators.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.5 Generic functions

Generic Function: relative-path-of OBJECT
Generic Function: (setf relative-path-of) NEW-VALUE OBJECT
Package

json-schema.reference

Methods
Method: relative-path-of (REFERENCE reference)

automatically generated reader method

Source

reference.lisp (file)

Method: (setf relative-path-of) NEW-VALUE (REFERENCE reference)

automatically generated writer method

Source

reference.lisp (file)

Generic Function: uri-of OBJECT
Generic Function: (setf uri-of) NEW-VALUE OBJECT
Package

json-schema.reference

Methods
Method: uri-of (REFERENCE reference)

automatically generated reader method

Source

reference.lisp (file)

Method: (setf uri-of) NEW-VALUE (REFERENCE reference)

automatically generated writer method

Source

reference.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.6 Conditions

Condition: no-validator-condition ()
Package

json-schema.validators

Source

validators.lisp (file)

Direct superclasses

condition (condition)

Direct slots
Slot: field-name
Initargs

:field-name


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.7 Structures

Structure: context ()

A container for all state related to resolving references, namely: a stack of context urls

Package

json-schema.reference

Source

reference.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: root-schema
Type

json-schema.utils:schema

Readers

context-root-schema (function)

Writers

(setf context-root-schema) (function)

Slot: schema-version
Type

json-schema.utils:schema-version

Readers

context-schema-version (function)

Writers

(setf context-schema-version) (function)

Slot: uri-stack
Type

(trivial-types:proper-list string)

Readers

context-uri-stack (function)

Writers

(setf context-uri-stack) (function)

Slot: references
Type

hash-table

Initform

(make-hash-table :test (quote equal))

Readers

context-references (function)

Writers

(setf context-references) (function)

Slot: named-references
Type

hash-table

Initform

(make-hash-table :test (quote equal))

Readers

context-named-references (function)

Writers

(setf context-named-references) (function)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.8 Classes

Class: reference ()
Package

json-schema.reference

Source

reference.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: relative-path
Type

(or string (trivial-types:proper-list string))

Initargs

:relative-path

Readers

relative-path-of (generic function)

Writers

(setf relative-path-of) (generic function)

Slot: uri
Type

string

Initargs

:uri

Readers

uri-of (generic function)

Writers

(setf uri-of) (generic function)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   J   L  
Index Entry  Section

F
File, Lisp, json-schema.asd: The json-schema․asd file
File, Lisp, json-schema/formats.lisp: The json-schema/formats․lisp file
File, Lisp, json-schema/json-schema.lisp: The json-schema/json-schema․lisp file
File, Lisp, json-schema/parse.lisp: The json-schema/parse․lisp file
File, Lisp, json-schema/reference.lisp: The json-schema/reference․lisp file
File, Lisp, json-schema/types.lisp: The json-schema/types․lisp file
File, Lisp, json-schema/utils.lisp: The json-schema/utils․lisp file
File, Lisp, json-schema/validators.lisp: The json-schema/validators․lisp file

J
json-schema.asd: The json-schema․asd file
json-schema/formats.lisp: The json-schema/formats․lisp file
json-schema/json-schema.lisp: The json-schema/json-schema․lisp file
json-schema/parse.lisp: The json-schema/parse․lisp file
json-schema/reference.lisp: The json-schema/reference․lisp file
json-schema/types.lisp: The json-schema/types․lisp file
json-schema/utils.lisp: The json-schema/utils․lisp file
json-schema/validators.lisp: The json-schema/validators․lisp file

L
Lisp File, json-schema.asd: The json-schema․asd file
Lisp File, json-schema/formats.lisp: The json-schema/formats․lisp file
Lisp File, json-schema/json-schema.lisp: The json-schema/json-schema․lisp file
Lisp File, json-schema/parse.lisp: The json-schema/parse․lisp file
Lisp File, json-schema/reference.lisp: The json-schema/reference․lisp file
Lisp File, json-schema/types.lisp: The json-schema/types․lisp file
Lisp File, json-schema/utils.lisp: The json-schema/utils․lisp file
Lisp File, json-schema/validators.lisp: The json-schema/validators․lisp file

Jump to:   F   J   L  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   $   %   (  
A   B   C   D   E   F   G   H   I   J   L   M   N   O   P   R   T   U   V   W  
Index Entry  Section

$
$ref: Internal functions

%
%make-context: Internal functions

(
(setf context-named-references): Internal functions
(setf context-references): Internal functions
(setf context-root-schema): Exported functions
(setf context-schema-version): Exported functions
(setf context-uri-stack): Internal functions
(setf relative-path-of): Internal generic functions
(setf relative-path-of): Internal generic functions
(setf uri-of): Internal generic functions
(setf uri-of): Internal generic functions

A
absolute-uri: Internal functions
additional-items: Internal functions
additional-properties: Internal functions
all-of: Internal functions
any-of: Internal functions
any-p: Internal functions
array-p: Internal functions

B
boolean-p: Internal functions

C
check-dependencies: Internal functions
collect-subschemas: Internal functions
const: Internal functions
contains: Internal functions
context-named-references: Internal functions
context-p: Internal functions
context-references: Internal functions
context-root-schema: Exported functions
context-schema-version: Exported functions
context-uri-stack: Internal functions
copy-context: Internal functions

D
date-time-p: Internal functions
datep: Internal functions
def-checker: Internal macros
def-checker: Internal macros
def-validator: Internal macros
default-id-fun: Internal functions
defvfun: Internal macros
dependencies: Internal functions
dependent-required: Internal functions
dependent-schemas: Internal functions
description: Internal functions
draft2019-09: Exported functions
draft2019-09: Exported functions
draft2019-09: Internal functions
draft2019-09-id-fun: Internal functions
draft3: Exported functions
draft3: Exported functions
draft3-timep: Internal functions
draft4: Exported functions
draft4: Exported functions
draft4: Internal functions
draft4-id-fun: Internal functions
draft6: Exported functions
draft6: Exported functions
draft6: Internal functions
draft7: Exported functions
draft7: Exported functions
draft7: Internal functions
durationp: Internal functions

E
emailp: Internal functions
empty-object-p: Exported functions
enum: Internal functions
escape: Internal functions
exclusive-maximum: Internal functions
exclusive-minimum: Internal functions

F
fetch-reference: Internal functions
fetch-schema: Exported functions
format-validator: Internal functions
Function, $ref: Internal functions
Function, %make-context: Internal functions
Function, (setf context-named-references): Internal functions
Function, (setf context-references): Internal functions
Function, (setf context-root-schema): Exported functions
Function, (setf context-schema-version): Exported functions
Function, (setf context-uri-stack): Internal functions
Function, absolute-uri: Internal functions
Function, additional-items: Internal functions
Function, additional-properties: Internal functions
Function, all-of: Internal functions
Function, any-of: Internal functions
Function, any-p: Internal functions
Function, array-p: Internal functions
Function, boolean-p: Internal functions
Function, check-dependencies: Internal functions
Function, collect-subschemas: Internal functions
Function, const: Internal functions
Function, contains: Internal functions
Function, context-named-references: Internal functions
Function, context-p: Internal functions
Function, context-references: Internal functions
Function, context-root-schema: Exported functions
Function, context-schema-version: Exported functions
Function, context-uri-stack: Internal functions
Function, copy-context: Internal functions
Function, date-time-p: Internal functions
Function, datep: Internal functions
Function, default-id-fun: Internal functions
Function, dependencies: Internal functions
Function, dependent-required: Internal functions
Function, dependent-schemas: Internal functions
Function, description: Internal functions
Function, draft2019-09: Exported functions
Function, draft2019-09: Exported functions
Function, draft2019-09: Internal functions
Function, draft2019-09-id-fun: Internal functions
Function, draft3: Exported functions
Function, draft3: Exported functions
Function, draft3-timep: Internal functions
Function, draft4: Exported functions
Function, draft4: Exported functions
Function, draft4: Internal functions
Function, draft4-id-fun: Internal functions
Function, draft6: Exported functions
Function, draft6: Exported functions
Function, draft6: Internal functions
Function, draft7: Exported functions
Function, draft7: Exported functions
Function, draft7: Internal functions
Function, durationp: Internal functions
Function, emailp: Internal functions
Function, empty-object-p: Exported functions
Function, enum: Internal functions
Function, escape: Internal functions
Function, exclusive-maximum: Internal functions
Function, exclusive-minimum: Internal functions
Function, fetch-reference: Internal functions
Function, fetch-schema: Exported functions
Function, format-validator: Internal functions
Function, get-current-schema: Internal functions
Function, get-current-uri: Internal functions
Function, get-id-fun-for-schema-version: Exported functions
Function, get-ref: Internal functions
Function, hostnamep: Internal functions
Function, if-validator: Internal functions
Function, integer-p: Internal functions
Function, ip-v4-address-p: Internal functions
Function, ip-v6-address-p: Internal functions
Function, items: Internal functions
Function, json-equal-p: Exported functions
Function, json-pointer-p: Internal functions
Function, json-pretty-printer: Exported functions
Function, lookup: Internal functions
Function, make-context: Exported functions
Function, make-empty-object: Exported functions
Function, make-reference: Internal functions
Function, make-relative-path-list: Internal functions
Function, make-uri-without-fragment: Internal functions
Function, max-items: Internal functions
Function, max-length: Internal functions
Function, max-properties: Internal functions
Function, maximum: Internal functions
Function, maximum-draft4: Internal functions
Function, min-items: Internal functions
Function, min-length: Internal functions
Function, min-properties: Internal functions
Function, minimum: Internal functions
Function, minimum-draft4: Internal functions
Function, multiple-of: Internal functions
Function, noop: Internal functions
Function, not-validator: Internal functions
Function, null-p: Internal functions
Function, object-equal-p: Exported functions
Function, object-get: Exported functions
Function, object-keys: Exported functions
Function, object-p: Internal functions
Function, one-of: Internal functions
Function, parse: Exported functions
Function, pattern: Internal functions
Function, pattern-properties: Internal functions
Function, pop-context: Internal functions
Function, populate-named-references-for-schema: Internal functions
Function, properties: Internal functions
Function, property-names: Internal functions
Function, push-context: Internal functions
Function, ref-p: Internal functions
Function, reference-eq: Internal functions
Function, regexp: Internal functions
Function, relative-reference-p: Exported functions
Function, required: Internal functions
Function, resolve: Exported functions
Function, timep: Internal functions
Function, type-validator: Internal functions
Function, unescape: Internal functions
Function, unevaluated-properties: Internal functions
Function, unique-items: Internal functions
Function, uri: Internal functions
Function, uri-reference: Internal functions
Function, validate: Exported functions
Function, validate: Exported functions
Function, validate-type: Internal functions

G
Generic Function, (setf relative-path-of): Internal generic functions
Generic Function, (setf uri-of): Internal generic functions
Generic Function, relative-path-of: Internal generic functions
Generic Function, uri-of: Internal generic functions
get-current-schema: Internal functions
get-current-uri: Internal functions
get-id-fun-for-schema-version: Exported functions
get-ref: Internal functions

H
hostnamep: Internal functions

I
if-validator: Internal functions
integer-p: Internal functions
ip-v4-address-p: Internal functions
ip-v6-address-p: Internal functions
items: Internal functions

J
json-equal-p: Exported functions
json-pointer-p: Internal functions
json-pretty-printer: Exported functions

L
lookup: Internal functions

M
Macro, def-checker: Internal macros
Macro, def-checker: Internal macros
Macro, def-validator: Internal macros
Macro, defvfun: Internal macros
Macro, with-context: Exported macros
Macro, with-lookup-depth-tracking: Internal macros
Macro, with-pushed-context: Internal macros
Macro, with-pushed-id: Exported macros
Macro, with-resolved-ref: Exported macros
make-context: Exported functions
make-empty-object: Exported functions
make-reference: Internal functions
make-relative-path-list: Internal functions
make-uri-without-fragment: Internal functions
max-items: Internal functions
max-length: Internal functions
max-properties: Internal functions
maximum: Internal functions
maximum-draft4: Internal functions
Method, (setf relative-path-of): Internal generic functions
Method, (setf uri-of): Internal generic functions
Method, relative-path-of: Internal generic functions
Method, uri-of: Internal generic functions
min-items: Internal functions
min-length: Internal functions
min-properties: Internal functions
minimum: Internal functions
minimum-draft4: Internal functions
multiple-of: Internal functions

N
noop: Internal functions
not-validator: Internal functions
null-p: Internal functions

O
object-equal-p: Exported functions
object-get: Exported functions
object-keys: Exported functions
object-p: Internal functions
one-of: Internal functions

P
parse: Exported functions
pattern: Internal functions
pattern-properties: Internal functions
pop-context: Internal functions
populate-named-references-for-schema: Internal functions
properties: Internal functions
property-names: Internal functions
push-context: Internal functions

R
ref-p: Internal functions
reference-eq: Internal functions
regexp: Internal functions
relative-path-of: Internal generic functions
relative-path-of: Internal generic functions
relative-reference-p: Exported functions
required: Internal functions
resolve: Exported functions

T
timep: Internal functions
type-validator: Internal functions

U
unescape: Internal functions
unevaluated-properties: Internal functions
unique-items: Internal functions
uri: Internal functions
uri-of: Internal generic functions
uri-of: Internal generic functions
uri-reference: Internal functions

V
validate: Exported functions
validate: Exported functions
validate-type: Internal functions

W
with-context: Exported macros
with-lookup-depth-tracking: Internal macros
with-pushed-context: Internal macros
with-pushed-id: Exported macros
with-resolved-ref: Exported macros

Jump to:   $   %   (  
A   B   C   D   E   F   G   H   I   J   L   M   N   O   P   R   T   U   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
C   E   F   M   N   P   R   S   U  
Index Entry  Section

*
*context*: Internal special variables
*current-lookup-depth*: Internal special variables
*http-connect-timeout*: Exported special variables
*http-read-timeout*: Exported special variables
*id-fun*: Internal special variables
*resolve-remote-references*: Exported special variables
*schema-version*: Exported special variables
*schema-version*: Internal special variables

+
+hostname-regex+: Internal constants
+max-lookup-depth+: Internal special variables
+unreserved-uri-characters+: Internal constants

C
Constant, +hostname-regex+: Internal constants
Constant, +unreserved-uri-characters+: Internal constants

E
error-message: Exported conditions

F
field-name: Internal conditions

M
message: Exported conditions

N
named-references: Internal structures

P
property-name: Exported conditions

R
references: Internal structures
relative-path: Internal classes
remote-uri: Exported conditions
remote-uri: Exported conditions
root-schema: Internal structures

S
schema-version: Internal structures
Slot, error-message: Exported conditions
Slot, field-name: Internal conditions
Slot, message: Exported conditions
Slot, named-references: Internal structures
Slot, property-name: Exported conditions
Slot, references: Internal structures
Slot, relative-path: Internal classes
Slot, remote-uri: Exported conditions
Slot, remote-uri: Exported conditions
Slot, root-schema: Internal structures
Slot, schema-version: Internal structures
Slot, sub-errors: Exported conditions
Slot, uri: Internal classes
Slot, uri-stack: Internal structures
Special Variable, *context*: Internal special variables
Special Variable, *current-lookup-depth*: Internal special variables
Special Variable, *http-connect-timeout*: Exported special variables
Special Variable, *http-read-timeout*: Exported special variables
Special Variable, *id-fun*: Internal special variables
Special Variable, *resolve-remote-references*: Exported special variables
Special Variable, *schema-version*: Exported special variables
Special Variable, *schema-version*: Internal special variables
Special Variable, +max-lookup-depth+: Internal special variables
sub-errors: Exported conditions

U
uri: Internal classes
uri-stack: Internal structures

Jump to:   *   +  
C   E   F   M   N   P   R   S   U  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   F   J   N   O   P   R   S   T   V  
Index Entry  Section

C
Class, reference: Internal classes
Condition, fetching-not-allowed-error: Exported conditions
Condition, nested-reference-error: Exported conditions
Condition, no-validator-condition: Internal conditions
Condition, reference-error: Exported conditions
Condition, remote-reference-error: Exported conditions
Condition, validation-failed-error: Exported conditions
context: Internal structures

F
fetching-not-allowed-error: Exported conditions

J
json-array: Exported types
json-boolean: Exported types
json-null: Exported types
json-schema: The json-schema system
json-schema: The json-schema package
json-schema.formats: The json-schema․formats package
json-schema.parse: The json-schema․parse package
json-schema.reference: The json-schema․reference package
json-schema.types: The json-schema․types package
json-schema.utils: The json-schema․utils package
json-schema.validators: The json-schema․validators package

N
nested-reference-error: Exported conditions
no-validator-condition: Internal conditions

O
object: Exported types

P
Package, json-schema: The json-schema package
Package, json-schema.formats: The json-schema․formats package
Package, json-schema.parse: The json-schema․parse package
Package, json-schema.reference: The json-schema․reference package
Package, json-schema.types: The json-schema․types package
Package, json-schema.utils: The json-schema․utils package
Package, json-schema.validators: The json-schema․validators package

R
reference: Internal classes
reference-error: Exported conditions
remote-reference-error: Exported conditions

S
schema: Exported types
schema-version: Exported types
Structure, context: Internal structures
System, json-schema: The json-schema system

T
Type, json-array: Exported types
Type, json-boolean: Exported types
Type, json-null: Exported types
Type, object: Exported types
Type, schema: Exported types
Type, schema-version: Exported types

V
validation-failed-error: Exported conditions

Jump to:   C   F   J   N   O   P   R   S   T   V