openapi.city
Sign in

Oxford Dictionaries

Dictionary and language data API

developer.oxforddictionaries.com ↗
Version
1.11.0
OpenAPI
3.0.0
Endpoints
26
Schemas
36
Updated
3 days ago
Reference reference language dictionary
Use this API in your AI agent

Query structured spec data via REST or MCP. Get exactly what your agent needs.

Get API Key

Server URLs

https://od-api-demo.oxforddictionaries.com:443/api/v1

Authentication

apiKey apiKey

Endpoints

GET POST PUT PATCH DELETE

Dictionary entries 3 endpoints

GET /entries/{source_lang}/{word_id}

Use this to retrieve definitions, [pronunciations](documentation/glossary?term=pronunciation), example sentences, [grammatical information](documentation/glossary?term=grammaticalfeatures) and [word origins](documentation/glossary?term=etymology). It only works for dictionary [headwords](documentation/glossary?term=headword), so you may need to use the [Lemmatron](documentation/glossary?term=lemma) first if your input is likely to be an [inflected](documentation/glossary?term=inflection) form (e.g., 'swimming'). This would return the linked [headword](documentation/glossary?term=headword) (e.g., 'swim') which you can then use in the Entries endpoint. Unless specified using a region filter, the default lookup will be the Oxford Dictionary of English (GB). <div id="dictionary_entries"></div>

operationId: DictionaryEntries_getInformation

Parameters

Name In Required Type Description
source_lang path required string IANA language code
word_id path required string An Entry identifier. Case-sensitive.

Responses

200 Successful response.
404 No entry is found matching supplied id and source_lang or filters are not recognized
500 Internal Error. An error occurred while processing the data.
GET /entries/{source_lang}/{word_id}
GET /entries/{source_lang}/{word_id}/regions={region}

USe this filter to restrict the lookup to either our Oxford Dictionary of English (GB) or New Oxford American Dictionary (US).

operationId: DictionaryEntries_specifyDictionaryRegion

Parameters

Name In Required Type Description
source_lang path required string IANA language code
word_id path required string An Entry identifier. Case-sensitive.
region path required string Region filter parameter. gb = Oxford Dictionary of English. us = New Oxford American Dictionary.

Responses

200 Successful response.
404 no entry is found matching supplied source_lang and id and/or that entry has no senses with translations in the target language.
500 Internal Error. An error occurred while processing the data.
GET /entries/{source_lang}/{word_id}/regions={region}
GET /entries/{source_lang}/{word_id}/{filters}

Use filters to limit the [entry](documentation/glossary?term=entry) information that is returned. For example, you may only require definitions and not everything else, or just [pronunciations](documentation/glossary?term=pronunciation). The full list of filters can be retrieved from the filters Utility endpoint. You can also specify values within the filter using '='. For example 'grammaticalFeatures=singular'. Filters can also be combined using a semicolon. <div id="dictionary_entries_filters"></div>

operationId: DictionaryEntries_applyFilters

Parameters

Name In Required Type Description
source_lang path required string IANA language code
word_id path required string An Entry identifier. Case-sensitive.
filters path required string Separate filtering conditions using a semicolon. Conditions take values grammaticalFeatures and/or lexicalCategory and are case-sensitive. To list multiple values in single condition divide them with comma.

Responses

200 Successful response.
404 no entry is found matching supplied source_lang and id and/or that entry has no senses with translations in the target language.
500 Internal Error. An error occurred while processing the data.
GET /entries/{source_lang}/{word_id}/{filters}

Lemmatron 1 endpoints

GET /inflections/{source_lang}/{word_id}/{filters}

Use this to check if a word exists in the dictionary, or what 'root' form it links to (e.g., swimming > swim). The response tells you the possible [lemmas](documentation/glossary?term=lemma) for a given [inflected](documentation/glossary?term=inflection) word. This can then be combined with other endpoints to retrieve more information. <div id="lemmatron"></div>

operationId: Lemmatron_checkAndRetrieveRootForm

Parameters

Name In Required Type Description
source_lang path required string IANA language code
filters path required string Separate filtering conditions using a semicolon. Conditions take values grammaticalFeatures and/or lexicalCategory and are case-sensitive. To list multiple values in single condition divide them with comma.
word_id path required string The input word

Responses

200 Successful response.
500 Internal Error. An error occurred while processing the data.
GET /inflections/{source_lang}/{word_id}/{filters}

Lexistats 3 endpoints

GET /stats/frequency/ngrams/{source_lang}/{corpus}/{ngram-size}

This endpoint returns frequencies of ngrams of size 1-4. That is the number of times a word (ngram size = 1) or words (ngram size > 1) appear in the corpus. Ngrams are case sensitive ("I AM" and "I am" will have different frequency) and frequencies are calculated per word (true case) so "the book" and "the books" are two different ngrams. The results can be filtered based on query parameters. <br> <br> Parameters can be provided in PATH, GET or POST (form or json). The parameters in PATH are overridden by parameters in GET, POST and json (in that order). In PATH, individual options are separated by semicolon and values are separated by commas (where multiple values can be used). <br> <br> Example for bigrams (ngram of size 2): * PATH: /tokens=a word,another word * GET: /?tokens=a word&tokens=another word * POST (json): ```javascript { "tokens": ["a word", "another word"] } ``` Either "tokens" or "contains" has to be provided. <br> <br> Some queries with "contains" or "sort" can exceed the 30s timeout, in which case the API will return an error message with status code 503. You mitigate this by providing additional restrictions such as "minFrequency" and "maxFrequency". <br> <br> You can use the parameters "offset" and "limit" to paginate through large result sets. For convenience, the HTTP header "Link" is set on the response to provide links to "first", "self", "next", "prev" and "last" pages of results (depending on the context). For example, if the result set contains 50 results and the parameter "limit" is set to 25, the Links header will contain an URL for the first 25 results and the next 25 results. <br> <br> Some libraries such as python's `requests` can parse the header automatically and offer a convenient way of iterating through the results. For example: ```python def get_all_results(url): while url: r = requests.get(url) r.raise_for_status() for item in r.json()['results']: yield item url = r.links.get('next', {}).get('url') ```

operationId: LexiStats_getNgramFrequencies

Parameters

Name In Required Type Description
source_lang path required string IANA language code
corpus path required string For corpora other than 'nmc' (New Monitor Corpus) please contact api@oxforddictionaries.com
ngram-size path required string the size of ngrams requested (1-4)
tokens query optional string List of tokens to filter. The tokens are separated by spaces, the list items are separated by comma (e.g., for bigrams (n=2) tokens=this is,this was, this will)
contains query optional string Find ngrams containing the given token(s). Use comma or space as token separators; the order of tokens is irrelevant.
punctuation query optional string Flag specifying whether to lookup ngrams that include punctuation or not (possible values are "true" and "false"; default is "false")
format query optional string Option specifying whether tokens should be returned as a single string (option "google") or as a list of strings (option "oup")
minFrequency query optional integer Restrict the query to entries with frequency of at least `minFrequency`
maxFrequency query optional integer Restrict the query to entries with frequency of at most `maxFrequency`
minDocumentFrequency query optional integer Restrict the query to entries that appear in at least `minDocumentFrequency` documents
maxDocumentFrequency query optional integer Restrict the query to entries that appera in at most `maxDocumentFrequency` documents
collate query optional string collate the results by wordform, trueCase, lemma, lexicalCategory. Multiple values can be separated by commas (e.g., collate=trueCase,lemma,lexicalCategory).
sort query optional string sort the resulting list by wordform, trueCase, lemma, lexicalCategory, frequency, normalizedFrequency. Descending order is achieved by prepending the value with the minus sign ('-'). Multiple values can be separated by commas (e.g., sort=lexicalCategory,-frequency)
offset query optional integer pagination - results offset
limit query optional integer pagination - results limit

Responses

200 Successful response.
400 Invalid option name...
404 language is not in...
500 Internal Error. An error occurred while processing the data.
GET /stats/frequency/ngrams/{source_lang}/{corpus}/{ngram-size}
GET /stats/frequency/word/{source_lang}

This endpoint provides the frequency of a given word. When multiple database records match the query parameters, the returned frequency is the sum of the individual frequencies. For example, if the query parameters are lemma=test, the returned frequency will include the verb "test", the noun "test" and the adjective "test" in all forms (Test, tested, testing, etc.) <br> <br> If you are interested in the frequency of the word "test" but want to exclude other forms (e.g., tested) use the option trueCase=test. Normally, the word "test" will be spelt with a capital letter at the beginning of a sentence. The option trueCase will ignore this and it will count "Test" and "test" as the same token. If you are interested in frequencies of "Test" and "test", use the option wordform=test or wordform=Test. Note that trueCase is not just a lower case of the word as some words are genuinely spelt with a capital letter such as the word "press" in Oxford University Press. <br> <br> Parameters can be provided in PATH, GET or POST (form or json). The parameters in PATH are overriden by parameters in GET, POST and json (in that order). In PATH, individual options are separated by semicolon and values are separated by commas (where multiple values can be used). Examples: * PATH: /lemma=test;lexicalCategory=noun * GET: /?lemma=test&lexicalCategory=noun * POST (json): ```javascript { "lemma": "test", "lexicalCategory": "noun" } ``` <br> One of the options wordform/trueCase/lemma/lexicalCategory has to be provided.

operationId: LexiStats_getWordFrequency

Parameters

Name In Required Type Description
source_lang path required string IANA language code
corpus query optional string For corpora other than 'nmc' (New Monitor Corpus) please contact api@oxforddictionaries.com
wordform query optional string The written form of the word to look up (preserving case e.g., Books vs books)
trueCase query optional string The written form of the word to look up with normalised case (Books --> books)
lemma query optional string The lemma of the word to look up (e.g., Book, booked, books all have the lemma "book")
lexicalCategory query optional string The lexical category of the word(s) to look up (e.g., noun or verb)

Responses

200 Successful response.
400 You need to specify at least one option. Try one of 'wordform, lemma, trueCase, lexicalCategory'.
404 language is not in...
500 Internal Error. An error occurred while processing the data.
GET /stats/frequency/word/{source_lang}
GET /stats/frequency/words/{source_lang}

This endpoint provides a list of frequencies for a given word or words. Unlike the /word/ endpoint, the results are split into the smallest units. <br> <br> To exclude a specific value, prepend it with the minus sign ('-'). For example, to get frequencies of the lemma 'happy' but exclude superlative forms (i.e., happiest) you could use options 'lemma=happy;grammaticalFeatures=-degreeType:superlative'. <br> <br> Parameters can be provided in PATH, GET or POST (form or json). The parameters in PATH are overridden by parameters in GET, POST and json (in that order). In PATH, individual options are separated by semicolon and values are separated by commas (where multiple values can be used). <br> <br> The parameters wordform/trueCase/lemma/lexicalCategory also exist in a plural form, taking a lists of items. Examples: * PATH: /wordforms=happy,happier,happiest * GET: /?wordforms=happy&wordforms=happier&wordforms=happiest * POST (json): ```javascript { "wordforms": ["happy", "happier", "happiest"] } ``` A mor complex example of retrieving frequencies of multiple lemmas: ``` { "lemmas": ["happy", "content", "cheerful", "cheery", "merry", "joyful", "ecstatic"], "grammaticalFeatures": { "adjectiveFunctionType": "predicative" }, "lexicalCategory": "adjective", "sort": ["lemma", "-frequency"] } ``` Some queries with "collate" or "sort" can exceed the 30s timeout, in which case the API will return an error message with status code 503. You mitigate this by providing additional restrictions such as "minFrequency" and "maxFrequency". <br> <br> You can use the parameters "offset" and "limit" to paginate through large result sets. For convenience, the HTTP header "Link" is set on the response to provide links to "first", "self", "next", "prev" and "last" pages of results (depending on the context). For example, if the result set contains 50 results and the parameter "limit" is set to 25, the Links header will contain an URL for the first 25 results and the next 25 results. <br> <br> Some libraries such as python's `requests` can parse the header automatically and offer a convenient way of iterating through the results. For example: ```python def get_all_results(url): while url: r = requests.get(url) r.raise_for_status() for item in r.json()['results']: yield item url = r.links.get('next', {}).get('url') ```

operationId: LexiStats_getWordFrequencies

Parameters

Name In Required Type Description
source_lang path required string IANA language code
corpus query optional string For corpora other than 'nmc' (New Monitor Corpus) please contact api@oxforddictionaries.com
wordform query optional string The written form of the word to look up (preserving case e.g., Book vs book)
trueCase query optional string The written form of the word to look up with normalised case (Books --> books)
lemma query optional string The lemma of the word to look up (e.g., Book, booked, books all have the lemma "book")
lexicalCategory query optional string The lexical category of the word(s) to look up (e.g., adjective or noun)
grammaticalFeatures query optional string The grammatical features of the word(s) to look up entered as a list of k:v (e.g., degree_type:comparative)
sort query optional string sort the resulting list by wordform, trueCase, lemma, lexicalCategory, frequency, normalizedFrequency. Descending order is achieved by prepending the value with the minus sign ('-'). Multiple values can be separated by commas (e.g., sort=lexicalCategory,-frequency)
collate query optional string collate the results by wordform, trueCase, lemma, lexicalCategory. Multiple values can be separated by commas (e.g., collate=trueCase,lemma,lexicalCategory).
minFrequency query optional integer Restrict the query to entries with frequency of at least `minFrequency`
maxFrequency query optional integer Restrict the query to entries with frequency of at most `maxFrequency`
minNormalizedFrequency query optional number Restrict the query to entries with frequency of at least `minNormalizedFrequency`
maxNormalizedFrequency query optional number Restrict the query to entries with frequency of at most `maxNormalizedFrequency`
offset query optional integer pagination - results offset
limit query optional integer pagination - results limit

Responses

200 Successful response.
400 Invalid option name...; Option ... must have a value.; The option 'minFrequency' has to have an non-negative integer parameter.; The option 'maxFrequency' has to have an non-negative integer parameter.; The option 'limit' has to have an non-negative integer parameter.; The option 'offset' has to have an non-negative integer parameter.
404 language is not in...
500 Internal Error. An error occurred while processing the data.
GET /stats/frequency/words/{source_lang}

The sentence dictionary 1 endpoints

GET /entries/{source_language}/{word_id}/sentences

Use this to retrieve sentences extracted from corpora which show how a word is used in the language. This is available for English and Spanish. For English, the sentences are linked to the correct [sense](documentation/glossary?term=sense) of the word in the dictionary. In Spanish, they are linked at the [headword](documentation/glossary?term=headword) level. <div id="sentences"></div>

operationId: TheSentenceDictionary_getCorpusSentences

Parameters

Name In Required Type Description
source_language path required string IANA language code
word_id path required string An Entry identifier. Case-sensitive.

Responses

200 Successful response.
404 No entry is found matching supplied id and source_language
500 Internal Error. An error occurred while processing the data.
GET /entries/{source_language}/{word_id}/sentences

Thesaurus 3 endpoints

GET /entries/{source_lang}/{word_id}/antonyms

Retrieve words that are opposite in meaning to the input word ([antonym](documentation/glossary?term=thesaurus)). <div id="antonyms"></div>

operationId: Thesaurus_getAntonyms

Parameters

Name In Required Type Description
source_lang path required string IANA language code
word_id path required string An Entry identifier. Case-sensitive.

Responses

200 Successful response.
404 No entry is found matching supplied id and source_lang or filters are not recognized
500 Internal Error. An error occurred while processing the data.
GET /entries/{source_lang}/{word_id}/antonyms
GET /entries/{source_lang}/{word_id}/synonyms

Use this to retrieve words that are similar in meaning to the input word ([synonym](documentation/glossary?term=synonym)). <div id="synonyms"></div>

operationId: Thesaurus_getSimilarWords

Parameters

Name In Required Type Description
source_lang path required string IANA language code
word_id path required string An Entry identifier. Case-sensitive.

Responses

200 Successful response.
404 No entry is found matching supplied id and source_lang or filters are not recognized
500 Internal Error. An error occurred while processing the data.
GET /entries/{source_lang}/{word_id}/synonyms
GET /entries/{source_lang}/{word_id}/synonyms;antonyms

Retrieve available [synonyms](documentation/glossary?term=thesaurus) and [antonyms](documentation/glossary?term=thesaurus) for a given word and language. <div id="synonyms_and_antonyms"></div>

operationId: Thesaurus_getSynonymsAntonyms

Parameters

Name In Required Type Description
source_lang path required string IANA language code
word_id path required string An Entry identifier. Case-sensitive.

Responses

200 Successful response.
404 No entry is found matching supplied id and source_lang or filters are not recognized
500 Internal Error. An error occurred while processing the data.
GET /entries/{source_lang}/{word_id}/synonyms;antonyms

Translation 1 endpoints

GET /entries/{source_translation_language}/{word_id}/translations={target_translation_language}

Use this to return translations for a given word. In the event that a word in the dataset does not have a direct translation, the response will be a [definition](documentation/glossary?term=entry) in the target language. <div id="translation"></div>

operationId: Translation_getWordTranslation

Parameters

Name In Required Type Description
source_translation_language path required string IANA language code
word_id path required string The source word
target_translation_language path required string IANA language code

Responses

200 Successful response. In case word doesn't have a direct translation a response would be definitions.
400 any of target languages is unknown
404 no entry is found matching supplied source_lang and id and/or that entry has no senses with translations in the target language(s).
500 Internal Error. An error occurred while processing the data.
GET /entries/{source_translation_language}/{word_id}/translations={target_translation_language}

Utility 10 endpoints

GET /domains/{source_domains_language}/{target_domains_language}

Returns a list of the available [domains](documentation/glossary?term=domain) for a given bilingual language dataset.

operationId: Utility_listAvailableDomains

Parameters

Name In Required Type Description
source_domains_language path required string IANA language code
target_domains_language path required string IANA language code

Responses

200 Successful response.
400 source_language and target_language are same.
404 Unknown source_language and/or target_language.
GET /domains/{source_domains_language}/{target_domains_language}
GET /domains/{source_language}

Returns a list of the available [domains](documentation/glossary?term=domain) for a given monolingual language dataset.

operationId: Utility_listMonolingualDomains

Parameters

Name In Required Type Description
source_language path required string IANA language code

Responses

200 Successful response.
404 Unknown source_language.
GET /domains/{source_language}
GET /filters

Returns a list of all the valid filters to construct API calls.

operationId: Utility_listAvailableFilters

Responses

200 Successful response.
500 Internal Error. An error occurred while processing the data.
GET /filters
GET /filters/{endpoint}

Returns a list of all the valid filters for a given endpoint to construct API calls.

operationId: Utility_listEndpointFilters

Parameters

Name In Required Type Description
endpoint path required string Name of the endpoint.

Responses

200 Successful response.
404 Unknown endpoint.
500 Internal Error. An error occurred while processing the data.
GET /filters/{endpoint}
GET /grammaticalFeatures/{source_language}

Returns a list of the available [grammatical features](documentation/glossary?term=grammaticalfeatures) for a given language dataset.

operationId: Utility_getGrammaticalFeatures

Parameters

Name In Required Type Description
source_language path required string IANA language code. If provided output will be filtered by sourceLanguage.

Responses

200 Successful response.
404 Unknown source_language.
GET /grammaticalFeatures/{source_language}
GET /languages

Returns a list of monolingual and bilingual language datasets available in the API

operationId: Utility_listAvailableLanguages

Parameters

Name In Required Type Description
sourceLanguage query optional string IANA language code. If provided output will be filtered by sourceLanguage.
targetLanguage query optional string IANA language code. If provided output will be filtered by sourceLanguage.

Responses

200 Successful response.
404 Unknown sourceLanguage and/or targetLanguage.
500 Internal Error. An error occurred while processing the data.
GET /languages
GET /lexicalcategories/{language}

Returns a list of available [lexical categories](documentation/glossary?term=lexicalcategory) for a given language dataset.

operationId: Utility_getLexicalCategories

Parameters

Name In Required Type Description
language path required string IANA language code

Responses

200 Successful response.
404 Unknown language.
500 Internal Error. An error occurred while processing the data.
GET /lexicalcategories/{language}
GET /regions/{source_language}

Returns a list of the available [regions](documentation/glossary?term=regions) for a given monolingual language dataset.

operationId: Utility_listMonolingualRegions

Parameters

Name In Required Type Description
source_language path required string IANA language code

Responses

200 Successful response.
404 Unknown source_language.
GET /regions/{source_language}
GET /registers/{source_language}

Returns a list of the available [registers](documentation/glossary?term=registers) for a given monolingual language dataset.

operationId: Utility_listMonolingualRegisters

Parameters

Name In Required Type Description
source_language path required string IANA language code

Responses

200 Successful response.
404 Unknown source_language.
500 Internal Error. An error occurred while processing the data.
GET /registers/{source_language}
GET /registers/{source_register_language}/{target_register_language}

Returns a list of the available [registers](documentation/glossary?term=registers) for a given bilingual language dataset.

operationId: Utility_listBilingualRegisters

Parameters

Name In Required Type Description
source_register_language path required string IANA language code
target_register_language path required string IANA language code

Responses

200 Successful response.
400 source_language and target_language are same.
404 Unknown source_language and/or target_language.
500 Internal Error. An error occurred while processing the data.
GET /registers/{source_register_language}/{target_register_language}

Wordlist 2 endpoints

GET /wordlist/{source_lang}/{filters_advanced}

Use this to apply more complex filters to the [list of words](documentation/glossary?term=wordlist). For example, you may only want to filter out words for which all [senses](documentation/glossary?term=sense) match the filter, or only its 'prime sense'. You can also filter by word length or match by substring (prefix). <div id="wordlist_advanced"></div>

operationId: Wordlist_getAdvancedWords

Parameters

Name In Required Type Description
source_lang path required string IANA language code
filters_advanced path required string Semicolon separated list of wordlist parameters, presented as value pairs: LexicalCategory, domains, regions, registers. Parameters can take comma separated list of values. E.g., lexicalCategory=noun,adjective;domains=sport. Number of values limited to 5.
exclude query optional string Semicolon separated list of parameters-value pairs (same as filters). Excludes headwords that have any senses in specified exclusion attributes (lexical categories, domains, etc.) from results.
exclude_senses query optional string Semicolon separated list of parameters-value pairs (same as filters). Excludes only those senses of a particular headword that match specified exclusion attributes (lexical categories, domains, etc.) from results but includes the headword if it has other permitted senses.
exclude_prime_senses query optional string Semicolon separated list of parameters-value pairs (same as filters). Excludes a headword only if the primary sense matches the specified exclusion attributes (registers, domains only).
word_length query optional string Parameter to speficy the minimum (>), exact or maximum (<) length of the words required. E.g., >5 - more than 5 chars; <4 - less than 4 chars; >5<10 - from 5 to 10 chars; 3 - exactly 3 chars.
prefix query optional string Filter words that start with prefix parameter
exact query optional string If exact=true wordlist returns a list of entries that exactly matches the search string. Otherwise wordlist lists entries that start with prefix string.
limit query optional string Limit the number of results per response. Default and maximum limit is 5000.
offset query optional string Offset the start number of the result.

Responses

200 Successful response.
400 disjoint sets of word_length values (eg <3>10); filter has no values; total number of filters > 20; filters and excludes values can not be the same; source_lang and translations can not be same; word_length conflicts with prefix length.
404 No entries is found matching supplied filters or lang or filters is not recognized.
500 Internal Error. An error occurred while processing the data.
GET /wordlist/{source_lang}/{filters_advanced}
GET /wordlist/{source_lang}/{filters_basic}

Use this to retrieve a [list of words](documentation/glossary?term=wordlist) for particular [domain](documentation/glossary?term=domain), [lexical category](documentation/glossary?term=lexicalcategory), [register](documentation/glossary?term=registers) and/or [region](documentation/glossary?term=regions). View the full list of possible filters using the filters Utility endpoint. The response only includes [headwords](documentation/glossary?term=headword), not all their possible [inflections](documentation/glossary?term=inflection). If you require a full [wordlist](documentation/glossary?term=wordlist) including [inflected forms](documentation/glossary?term=inflection), contact us and we can help. <div id="wordlist"></div>

operationId: Wordlist_getCategoryWords

Parameters

Name In Required Type Description
source_lang path required string IANA language code
filters_basic path required string Semicolon separated list of wordlist parameters, presented as value pairs: LexicalCategory, domains, regions, registers. Parameters can take comma separated list of values. E.g., lexicalCategory=noun,adjective;domains=sport. Number of values limited to 5.
limit query optional string Limit the number of results per response. Default and maximum limit is 5000.
offset query optional string Offset the start number of the result

Responses

200 Successful response.
400 filter has no values; total number of filters > 20.
404 No entries is found matching supplied filters or lang or filters is not recognized.
500 Internal Error. An error occurred while processing the data.
GET /wordlist/{source_lang}/{filters_basic}

Schemas

array ArrayOfRelatedEntries 
{
  "type": "array",
  "items": {
    "type": "object",
    "required": [
      "text",
      "id"
    ],
    "properties": {
      "id": {
        "type": "string",
        "description": "The identifier of the word"
      },
      "text": {
        "type": "string"
      },
      "domains": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "regions": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "language": {
        "type": "string",
        "description": "IANA language code specifying the language of the word"
      },
      "registers": {
        "$ref": "#/components/schemas/arrayofstrings"
      }
    }
  },
  "minItems": 1,
  "description": "A list of written or spoken words"
}
array CategorizedTextList 
{
  "type": "array",
  "items": {
    "type": "object",
    "required": [
      "text",
      "type"
    ],
    "properties": {
      "id": {
        "type": "string",
        "description": "The identifier of the word"
      },
      "text": {
        "type": "string",
        "description": "A note text"
      },
      "type": {
        "type": "string",
        "description": "The descriptive category of the text"
      }
    }
  },
  "minItems": 1,
  "description": "various types of notes that appear"
}
array CrossReferencesList 
{
  "type": "array",
  "items": {
    "type": "object",
    "required": [
      "id",
      "text",
      "type"
    ],
    "properties": {
      "id": {
        "type": "string",
        "description": "The word id of cooccurrence"
      },
      "text": {
        "type": "string",
        "description": "The word of cooccurrence"
      },
      "type": {
        "type": "string",
        "description": "The type of relation between the two words. Possible values are 'close match', 'related', 'see also', 'variant spelling', and 'abbreviation' in case of crossreferences, or 'pre', 'post' in case of collocates."
      }
    },
    "description": "cross references of a sense"
  },
  "minItems": 1,
  "description": "A reference to another word that is closely related, might provide additional information about the subject, has a variant spelling or is an abbreviated form of it."
}
object Entry 
{
  "type": "object",
  "properties": {
    "notes": {
      "$ref": "#/components/schemas/CategorizedTextList"
    },
    "senses": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Sense"
      },
      "minItems": 1,
      "description": "Complete list of senses"
    },
    "etymologies": {
      "$ref": "#/components/schemas/arrayofstrings"
    },
    "variantForms": {
      "$ref": "#/components/schemas/VariantFormsList"
    },
    "pronunciations": {
      "$ref": "#/components/schemas/PronunciationsList"
    },
    "homographNumber": {
      "type": "string",
      "description": "Identifies the homograph grouping. The last two digits identify different entries of the same homograph. The first one/two digits identify the homograph number."
    },
    "grammaticalFeatures": {
      "$ref": "#/components/schemas/GrammaticalFeaturesList"
    }
  },
  "minProperties": 1
}
array ExamplesList 
{
  "type": "array",
  "items": {
    "type": "object",
    "required": [
      "text"
    ],
    "properties": {
      "text": {
        "type": "string"
      },
      "notes": {
        "$ref": "#/components/schemas/CategorizedTextList"
      },
      "domains": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "regions": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "senseIds": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "registers": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "definitions": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "translations": {
        "$ref": "#/components/schemas/TranslationsList"
      }
    }
  },
  "minItems": 1,
  "description": "A list of written or spoken rendering of examples of use of a word or text"
}
object Filters 
{
  "properties": {
    "results": {
      "type": "object",
      "properties": {
        "entries": {
          "$ref": "#/components/schemas/arrayofstrings"
        },
        "wordlist": {
          "$ref": "#/components/schemas/arrayofstrings"
        },
        "inflections": {
          "$ref": "#/components/schemas/arrayofstrings"
        },
        "translations": {
          "$ref": "#/components/schemas/arrayofstrings"
        }
      },
      "description": "A mapping of filters available per endpoints.",
      "minProperties": 1
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for the Filters endpoint."
}
array GrammaticalFeaturesList 
{
  "type": "array",
  "items": {
    "type": "object",
    "required": [
      "text",
      "type"
    ],
    "properties": {
      "text": {
        "type": "string"
      },
      "type": {
        "type": "string"
      }
    }
  },
  "minItems": 1,
  "description": "The different forms are correlated with meanings or functions which we text as 'features'"
}
object HeadwordEntry 
{
  "type": "object",
  "required": [
    "id",
    "language",
    "lexicalEntries",
    "word"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "The identifier of a word"
    },
    "type": {
      "type": "string",
      "description": "The json object type. Could be 'headword', 'inflection' or 'phrase'"
    },
    "word": {
      "type": "string",
      "description": "A given written or spoken realisation of a an entry, lowercased."
    },
    "language": {
      "type": "string",
      "description": "IANA language code"
    },
    "lexicalEntries": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/lexicalEntry"
      },
      "minItems": 1,
      "description": "A grouping of various senses in a specific language, and a lexical category that relates to a word"
    },
    "pronunciations": {
      "$ref": "#/components/schemas/PronunciationsList"
    }
  },
  "description": "Description of a word"
}
object HeadwordLemmatron 
{
  "type": "object",
  "required": [
    "id",
    "language",
    "lexicalEntries",
    "word"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "The identifier of a word"
    },
    "type": {
      "type": "string",
      "description": "The json object type. Could be 'headword', 'inflection' or 'phrase'"
    },
    "word": {
      "type": "string",
      "description": "A given written or spoken realisation of a an entry, lowercased."
    },
    "language": {
      "type": "string",
      "description": "IANA language code"
    },
    "lexicalEntries": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/LemmatronLexicalEntry"
      },
      "minItems": 1,
      "description": "A grouping of various senses in a specific language, and a lexical category that relates to a word"
    }
  },
  "description": "Description of an inflected form of a word"
}
object HeadwordThesaurus 
{
  "type": "object",
  "required": [
    "word",
    "id",
    "language",
    "lexicalEntries"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "The identifier of a word"
    },
    "type": {
      "type": "string",
      "description": "The json object type. Could be 'headword', 'inflection' or 'phrase'"
    },
    "word": {
      "type": "string",
      "description": "A given written or spoken realisation of a an entry, lowercased."
    },
    "language": {
      "type": "string",
      "description": "IANA language code"
    },
    "lexicalEntries": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/ThesaurusLexicalEntry"
      },
      "minItems": 1,
      "description": "A grouping of various senses in a specific language, and a lexical category that relates to a word"
    }
  },
  "description": "description of thesaurus information of a word"
}
array InflectionsList 
{
  "type": "array",
  "items": {
    "type": "object",
    "required": [
      "text",
      "id"
    ],
    "properties": {
      "id": {
        "type": "string",
        "description": "The identifier of the word"
      },
      "text": {
        "type": "string"
      }
    }
  },
  "minItems": 1,
  "description": "A grouping of the modifications of a word to express different grammatical categories"
}
object Languages 
{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "enum": [
              "monolingual",
              "bilingual"
            ],
            "type": "string",
            "description": "whether monolingual or bilingual."
          },
          "region": {
            "type": "string",
            "description": "Name of region."
          },
          "source": {
            "type": "string",
            "description": "Name of source dictionary."
          },
          "sourceLanguage": {
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "description": "IANA language code"
              },
              "language": {
                "type": "string",
                "description": "Language label."
              }
            },
            "description": "Source language of the results"
          },
          "targetLanguage": {
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "description": "IANA language code"
              },
              "language": {
                "type": "string",
                "description": "Language label."
              }
            },
            "description": "Translation language of the results"
          }
        },
        "minProperties": 1
      },
      "minItems": 1,
      "description": "A list of languages available."
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for the languages endpoint."
}
object Lemmatron 
{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/HeadwordLemmatron"
      },
      "minItems": 1,
      "description": "A list of inflections matching a given word"
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for the inflections endpoint."
}
object LemmatronLexicalEntry 
{
  "type": "object",
  "required": [
    "inflectionOf",
    "language",
    "lexicalCategory",
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "A given written or spoken realisation of a an entry."
    },
    "language": {
      "type": "string",
      "description": "IANA language code"
    },
    "inflectionOf": {
      "$ref": "#/components/schemas/InflectionsList"
    },
    "lexicalCategory": {
      "type": "string",
      "description": "A linguistic category of words (or more precisely lexical items), generally defined by the syntactic or morphological behaviour of the lexical item in question, such as noun or verb"
    },
    "grammaticalFeatures": {
      "$ref": "#/components/schemas/GrammaticalFeaturesList"
    }
  },
  "description": "Description of an entry for a particular part of speech and grammatical features"
}
object NgramsResult 
{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "tokens",
          "frequency"
        ],
        "properties": {
          "tokens": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "minItems": 1,
            "description": "A list of tokens"
          },
          "frequency": {
            "type": "integer",
            "description": "The number of times the ngram (a sequence of n words) appears in the corpus"
          }
        },
        "description": "Ngrams matching the given options",
        "additionalProperties": true
      },
      "minItems": 0,
      "description": "A list of found ngrams along with their frequencies"
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for corpus ngrams."
}
array PronunciationsList 
{
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "regions": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "dialects": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "audioFile": {
        "type": "string",
        "description": "The URL of the sound file"
      },
      "phoneticNotation": {
        "type": "string",
        "description": "The alphabetic system used to display the phonetic spelling"
      },
      "phoneticSpelling": {
        "type": "string",
        "description": "Phonetic spelling is the representation of vocal sounds which express pronunciations of words. It is a system of spelling in which each letter represents invariably the same spoken sound"
      }
    },
    "description": "A grouping of pronunciation information",
    "minProperties": 1
  },
  "minItems": 1,
  "description": "A list of possible pronunciations of a word"
}
object Regions 
{
  "properties": {
    "results": {
      "type": "object",
      "description": "A mapping of regions available.",
      "additionalProperties": {
        "$ref": "#/components/schemas/arrayofstrings"
      }
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for region endpoint."
}
object RetrieveEntry 
{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/HeadwordEntry"
      },
      "minItems": 1,
      "description": "A list of entries and all the data related to them"
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for the 'entries' endpoints"
}
object Sense 
{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "The id of the sense that is required for the delete procedure"
    },
    "notes": {
      "$ref": "#/components/schemas/CategorizedTextList"
    },
    "domains": {
      "$ref": "#/components/schemas/arrayofstrings"
    },
    "regions": {
      "$ref": "#/components/schemas/arrayofstrings"
    },
    "examples": {
      "$ref": "#/components/schemas/ExamplesList"
    },
    "registers": {
      "$ref": "#/components/schemas/arrayofstrings"
    },
    "subsenses": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Sense"
      },
      "minItems": 1,
      "description": "Ordered list of subsenses of a sense"
    },
    "definitions": {
      "$ref": "#/components/schemas/arrayofstrings"
    },
    "translations": {
      "$ref": "#/components/schemas/TranslationsList"
    },
    "variantForms": {
      "$ref": "#/components/schemas/VariantFormsList"
    },
    "pronunciations": {
      "$ref": "#/components/schemas/PronunciationsList"
    },
    "thesaurusLinks": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/thesaurusLink"
      },
      "minItems": 1,
      "description": "Ordered list of links to the Thesaurus Dictionary"
    },
    "crossReferences": {
      "$ref": "#/components/schemas/CrossReferencesList"
    },
    "short_definitions": {
      "$ref": "#/components/schemas/arrayofstrings"
    },
    "crossReferenceMarkers": {
      "$ref": "#/components/schemas/arrayofstrings"
    }
  },
  "description": "A lexical sense represents the lexical meaning of a lexical entry when interpreted as referring to the corresponding ontology element",
  "minProperties": 1
}
object SentencesEntry 
{
  "type": "object",
  "required": [
    "id",
    "language",
    "lexicalEntries",
    "word"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "The identifier of a word"
    },
    "type": {
      "type": "string",
      "description": "The json object type. Could be 'headword', 'inflection' or 'phrase'"
    },
    "word": {
      "type": "string",
      "description": "A given written or spoken realisation of a an entry, lowercased."
    },
    "language": {
      "type": "string",
      "description": "IANA language code"
    },
    "lexicalEntries": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/SentencesLexicalEntry"
      },
      "minItems": 1,
      "description": "A grouping of various senses in a specific language, and a lexical category that relates to a word"
    }
  },
  "description": "Description of a word"
}
object SentencesLexicalEntry 
{
  "type": "object",
  "required": [
    "language",
    "sentences",
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "A given written or spoken realisation of a an entry."
    },
    "language": {
      "type": "string",
      "description": "IANA language code"
    },
    "sentences": {
      "$ref": "#/components/schemas/ExamplesList"
    },
    "lexicalCategory": {
      "type": "string",
      "description": "A linguistic category of words (or more precisely lexical items), generally defined by the syntactic or morphological behaviour of the lexical item in question, such as noun or verb"
    },
    "grammaticalFeatures": {
      "$ref": "#/components/schemas/GrammaticalFeaturesList"
    }
  },
  "description": "Description of an entry for a particular part of speech"
}
object SentencesResults 
{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/SentencesEntry"
      },
      "minItems": 1,
      "description": "A list of entries and all the data related to them"
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for the 'sentences' endpoint"
}
object StatsWordResult 
{
  "type": "object",
  "properties": {
    "result": {
      "type": "object",
      "required": [
        "frequency",
        "normalizedFrequency",
        "matchCount"
      ],
      "properties": {
        "lemma": {
          "type": "string",
          "description": "A lemma of the word (e.g., wordforms \"lay\", \"laid\" and \"laying\" have all lemma \"lay\")"
        },
        "trueCase": {
          "type": "string",
          "description": "A given written realisation of a an entry (e.g., \"lay\") usually lower case"
        },
        "wordform": {
          "type": "string",
          "description": "A given written realisation of a an entry (e.g., \"Lay\") preserving case"
        },
        "frequency": {
          "type": "integer",
          "description": "The number of times a word appears in the entire corpus"
        },
        "matchCount": {
          "type": "integer",
          "description": "The number of database records that matched the query params (stated frequency is the sum of the individual frequencies)"
        },
        "lexicalCategory": {
          "type": "string",
          "description": "A lexical category such as 'verb' or 'noun'"
        },
        "normalizedFrequency": {
          "type": "integer",
          "description": "The number of times a word appears on average in 1 million words"
        }
      },
      "description": "Frequency information for a given entity",
      "additionalProperties": true
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for lexi-stats results for a word/trueCase/lemma/lexicalCategory returned as a frequency"
}
object StatsWordResultList 
{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "wordform",
          "trueCase",
          "lemma",
          "lexicalCategory",
          "frequency",
          "normalizedFrequency"
        ],
        "properties": {
          "lemma": {
            "type": "string",
            "description": "A lemma of the word."
          },
          "trueCase": {
            "type": "string",
            "description": "A given written realisation of a an entry (e.g., \"lay\") usually lower case"
          },
          "wordform": {
            "type": "string",
            "description": "A given written realisation of a an entry (e.g., \"lay\") preserving case"
          },
          "frequency": {
            "type": "integer",
            "description": "The number of times a word appears in the entire corpus"
          },
          "lexicalCategory": {
            "type": "string",
            "description": "A lexical category such as 'verb' or 'noun'"
          },
          "normalizedFrequency": {
            "type": "integer",
            "description": "The number of times a word appears on average in 1 million words"
          }
        },
        "description": "Statistical information about a word",
        "additionalProperties": true
      },
      "minItems": 0,
      "description": "A list of found words along with their frequencies"
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for lexi-stats results for a word/trueCase/lemma/lexicalCategory returned as a list of frequencies per wordform-trueCase-lemma-lexicalCategory entry."
}
array SynonymsAntonyms 
{
  "type": "array",
  "items": {
    "type": "object",
    "required": [
      "id",
      "text"
    ],
    "properties": {
      "id": {
        "type": "string"
      },
      "text": {
        "type": "string"
      },
      "domains": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "regions": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "language": {
        "type": "string"
      },
      "registers": {
        "$ref": "#/components/schemas/arrayofstrings"
      }
    }
  },
  "minItems": 1
}
object Thesaurus 
{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/HeadwordThesaurus"
      },
      "minItems": 1,
      "description": "A list of found synonyms or antonyms"
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for thesaurus endpoint"
}
object ThesaurusEntry 
{
  "type": "object",
  "properties": {
    "senses": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/ThesaurusSense"
      },
      "minItems": 1,
      "description": "Complete list of senses"
    },
    "variantForms": {
      "$ref": "#/components/schemas/VariantFormsList"
    },
    "homographNumber": {
      "type": "string",
      "description": "Identifies the homograph grouping. The last two digits identify different entries of the same homograph. The first one/two digits identify the homograph number."
    }
  },
  "minProperties": 1
}
object ThesaurusLexicalEntry 
{
  "type": "object",
  "required": [
    "language",
    "lexicalCategory",
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "A given written or spoken realisation of a an entry."
    },
    "entries": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/ThesaurusEntry"
      },
      "minItems": 1
    },
    "language": {
      "type": "string",
      "description": "IANA language code"
    },
    "variantForms": {
      "$ref": "#/components/schemas/VariantFormsList"
    },
    "lexicalCategory": {
      "type": "string",
      "description": "A linguistic category of words (or more precisely lexical items), generally defined by the syntactic or morphological behaviour of the lexical item in question, such as noun or verb"
    }
  },
  "description": "Description of an entry for a particular part of speech"
}
object ThesaurusSense 
{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "The id of the sense that is required for the delete procedure"
    },
    "domains": {
      "$ref": "#/components/schemas/arrayofstrings"
    },
    "regions": {
      "$ref": "#/components/schemas/arrayofstrings"
    },
    "antonyms": {
      "$ref": "#/components/schemas/SynonymsAntonyms"
    },
    "examples": {
      "$ref": "#/components/schemas/ExamplesList"
    },
    "synonyms": {
      "$ref": "#/components/schemas/SynonymsAntonyms"
    },
    "registers": {
      "$ref": "#/components/schemas/arrayofstrings"
    },
    "subsenses": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/ThesaurusSense"
      },
      "minItems": 1,
      "description": "subsenses of word"
    }
  },
  "description": "A lexical sense represents the lexical meaning of a lexical entry when interpreted as referring to the corresponding ontology element",
  "minProperties": 1
}
array TranslationsList 
{
  "type": "array",
  "items": {
    "type": "object",
    "required": [
      "text",
      "language"
    ],
    "properties": {
      "text": {
        "type": "string"
      },
      "notes": {
        "$ref": "#/components/schemas/CategorizedTextList"
      },
      "domains": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "regions": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "language": {
        "type": "string",
        "description": "IANA language code specifying the language of the translation"
      },
      "registers": {
        "$ref": "#/components/schemas/arrayofstrings"
      },
      "grammaticalFeatures": {
        "$ref": "#/components/schemas/GrammaticalFeaturesList"
      }
    }
  },
  "minItems": 1,
  "description": "A list of written or spoken rendering of the meaning of a word or text in another language(s)"
}
object UtilityLabels 
{
  "properties": {
    "results": {
      "type": "object",
      "description": "Mapping of labels available.",
      "additionalProperties": {
        "type": "object",
        "properties": {
          "en": {
            "type": "string",
            "description": "Label in English"
          }
        },
        "description": "the list of labels for an object. Every object can be a lexical category, or a register, or a domain."
      }
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for lexicalcategories, registers utility endpoints."
}
array VariantFormsList 
{
  "type": "array",
  "items": {
    "type": "object",
    "required": [
      "text"
    ],
    "properties": {
      "text": {
        "type": "string"
      },
      "regions": {
        "$ref": "#/components/schemas/arrayofstrings"
      }
    }
  },
  "minItems": 1,
  "description": "Various words that are used interchangeably depending on the context, e.g 'aluminium' and 'aluminum'"
}
object Wordlist 
{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "word"
        ],
        "properties": {
          "id": {
            "type": "string",
            "description": "The identifier of a word"
          },
          "word": {
            "type": "string",
            "description": "A given written or spoken realisation of a an entry, lowercased."
          },
          "region": {
            "type": "string",
            "description": "Name of region."
          },
          "matchType": {
            "type": "string"
          },
          "matchString": {
            "type": "string",
            "nullable": true
          }
        },
        "description": "Description of found word",
        "additionalProperties": true
      },
      "minItems": 0,
      "description": "A list of found words"
    },
    "metadata": {
      "type": "object",
      "description": "Additional Information provided by OUP"
    }
  },
  "description": "Schema for wordlist endpoint."
}
array arrayofstrings 
{
  "type": "array",
  "items": {
    "type": "string"
  }
}
object lexicalEntry 
{
  "type": "object",
  "required": [
    "language",
    "lexicalCategory",
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "A given written or spoken realisation of a an entry."
    },
    "notes": {
      "$ref": "#/components/schemas/CategorizedTextList"
    },
    "entries": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Entry"
      },
      "minItems": 1
    },
    "language": {
      "type": "string",
      "description": "IANA language code"
    },
    "derivatives": {
      "$ref": "#/components/schemas/ArrayOfRelatedEntries"
    },
    "derivativeOf": {
      "$ref": "#/components/schemas/ArrayOfRelatedEntries"
    },
    "variantForms": {
      "$ref": "#/components/schemas/VariantFormsList"
    },
    "pronunciations": {
      "$ref": "#/components/schemas/PronunciationsList"
    },
    "lexicalCategory": {
      "type": "string",
      "description": "A linguistic category of words (or more precisely lexical items), generally defined by the syntactic or morphological behaviour of the lexical item in question, such as noun or verb"
    },
    "grammaticalFeatures": {
      "$ref": "#/components/schemas/GrammaticalFeaturesList"
    }
  },
  "description": "Description of an entry for a particular part of speech"
}
object thesaurusLink 
{
  "type": "object",
  "required": [
    "entry_id",
    "sense_id"
  ],
  "properties": {
    "entry_id": {
      "type": "string",
      "description": "identifier of a word"
    },
    "sense_id": {
      "type": "string",
      "description": "identifier of a sense"
    }
  },
  "description": "Link to a sense of a specific entry in the thesaurus Dictionary"
}