1.1 Status of this document

This document is managed in a public git repository hosted at http://github.com/gbv/daia. The specification can be distributed freely under the terms of CC-BY-SA.

See the list of releases for updates.

1.2 Conformance requirements

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.

2.1 Simple data types

The following data types are used to defined DAIA Response format.

string

A Unicode string. A DAIA client MUST treat fields with empty string value equal to non-existing fields. Strings SHOULD be normalized to Unicode Normalization Form C (NFC).

URI

A syntactically correct URI.

URL

A syntactically correct URL with HTTPS (RECOMMENDED) or HTTP scheme.

count

A non-negative integer.

boolean

A Boolean value (true or false).

datetime

An instant of time specified in the form YYYY-MM-DDThh:mm:ss(.ss)?(Z|[+-]hh:mm)? as defined with XML Schema datatype xsd:dateTime. A timezone indicator SHOULD be included.

anydate

A date as defined with XML Schema datatype xsd:date (YYYY-MM-DD(Z|[+-]hh:mm)?), a datetime as defined above, or the string unknown. A timezone indicator SHOULD be included.

duration

A duration as defined with XML Schema datatype xsd:duration or the string unknown.

service

An URI or a string with one of values presentation, loan, remote, interloan, and openaccess. DAIA clients SHOULD ignore other non-URI values.

entity

A non-empty JSON object with the following fields:

name	type		description
id	URI	RECOMMENDED	globally unique identifier of the entity
href	URL	OPTIONAL	web page about the entity
content	string	OPTIONAL	human-readable label, title or description of the entity

The language of field content SHOULD be given with HTTP response header Content-Language. A DAIA client MAY use the id field to retrieve additional information about the entity and it MAY override fields href and/or content with this information.

{
  "id": "http://viaf.org/viaf/151962300",
  "href": "https://www.loc.org/",
  "content": "Library of Congress"
}

2.2 DAIA Response

A DAIA Response is a JSON object with one REQUIRED and four OPTIONAL fields:

A DAIA Response sent by a DAIA server in response to a request MUST only contain documents matching queried request identifiers. A document matches a given request identifier if the request identifier is repeated in document field id, requested, or both. A DAIA Response MAY contain multiple documents that match the same request identifier.

DAIA clients MUST treat fields with empty JSON arrays (possible fields document, item, available, unavailable, and limitation) equal to non-existing fields. A DAIA server MAY include additional fields not included in this specification. Additional fields SHOULD be ignored by DAIA clients.

{
  "document": [ {
    "requested": "http://example.org/?issn=0302-9743&volume=9341&spage=26",
    "id": "http://dx.doi.org/10.1007/978-3-319-25639-9_5",
    "item": [ {
      "available": [ {
        "service": "openaccess",
        "href": "http://csarven.ca/this-paper-is-a-demo"
      } ]
    } ]
  } ]
}

2.3 Documents

A document is a JSON object with one REQUIRED and four OPTIONAL fields:

Documents typically refer to works or editions of publications.

GET /?format=json&id=PPN%2062486362X HTTP/1.1
Host: example.org
User-Agent: MyDAIAClient/1.0
Accept: application/json

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Language: en
X-DAIA-Version: 1.0.0

{
  "$schema": "http://gbv.github.io/daia/daia.schema.json",
  "institution": {
    "content": "Staats- und Universitätsbibliothek Hamburg",
    "href": "http://www.sub.uni-hamburg.de/"
  },
  "document": [
    {
      "href": "https://kataloge.uni-hamburg.de/DB=1/PPNSET?PPN=62486362X",
      "id": "http://d-nb.info/1001703464",
      "requested": "PPN 62486362X",
      "about": "Emma Goldman: Gelebtes Leben. Ed. Nautilus, 2010"
    }
  ]
}

2.4 Items

An item is a JSON object with the following fields:

Items refer to particular copies or holdings of documents. The value of field part MUST be one of narrower and broader, if given. Partial items refer to items which contain less (narrower) or more (broader) than the whole document. Some items MAY be identical with their document, for instance indistinguishable digital copies of a digital document. The field part MUST NOT be set in this case.

The department refers to a department of an institution that is resposible for or knows about availability of the item. DAIA clients SHOULD assume a general hierarchy between institution, department, and storage.

{
  "$schema": "http://gbv.github.io/daia/daia.schema.json",
  "document": [
    {
      "id": "urn:isbn:978-3-531-18621-4",
      "requested": "10.1007/978-3-531-19144-7_13",
      "item": [
        {
          "part": "broader",
          "available": [ { "service": "loan" } ]
        }
      ]
    },
    {
      "id": "http://dx.doi.org/10.1007/978-3-531-19144-7_13", 
      "requested": "10.1007/978-3-531-19144-7_13",
      "item": [
        {
          "id": "http://dx.doi.org/10.1007/978-3-531-19144-7_13", 
          "available": [ {
              "service": "presentation"
            },{
              "service": "loan",
              "limitation": [ {
                "id": "http://purl.org/ontology/dso#ShortLoan"
              } ]
            }
          ],
          "unavailable": [ { "service": "openaccess" } ]
        }
      ]
    }
  ]
}

2.5 Services

A service is something that an item is currently accessible or unaccessible for (availability fields available and unavailable of item). Each service has a service type to define what can be done with a given item. A service type MUST be identified by an URI. Abbreviated names SHOULD be used for the following predefined DAIA service types.

A DAIA server SHOULD NOT omit services because of assumed implications between service types (for instance most times an item is available for loan it is also available for presentation) but include all service types it knows about.

2.6 Availability

{ "service": "presentation" }
{ "service": "loan" }

{ "service": "interloan" }

{ "service": "presentation", "href": "http://example.org/request" }
{ "service": "loan",         "href": "http://example.org/request" }
{ "service": "interloan",    "href": "http://example.org/request" }

{ "service": "openaccess", "href": "http://example.org/request" }

{ "service": "openaccess" }

{
  "available": [ { 
    "service": "presentation",
    "delay": "PT2H",
  },{ 
    "service": "http://example.org/digitize",
    "href": "http://example.org/request?service=digitize&doc=1234"
  } ],
  "unavailable": [ { 
    "service": "loan",
    "expected": "unknown" 
  } ]
}

{
  "available": [ {
    "service": "presentation",
    "limitation": [ { "id": "http://example.org/restricted" } ]
  } ],
  "unavailable": [ {
    "service": "presentation",
    "expected": "2017-03-07"
  } ]
}

2.7 Limitations

A service can be restricted by limitations, given as entity. It is RECOMMENDED to identity types of service limitations with an URI (field id) but unspecified, free-text limitations (field content) are possible as well.

DAIA clients are not required to understand limitation types so they MAY map all limitations to the same “unknown” kind of limitation. DAIA servers SHOULD NOT use limitations to transport arbitrary messages that do not correspond to real impairments of a service. The following limitation types are RECOMMENDED to be used by DAIA servers and to be understood by DAIA clients if applicable:

In addition, limitation types with base URI http://creativecommons.org/license/ are applicable with service type openaccess.

{ 
  "id": "example:document",
  "items": [ 
    {
      "id": "example:section:1",
      "part": "narrower",
      "available": {
        "service": "remote" 
      }
    }
  ]
}

{ 
  "id": "example:document",
  "items": [ 
    {
      "id": "example:all-sections",
      "available": {
        "service": "remote",
        "limitation": [
          { "id": "http://purl.org/ontology/dso#PartialDelivery" }
        ]
      }
    }
  ]
}

{
  "available": [ {
    "service": "interloan",
    "limitation": [ {
      "id": "http://purl.org/ontology/dso#PhysicalDelivery",
      "content": "Only paper copy to patron"
    }, {
      "id": "http://purl.org/ontology/dso#NoForeignCountry",
      "content": "Only domestic loans"
    } ]
  } ]
}

{
  "about": "Editorial Introduction: The Code4Lib Journal Experiment, Rejection Rates, and Peer Review", 
  "available": [ { 
    "service": "openaccess",
    "href": "http://journal.code4lib.org/articles/3277",
    "limitation": [ {
      "id": "http://creativecommons.org/licenses/by/3.0/us/",
      "href": "https://creativecommons.org/licenses/by/3.0/us/",
      "content": "CC-BY 3.0 US"
    } ]
  } ]
}

{
  "about": "Uncle Tom's Cabin",
  "available": [ {
    "service": "openaccess",
    "href": "https://archive.org/details/uncle_toms_cabin_librivox",
    "limitation": [ {
      "id": "http://creativecommons.org/licenses/publicdomain/",
      "href": "https://creativecommons.org/licenses/publicdomain/",
      "content": "Public Domain"
    } ]
  } ]
}

2.8 Chronology

A chronology is a JSON object with one OPTIONAL field:

A chronology specifies the extend of a partitioned item such as a serial in terms of time spans, volumes, and issues. A later version of DAIA specification will define addition fields to express this information in structured form. DAIA clients SHOULD therefore ignore unknown fields in a chronology object until they can refer to a later version of DAIA.

Item field part SHOULD be set to narrower if a chronology is given and the chronology does not cover the full extent of the document (for instance not all issues of a journal).

{
  "about": "v.1/1920-19/1939, v.21/1941, v.36/1956-"
}

{
  "document": [
    {
      "id": "urn:issn:0370–2316",
      "item": [
        {
          "about": "first issue of Philosophical Transactions",
          "chronology": {
            "about": "volume 1, issue 1 (1665)"
          },
          "part": "narrower"
        }
      ]
    }
  ]
}

2.9 Integrity rules

DAIA data model is specified using JSON but it can also be expressed in other data structuring languages such as RDF. For this reason and to avoid misleading data instances, the following integrity rules MUST be met in a DAIA Response:

1. Documents and items are unique: all Documents and Items MUST have unique values in field id, if given. As exception a document with a single item that does not have field part set MAY share the same id with its item (for instance a unique physical item without dedicated document identifier).

2. Institution is is disjoint to departments and storages within the same DAIA response: The value of field institution.id SHOULD NOT occur as id of another entity (storage, department, and limitation).

3. Limitations (field id) MUST be disjoint with other entities (institution, storage, and department).

4. Storages are subordinated to departments: The value of field id in Item entity storage MUST NOT be equal to field id of entity department of the same item.

5. An Item MUST NOT have an available service and an unavailable service with the same service type (field service) and equal values in field limitation. Two limitation entities are equal if thei share the same field id or if they both have no id and same field values href and content.

{
  "document": [
    { "id": "http://example.org/123" },
    { "id": "http://example.org/123",
      "item": [ { "id": "http://example.org/123" } ] }
  ]
}

{
  "document": [ {
    "id": "http://example.org/123",
    "item": [ {
      "department": "http://example.org/archive"
    },{
      "department": "http://example.org/main",
      "storage": "http://example.org/archive"
    } ]
}

{
  "available": [ { "service": "presentation", "href": "http://example.org/request" } ],
  "unavailable": [ { "service": "presentation" } ]
}

3.1 Query parameters

A DAIA server MUST respect following query parameters:

id

query id with one or multiple request identifiers of documents or items.

format

set to json. If this parameter is missing or not set to json, a DAIA server SHOULD sent an error response with HTTP status code 422 (invalid request). For backwards compatibility with previous implementations, a DAIA server MAY also response with HTTP status code 200 and with an arbitrary document (HTML, XML…) if no format parameter was given or if its value was not json.

callback

a JavaScript callback method name to return JSONP instead of JSON. The callback MUST only contain alphanumeric characters and underscores.

patron

a patron identifier for patron-specific availability.

patron-type

a patron identifier for patron-specific availability.

access_token

an access token for authentication. A DAIA client MUST use HTTPS when sending access tokens.

suppress_response_codes

if this parameter is present, all responses MUST be returned with a 200 OK status code, even an error response. Support of this parameter is OPTIONAL.

GET /?id=x:a%7Cx:b%7Cx:c%7Cx:d%7Cx:e&format=json HTTP/1.1
Host: example.org
User-Agent: MyDAIAClient/1.0
Accept: application/json

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Language: en
X-DAIA-Version: 1.0.0
Link: <https://example.org/?id=x:d%7Cx:e&format=json>; rel="next"

{ "document": [ { "id": "some:uri" } ] }

?format=json&id=x:a%7Cx:b%7Cx:c
?format=json&id=x:a%7Cx:b|x:c
?format=json&id=x:a|x:b%7Cx:c
?format=json&id=x:a|x:b|x:c

3.2 Request headers

A DAIA client SHOULD sent the following HTTP request headers:

User-Agent

with an appropriate client name and version number.

Accept

with the value application/json.

A DAIA client MAY sent the following HTTP request headers:

Accept-Language

to indicate preferred languages of human-readable response fields (content, about, error_description).

Authorization

to provide an OAuth 2 Bearer token for authentication.

For OPTIONS preflight requests of Cross-Origin Resource Sharing (CORS) a DAIA client MUST include the following HTTP request headers:

Origin

where the cross-origin request originates from.

Access-Control-Request-Method

the HTTP verb GET.

Access-Control-Request-Headers

the value Authorization if access tokens are sent as HTTP headers.

Note that DAIA clients do not need to respect CORS rules. CORS preflight requests in browsers can be avoided by omitting the request headers Accept and Authorization.

3.3 Response headers

A DAIA server SHOULD sent the following HTTP response headers with every DAIA Response:

Content-Language

to indicate the language of human-readable response fields (content, about, error_description).

Access-Control-Allow-Origin

to allow Cross-Origin Resource Sharing, this header SHOULD be set to *.

Link

URL of a DAIA profile document with RFC 5988 relation type profile. Also a request URL with unprocessed request identifiers (if given) and relation type next.

A DAIA server MUST sent the following HTTP response headers:

Content-Type

the value application/json or application/json; charset=utf-8 for JSON response; the value application/javascript or application/javascript; charset=utf-8 for JSONP response.

X-DAIA-Version

the version of DAIA specification which the server was checked against.

Access-Control-Allow-Headers

In response to an OPTIONS request this header MUST include the value Content-Type and, if authentication is supported, the value Authorization.

3.4 Error responses

A DAIA server SHOULD use HTTP status codes to indicate server errors and client request errors. An error response SHOULD include a JSON object with the following fields:

error

alphanumeric error code.

code

HTTP status code.

error_description

human-readable error description (OPTIONAL).

error_uri

human-readable web page about the error (OPTIONAL).

The following error responses are expected:

A DAIA server SHOULD never return a HTTP 404 error if queried at its base URL. In particular a DAIA server MUST NOT respond with a HTTP 404 status code for missing or unknown request identifiers.

3.5 Patron-specific availability

A DAIA server MAY support patron-specific availability with the query parameter patron and/or patron-type. The patron parameter can be used to refer to a particular patron and the patron-type parameter can be used to refer to a particular type of patrons.

Definiton of patron types is out of the scope of this specification. It is RECOMMENDED to use URIs for identification of both patrons and patron types.

A DAIA client SHOULD NOT include both parameters in the same request. A DAIA server SHOULD return an error response status 422 (invalid request) if both are given or if given values are unknown or invalid. A DAIA server SHOULD return an error response status 501 (not supported) if it does not support patron-specific availability for patron or patron-type respectively.

Patron-specific availability SHOULD be combined with authentication.

http://example.org/?format=json&id=doc:rare&patron-type=http%3A%2F%2Fexample.org%2Ftype%2Fstudent

{
  "document": [ {
    "id": "doc:rare",
    "item": [ {
      "available": [ { "service": "presentation" } ],
      "unavailable": [ { "service": "loan" } ]
    } ]
  } ]
}

http://example.org/?format=json&id=doc:rare&patron-type=http%3A%2F%2Fexample.org%2Ftype%2Fresearcher

{
  "document": [ {
    "id": "doc:rare",
    "item": [ {
      "available": [ 
        { "service": "presentation" },
        { "service": "loan" }
      ] 
    } ]
  } ]
}

http://example.org/?format=json&id=doc:rare

{
  "document": [ {
    "id": "doc:rare",
    "item": [ {
      "available": [ 
        { "service": "presentation" }, 
        { 
          "service": "loan",
          "limitation": [ { 
              "href": "http://example.org/rare-book-lending/",
                "content": "only for researchers"
          } ]
        } 
      ]
    } ]
  } ]
}

3.6 Authentication

A DAIA server MAY support authentfication via OAuth 2.0 bearer tokens (RFC 6750). Access tokens can be provided either as URL query parameter access_token or in the HTTP request header Authorization.

A DAIA server that supports authentication, MUST also support HTTP OPTIONS requests for CORS.

DAIA server and client MUST use HTTPS when sending and receiving access tokens.

Distribution of access tokens is out of the scope of this specification.

When also using PAIA it is RECOMMENDED to issue access tokens via PAIA auth and add a scope named read_availability for authentificated access to a DAIA server.

GET /?format=json&id=some:doc HTTP/1.1
Host: example.org
User-Agent: MyDAIAClient/1.0
Accept: application/json
Authorization: Bearer vF9dft4qmT

GET /?format=json&id=some:doc&access_token=vF9dft4qmT HTTP/1.1
Host: example.org
User-Agent: MyDAIAClient/1.0
Accept: application/json

3.7 Profiles

A DAIA Server SHOULD supply a profile in form of a JSON document. The DAIA profile MUST be referred to in a HTTP Link header as part of Response headers.

HTTP/1.1 200 OK
Content-Language: en
Access-Control-Allow-Origin: *
Link: <https://example.org/profile.json>; rel="profile"
Content-Type: application/json; charset=utf-8
X-DAIA-Version: 1.0.0
Access-Control-Allow-Headers: Authorization, Content-Type
Access-Control-Allow-Methods: GET, HEAD, OPTIONS

4.1 Normative References

• Berners-Lee, T., Fielding R., Masinter L. 2005. “RFC 3986: Uniform Resource Identifiers (URI): Generic Syntax”. http://tools.ietf.org/html/rfc3986.

• Biron, P. V., Malhotra, A. 2004. “XML Schema Part 2: Datatypes Second Edition”. http://www.w3.org/TR/xmlschema-2/.

• Bradner, S. 1997. “RFC 2119: Key words for use in RFCs to Indicate Requirement Levels”. http://tools.ietf.org/html/rfc2119.

• Crockford, D. 2006. “RFC 6427: The application/json Media Type for JavaScript Object Notation (JSON)”. http://tools.ietf.org/html/rfc4627.

• Fielding, R. 1999. “RFC 2616: Hypertext Transfer Protocol”. http://tools.ietf.org/html/rfc2616.

• Jones, M. and Hardt, D. 2012. “RFC 6750: The OAuth 2.0 Authorization Framework: Bearer Token Usage”. http://tools.ietf.org/html/rfc6750.

• Nottingham, M. 2010. “RFC 5988: Web Linking”. http://tools.ietf.org/html/rfc5988.

• van Kesteren, A. 2014. “Cross-Origin Resource Sharing” http://www.w3.org/TR/cors/.

4.2 Informal References

• Davis, M. and Whistler, K.: “Unicode Normalization Forms”. Unicode Standard Annex #15. http://www.unicode.org/reports/tr15/.

• Wright, A. and Andrews, H. 2017: “JSON Schema”. https://tools.ietf.org/html/draft-wright-json-schema-01

• Sporny, M. et al., 2014: “JSON-LD 1.0”. https://www.w3.org/TR/json-ld/

• Voß, J. 2017. “Patrons Account Information API (PAIA)” http://gbv.github.io/paia/.

4.3 Revision history

This is version 1.0.0 of DAIA specification, last modified at 2017-06-23 with revision 1d1ea4b.

Version numbers follow Semantic Versioning: each number consists of three numbers, optionally followed by + and a suffix:

• The major version (first number) is increased if changes require a modification of DAIA clients
• The minor version (second number) is increased if changes require a modification of DAIA servers
• The patch version (third number) is increased for backwards compatible fixes or extensions, such as the introduction of new optional fields
• The optional suffix indicates informal changes in documentation

Before version 1.0.0 the patch version was used as minor version.

5.1 DAIA Simple

DAIA Simple is simplified alternative to DAIA Response format for a particular document limited to a typical use case of availability information. A DAIA client could map DAIA Response to DAIA Simple or a DAIA server could directly support DAIA Simple as additional response when query parameter “format” is set to simple.

A DAIA Simple object is a plain JSON object with the following fields, based on simple data types:

{ "service": "loan", "available": true }
{ "service": "loan", "available": false, "expected": "2014-12-07" }
{ "service": "presentation", "available": true }
{ "service": "openaccess", "available": true, "href": "http://dx.doi.org/10.1901%2Fjaba.1974.7-497a" }

5.2 JSON Schema

The following JSON Schema daia.schema.json can be used to validate DAIA Response format without integrity rules.

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "additionalProperties": false,
  "properties": {
    "$schema": {
      "$ref": "#/types/URL"
    },
    "@context": {
      "$ref": "#/types/URL"
    },
    "document": {
      "items": {
        "$ref": "#/types/document"
      },
      "type": "array"
    },
    "institution": {
      "$ref": "#/types/entity"
    },
    "timestamp": {
      "$ref": "#/types/datetime"
    }
  },
  "required": [
    "document"
  ],
  "type": "object",
  "types": {
    "URI": {
      "format": "uri",
      "type": "string"
    },
    "URL": {
      "allOf": [
        {
          "format": "uri",
          "type": "string"
        },
        {
          "pattern": "^https?:",
          "type": "string"
        }
      ]
    },
    "anydate": {
      "anyOf": [
        {
          "pattern": "^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9](Z|[+-][0-9][0-9]:[0-9][0-9])?$",
          "type": "string"
        },
        {
          "enum": [
            "unknown"
          ]
        }
      ]
    },
    "available": {
      "additionalProperties": false,
      "properties": {
        "delay": {
          "$ref": "#/types/duration"
        },
        "href": {
          "$ref": "#/types/URL"
        },
        "limitation": {
          "items": {
            "$ref": "#/types/entity"
          },
          "type": "array"
        },
        "service": {
          "$ref": "#/types/service"
        },
        "title": {
          "type": "string"
        }
      },
      "required": [
        "service"
      ],
      "type": "object"
    },
    "chronology": {
      "additionalProperties": true,
      "properties": {
        "about": {
          "type": "string"
        }
      },
      "type": "object"
    },
    "count": {
      "minimum": 1,
      "type": "integer"
    },
    "datetime": {
      "format": "date-time",
      "type": "string"
    },
    "document": {
      "additionalProperties": false,
      "properties": {
        "about": {
          "type": "string"
        },
        "href": {
          "$ref": "#/types/URL"
        },
        "id": {
          "$ref": "#/types/URI"
        },
        "item": {
          "items": {
            "$ref": "#/types/item"
          },
          "type": "array"
        },
        "requested": {
          "type": "string"
        }
      },
      "required": [
        "id"
      ],
      "type": "object"
    },
    "duration": {
      "anyOf": [
        {
          "pattern": "^-?P([0-9]+Y)?([0-9]+M)?([0-9]+D)?T?([0-9]+H)?([0-9]+M)?([0-9]+(\\.[0-9]+)?S)?$",
          "type": "string"
        },
        {
          "enum": [
            "unknown"
          ]
        }
      ]
    },
    "entity": {
      "additionalProperties": false,
      "properties": {
        "content": {
          "type": "string"
        },
        "href": {
          "$ref": "#/types/URL"
        },
        "id": {
          "$ref": "#/types/URI"
        }
      },
      "type": "object"
    },
    "item": {
      "additionalProperties": false,
      "properties": {
        "about": {
          "type": "string"
        },
        "available": {
          "items": {
            "$ref": "#/types/available"
          },
          "type": "array"
        },
        "chronology": {
          "$ref": "#/types/chronology"
        },
        "department": {
          "$ref": "#/types/entity"
        },
        "href": {
          "$ref": "#/types/URL"
        },
        "id": {
          "$ref": "#/types/URI"
        },
        "label": {
          "type": "string"
        },
        "part": {
          "enum": [
            "broader",
            "narrower"
          ]
        },
        "storage": {
          "$ref": "#/types/entity"
        },
        "unavailable": {
          "items": {
            "$ref": "#/types/unavailable"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "service": {
      "anyOf": [
        {
          "$ref": "#/types/URI"
        },
        {
          "enum": [
            "presentation",
            "loan",
            "remote",
            "interloan",
            "openaccess"
          ]
        }
      ]
    },
    "unavailable": {
      "additionalProperties": false,
      "properties": {
        "expected": {
          "$ref": "#/types/anydate"
        },
        "href": {
          "$ref": "#/types/URL"
        },
        "limitation": {
          "items": {
            "$ref": "#/types/entity"
          },
          "type": "array"
        },
        "queue": {
          "$ref": "#/types/count"
        },
        "service": {
          "$ref": "#/types/service"
        },
        "title": {
          "type": "string"
        }
      },
      "required": [
        "service"
      ],
      "type": "object"
    }
  }
}