openapi.yaml

openapi: 3.0.0
info:
  title: Oxford Dictionaries
  description: >-
    Oxford Dictionaries, part of the Oxford Language Division, is a leading
    authority on the English language. It offers a wide range of language
    resources, including dictionaries, thesauruses, grammar guides, and language
    learning tools. Oxford Dictionaries provides accurate and up-to-date
    definitions, word origins, and usage examples to support language
    comprehension and communication.
  version: 1.11.0
  license:
    name: API Terms And Conditions
    url: https://developer.oxforddictionaries.com/api-terms-and-conditions
  termsOfService: http://helloreverb.com/terms/
  x-apisguru-categories:
    - text
  x-logo:
    url: https://twitter.com/OxfordWordsAPI/profile_image?size=original
  x-origin:
    - version: '3.0'
      format: openapi
      url: >-
        https://developer.oxforddictionaries.com/swagger/spec/public_doc_guest.json
  x-providerName: oxforddictionaries.com
  x-api-status-urls:
    - https://od-api.oxforddictionaries.com/api/v2/
servers:
  - url: https://od-api-demo.oxforddictionaries.com:443/api/v1
tags:
  - name: Utility
  - name: Dictionary entries
  - name: Thesaurus
  - name: LexiStats
  - name: Search
  - name: Wordlist
  - name: The Sentence Dictionary
  - name: Translation
  - name: Lemmatron
paths:
  /domains/{source_domains_language}/{target_domains_language}:
    get:
      tags:
        - Utility
      summary: Lists available domains in a bilingual dataset
      operationId: Utility_listAvailableDomains
      security:
        - appId: []
          appKey: []
      description: >
        Returns a list of the available
        [domains](documentation/glossary?term=domain) for a given bilingual
        language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_domains_language
          required: true
          schema:
            enum:
              - en
              - es
              - nso
              - zu
              - ur
              - de
              - pt
            type: string
        - description: IANA language code
          in: path
          name: target_domains_language
          required: true
          schema:
            enum:
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ro
              - de
              - pt
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UtilityLabels'
        '400':
          description: source_language and target_language are same.
        '404':
          description: Unknown source_language and/or target_language.
  /domains/{source_language}:
    get:
      tags:
        - Utility
      summary: Lists available domains in a monolingual dataset
      operationId: Utility_listMonolingualDomains
      security:
        - appId: []
          appKey: []
      description: >
        Returns a list of the available
        [domains](documentation/glossary?term=domain) for a given monolingual
        language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
              - es
              - nso
              - zu
              - hi
              - sw
              - ur
              - de
              - pt
              - ta
              - gu
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UtilityLabels'
        '404':
          description: Unknown source_language.
  /entries/{source_language}/{word_id}/sentences:
    get:
      tags:
        - The Sentence Dictionary
      summary: Retrieve corpus sentences for a given word
      operationId: TheSentenceDictionary_getCorpusSentences
      security:
        - appId: []
          appKey: []
      description: >

        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>
      parameters:
        - description: IANA language code
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
              - es
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SentencesResults'
        '404':
          description: |
            No entry is found matching supplied id and source_language
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
  /entries/{source_lang}/{word_id}:
    get:
      tags:
        - Dictionary entries
      summary: Retrieve dictionary information for a given word
      operationId: DictionaryEntries_getInformation
      security:
        - appId: []
          appKey: []
      description: >

        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>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - lv
              - hi
              - sw
              - ta
              - gu
              - fr
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RetrieveEntry'
        '404':
          description: >
            No entry is found matching supplied id and source_lang or filters
            are not recognized
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
  /entries/{source_lang}/{word_id}/antonyms:
    get:
      tags:
        - Thesaurus
      summary: Retrieve words that mean the opposite
      operationId: Thesaurus_getAntonyms
      security:
        - appId: []
          appKey: []
      description: >

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

          <div id="antonyms"></div>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Thesaurus'
        '404':
          description: >
            No entry is found matching supplied id and source_lang or filters
            are not recognized
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
  /entries/{source_lang}/{word_id}/regions={region}:
    get:
      tags:
        - Dictionary entries
      summary: Specify GB or US dictionary for English entry search
      operationId: DictionaryEntries_specifyDictionaryRegion
      security:
        - appId: []
          appKey: []
      description: >

        USe this filter to restrict the lookup to either our Oxford Dictionary
        of English (GB) or New Oxford American Dictionary (US).
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
        - description: >-
            Region filter parameter. gb = Oxford Dictionary of English. us = New
            Oxford American Dictionary.
          in: path
          name: region
          required: true
          schema:
            enum:
              - gb
              - us
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RetrieveEntry'
        '404':
          description: >
            no entry is found matching supplied source_lang and id

            and/or that entry has no senses with translations in the target
            language. 
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
  /entries/{source_lang}/{word_id}/synonyms:
    get:
      tags:
        - Thesaurus
      summary: Retrieve words that are similar
      operationId: Thesaurus_getSimilarWords
      security:
        - appId: []
          appKey: []
      description: >

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

          <div id="synonyms"></div>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Thesaurus'
        '404':
          description: >
            No entry is found matching supplied id and source_lang or filters
            are not recognized
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
  /entries/{source_lang}/{word_id}/synonyms;antonyms:
    get:
      tags:
        - Thesaurus
      summary: Retrieve synonyms and antonyms for a given word
      operationId: Thesaurus_getSynonymsAntonyms
      security:
        - appId: []
          appKey: []
      description: >

        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>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Thesaurus'
        '404':
          description: >
            No entry is found matching supplied id and source_lang or filters
            are not recognized
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
  /entries/{source_lang}/{word_id}/{filters}:
    get:
      tags:
        - Dictionary entries
      summary: Apply filters to response
      operationId: DictionaryEntries_applyFilters
      security:
        - appId: []
          appKey: []
      description: >

        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>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - lv
              - hi
              - sw
              - ta
              - gu
              - fr
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
        - description: >-
            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.
          in: path
          name: filters
          required: true
          schema:
            default: grammaticalFeatures=singular,past;lexicalCategory=noun
            items:
              pattern: (lexicalCategory|grammaticalFeatures)=.+
              type: string
            type: string
          style: simple
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RetrieveEntry'
        '404':
          description: >
            no entry is found matching supplied source_lang and id

            and/or that entry has no senses with translations in the target
            language. 
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
  /entries/{source_translation_language}/{word_id}/translations={target_translation_language}:
    get:
      tags:
        - Translation
      summary: Retrieve translation for a given word
      operationId: Translation_getWordTranslation
      security:
        - appId: []
          appKey: []
      description: >

        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>
      parameters:
        - description: IANA language code
          in: path
          name: source_translation_language
          required: true
          schema:
            enum:
              - en
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - de
              - pt
            type: string
        - description: The source word
          in: path
          name: word_id
          required: true
          schema:
            default: change
            type: string
        - description: IANA language code
          in: path
          name: target_translation_language
          required: true
          schema:
            enum:
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ro
              - de
              - pt
            type: string
      responses:
        '200':
          description: >-
            Successful response. In case word doesn't have a direct translation
            a response would be definitions.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RetrieveEntry'
        '400':
          description: any of target languages is unknown
        '404':
          description: >
            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':
          description: |
            Internal Error. An error occurred while processing the data.
  /filters:
    get:
      tags:
        - Utility
      summary: Lists available filters
      operationId: Utility_listAvailableFilters
      security:
        - appId: []
          appKey: []
      description: |
        Returns a list of all the valid filters to construct API calls.
      parameters: []
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Filters'
        '500':
          description: Internal Error. An error occurred while processing the data.
  /filters/{endpoint}:
    get:
      tags:
        - Utility
      summary: Lists available filters for specific endpoint
      operationId: Utility_listEndpointFilters
      security:
        - appId: []
          appKey: []
      description: >
        Returns a list of all the valid filters for a given endpoint to
        construct API calls.
      parameters:
        - description: Name of the endpoint.
          in: path
          name: endpoint
          required: true
          schema:
            enum:
              - entries
              - inflections
              - translations
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Filters'
        '404':
          description: Unknown endpoint.
        '500':
          description: Internal Error. An error occurred while processing the data.
  /grammaticalFeatures/{source_language}:
    get:
      tags:
        - Utility
      summary: Lists available grammatical features in a dataset
      operationId: Utility_getGrammaticalFeatures
      security:
        - appId: []
          appKey: []
      description: >
        Returns a list of the available [grammatical
        features](documentation/glossary?term=grammaticalfeatures) for a given
        language dataset.
      parameters:
        - description: >-
            IANA language code. If provided output will be filtered by
            sourceLanguage.
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
              - es
              - lv
              - nso
              - zu
              - ms
              - tn
              - ur
              - hi
              - sw
              - de
              - pt
              - ta
              - gu
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UtilityLabels'
        '404':
          description: Unknown source_language.
  /inflections/{source_lang}/{word_id}/{filters}:
    get:
      tags:
        - Lemmatron
      summary: Check a word exists in the dictionary and retrieve its root form
      operationId: Lemmatron_checkAndRetrieveRootForm
      security:
        - appId: []
          appKey: []
      description: >

        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>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - nso
              - tn
              - zu
              - de
              - pt
            type: string
        - description: >-
            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.
          in: path
          name: filters
          required: true
          schema:
            default: grammaticalFeatures=singular,past;lexicalCategory=noun
            items:
              pattern: (lexicalCategory|grammaticalFeatures)=.+
              type: string
            type: string
          style: simple
        - description: The input word
          in: path
          name: word_id
          required: true
          schema:
            default: swimming
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Lemmatron'
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
  /languages:
    get:
      tags:
        - Utility
      summary: Lists available dictionaries
      operationId: Utility_listAvailableLanguages
      security:
        - appId: []
          appKey: []
      description: >
        Returns a list of monolingual and bilingual language datasets available
        in the API
      parameters:
        - description: >-
            IANA language code. If provided output will be filtered by
            sourceLanguage.
          in: query
          name: sourceLanguage
          required: false
          schema:
            enum:
              - es
              - en
              - lv
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - hi
              - sw
              - ro
              - de
              - pt
              - ta
              - gu
            type: string
        - description: >-
            IANA language code. If provided output will be filtered by
            sourceLanguage.
          in: query
          name: targetLanguage
          required: false
          schema:
            enum:
              - es
              - en
              - lv
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - hi
              - sw
              - ro
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Languages'
        '404':
          description: Unknown sourceLanguage and/or targetLanguage.
        '500':
          description: Internal Error. An error occurred while processing the data.
  /lexicalcategories/{language}:
    get:
      tags:
        - Utility
      summary: Lists available lexical categories in a dataset
      operationId: Utility_getLexicalCategories
      security:
        - appId: []
          appKey: []
      description: >
        Returns a list of available [lexical
        categories](documentation/glossary?term=lexicalcategory) for a given
        language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: language
          required: true
          schema:
            enum:
              - es
              - en
              - lv
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - hi
              - sw
              - ro
              - de
              - pt
              - ta
              - gu
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UtilityLabels'
        '404':
          description: Unknown language.
        '500':
          description: Internal Error. An error occurred while processing the data.
  /regions/{source_language}:
    get:
      tags:
        - Utility
      summary: Lists available regions in a monolingual dataset
      operationId: Utility_listMonolingualRegions
      security:
        - appId: []
          appKey: []
      description: >
        Returns a list of the available
        [regions](documentation/glossary?term=regions) for a given monolingual
        language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Regions'
        '404':
          description: Unknown source_language.
  /registers/{source_language}:
    get:
      tags:
        - Utility
      summary: Lists available registers in a  monolingual dataset
      operationId: Utility_listMonolingualRegisters
      security:
        - appId: []
          appKey: []
      description: >
        Returns a list of the available
        [registers](documentation/glossary?term=registers) for a given
        monolingual language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - id
              - lv
              - ms
              - sw
              - ur
              - de
              - pt
              - ta
              - gu
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UtilityLabels'
        '404':
          description: Unknown source_language.
        '500':
          description: Internal Error. An error occurred while processing the data.
  /registers/{source_register_language}/{target_register_language}:
    get:
      tags:
        - Utility
      summary: Lists available registers in a bilingual dataset
      operationId: Utility_listBilingualRegisters
      security:
        - appId: []
          appKey: []
      description: >
        Returns a list of the available
        [registers](documentation/glossary?term=registers) for a given bilingual
        language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_register_language
          required: true
          schema:
            enum:
              - en
              - es
              - ms
              - id
              - ur
              - de
              - pt
            type: string
        - description: IANA language code
          in: path
          name: target_register_language
          required: true
          schema:
            enum:
              - es
              - en
              - nso
              - zu
              - ms
              - id
              - tn
              - ro
              - de
              - pt
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UtilityLabels'
        '400':
          description: source_language and target_language are same.
        '404':
          description: Unknown source_language and/or target_language.
        '500':
          description: Internal Error. An error occurred while processing the data.
  /search/{source_lang}:
    get:
      tags:
        - Search
      summary: Retrieve possible matches to input
      operationId: Search_getMatches
      security:
        - appId: []
          appKey: []
      description: >

        Use this to retrieve possible
        [headword](documentation/glossary?term=headword) matches for a given
        string of text. The results are culculated using headword matching,
        fuzzy matching, and [lemmatization](documentation/glossary?term=lemma) 

          <div id="search"></div>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - lv
              - sw
              - ta
              - gu
            type: string
        - description: Search string
          in: query
          name: q
          required: false
          schema:
            default: eye
            type: string
        - description: >-
            Set prefix to true if you'd like to get results only starting with
            search string.
          in: query
          name: prefix
          required: false
          schema:
            default: 'false'
            enum:
              - 'false'
              - 'true'
            type: string
        - description: >-
            If searching in English, filter words with specific region(s) either
            'us' or 'gb'.
          in: query
          name: regions
          required: false
          schema:
            type: string
        - description: >-
            Limit the number of results per response. Default and maximum limit
            is 5000.
          in: query
          name: limit
          required: false
          schema:
            type: string
        - description: Offset the start number of the result.
          in: query
          name: offset
          required: false
          schema:
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Wordlist'
        '404':
          description: >
            No entry is found matching supplied id and source_lang or filters
            are not recognized
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
  /search/{source_search_language}/translations={target_search_language}:
    get:
      tags:
        - Search
      summary: Retrieve possible translation matches to input
      operationId: Search_possibleTranslations
      security:
        - appId: []
          appKey: []
      description: |

        Use this to find matches in our translation dictionaries.

          <div id="search_translation"></div>
      parameters:
        - description: IANA language code
          in: path
          name: source_search_language
          required: true
          schema:
            enum:
              - en
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - de
              - pt
            type: string
        - description: IANA language code
          in: path
          name: target_search_language
          required: true
          schema:
            enum:
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ro
              - de
              - pt
            type: string
        - description: Search string.
          in: query
          name: q
          required: false
          schema:
            default: eye
            type: string
        - description: >-
            Set prefix to true if you'd like to get results only starting with
            search string.
          in: query
          name: prefix
          required: false
          schema:
            default: 'false'
            enum:
              - 'false'
              - 'true'
            type: string
        - description: >-
            Filter words with specific region(s) E.g., regions=us. For now gb,
            us are available for en language.
          in: query
          name: regions
          required: false
          schema:
            type: string
        - description: >-
            Limit the number of results per response. Default and maximum limit
            is 5000.
          in: query
          name: limit
          required: false
          schema:
            type: string
        - description: Offset the start number of the result.
          in: query
          name: offset
          required: false
          schema:
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Wordlist'
        '404':
          description: >
            No entry is found matching supplied id and source_lang or filters
            are not recognized
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
  /wordlist/{source_lang}/{filters_advanced}:
    get:
      tags:
        - Wordlist
      summary: Retrieve list of words for category with advanced options
      operationId: Wordlist_getAdvancedWords
      security:
        - appId: []
          appKey: []
      description: >
        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>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - lv
              - sw
              - ta
              - gu
            type: string
        - description: >-
            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.
          in: path
          name: filters_advanced
          required: true
          schema:
            default: lexicalCategory=Noun;domains=sport
            type: string
        - description: >-
            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.
          in: query
          name: exclude
          required: false
          schema:
            type: string
        - description: >-
            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.
          in: query
          name: exclude_senses
          required: false
          schema:
            type: string
        - description: >-
            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).
          in: query
          name: exclude_prime_senses
          required: false
          schema:
            type: string
        - description: >-
            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.
          in: query
          name: word_length
          required: false
          schema:
            default: '>5,<10'
            type: string
        - description: Filter words that start with prefix parameter
          in: query
          name: prefix
          required: false
          schema:
            default: goal
            type: string
        - description: >-
            If exact=true wordlist returns a list of entries that exactly
            matches the search string. Otherwise wordlist lists entries that
            start with prefix string.
          in: query
          name: exact
          required: false
          schema:
            default: 'false'
            enum:
              - 'false'
              - 'true'
            type: string
        - description: >-
            Limit the number of results per response. Default and maximum limit
            is 5000.
          in: query
          name: limit
          required: false
          schema:
            type: string
        - description: Offset the start number of the result.
          in: query
          name: offset
          required: false
          schema:
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Wordlist'
        '400':
          description: >-
            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':
          description: >
            No entries is found matching supplied filters or lang or filters is
            not recognized.
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
  /wordlist/{source_lang}/{filters_basic}:
    get:
      tags:
        - Wordlist
      summary: Retrieve a list of words in a category
      operationId: Wordlist_getCategoryWords
      security:
        - appId: []
          appKey: []
      description: >

        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>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - lv
              - sw
              - ta
              - gu
            type: string
        - description: >-
            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.
          in: path
          name: filters_basic
          required: true
          schema:
            default: registers=Rare;domains=Art
            type: string
        - description: >-
            Limit the number of results per response. Default and maximum limit
            is 5000.
          in: query
          name: limit
          required: false
          schema:
            type: string
        - description: Offset the start number of the result
          in: query
          name: offset
          required: false
          schema:
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Wordlist'
        '400':
          description: filter has no values; total number of filters > 20.
        '404':
          description: >
            No entries is found matching supplied filters or lang or filters is
            not recognized.
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
  /stats/frequency/ngrams/{source_lang}/{corpus}/{ngram-size}:
    get:
      tags:
        - LexiStats
      summary: Retrieve the frequency of ngrams (1-4) derived from a corpus
      operationId: LexiStats_getNgramFrequencies
      security:
        - appId: []
          appKey: []
      description: >
        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')
        ```
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            default: en
            type: string
        - description: >-
            For corpora other than 'nmc' (New Monitor Corpus) please contact
            api@oxforddictionaries.com
          in: path
          name: corpus
          required: true
          schema:
            default: nmc
            type: string
        - description: the size of ngrams requested (1-4)
          in: path
          name: ngram-size
          required: true
          schema:
            default: 2
            type: string
        - description: >-
            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)
          in: query
          name: tokens
          required: false
          schema:
            default: a word
            type: string
        - description: >-
            Find ngrams containing the given token(s). Use comma or space as
            token separators; the order of tokens is irrelevant.
          in: query
          name: contains
          required: false
          schema:
            type: string
        - description: >-
            Flag specifying whether to lookup ngrams that include punctuation or
            not (possible values are "true" and "false"; default is "false")
          in: query
          name: punctuation
          required: false
          schema:
            type: string
        - description: >-
            Option specifying whether tokens should be returned as a single
            string (option "google") or as a list of strings (option "oup")
          in: query
          name: format
          required: false
          schema:
            default: oup
            type: string
        - description: >-
            Restrict the query to entries with frequency of at least
            `minFrequency`
          in: query
          name: minFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: >-
            Restrict the query to entries with frequency of at most
            `maxFrequency`
          in: query
          name: maxFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: >-
            Restrict the query to entries that appear in at least
            `minDocumentFrequency` documents
          in: query
          name: minDocumentFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: >-
            Restrict the query to entries that appera in at most
            `maxDocumentFrequency` documents
          in: query
          name: maxDocumentFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: >-
            collate the results by wordform, trueCase, lemma, lexicalCategory.
            Multiple values can be separated by commas (e.g.,
            collate=trueCase,lemma,lexicalCategory).
          in: query
          name: collate
          required: false
          schema:
            type: string
        - description: >-
            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)
          in: query
          name: sort
          required: false
          schema:
            type: string
        - description: pagination - results offset
          in: query
          name: offset
          required: false
          schema:
            default: 0
            format: int64
            type: integer
        - description: pagination - results limit
          in: query
          name: limit
          required: false
          schema:
            default: 100
            format: int64
            type: integer
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/NgramsResult'
            text/csv:
              schema:
                $ref: '#/components/schemas/NgramsResult'
        '400':
          description: |
            Invalid option name...
        '404':
          description: |
            language is not in...
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
  /stats/frequency/word/{source_lang}:
    get:
      tags:
        - LexiStats
      summary: Retrieve the frequency of a word derived from a corpus.
      operationId: LexiStats_getWordFrequency
      security:
        - appId: []
          appKey: []
      description: >
        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.
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            default: en
            type: string
        - description: >-
            For corpora other than 'nmc' (New Monitor Corpus) please contact
            api@oxforddictionaries.com
          in: query
          name: corpus
          required: false
          schema:
            default: nmc
            type: string
        - description: >-
            The written form of the word to look up (preserving case e.g., Books
            vs books)
          in: query
          name: wordform
          required: false
          schema:
            type: string
        - description: >-
            The written form of the word to look up with normalised case (Books
            --> books)
          in: query
          name: trueCase
          required: false
          schema:
            type: string
        - description: >-
            The lemma of the word to look up (e.g., Book, booked, books all have
            the lemma "book")
          in: query
          name: lemma
          required: false
          schema:
            default: test
            type: string
        - description: The lexical category of the word(s) to look up (e.g., noun or verb)
          in: query
          name: lexicalCategory
          required: false
          schema:
            type: string
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StatsWordResult'
            text/csv:
              schema:
                $ref: '#/components/schemas/StatsWordResult'
        '400':
          description: >
            You need to specify at least one option. Try one of 'wordform,
            lemma, trueCase, lexicalCategory'.
        '404':
          description: |
            language is not in...
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
  /stats/frequency/words/{source_lang}:
    get:
      tags:
        - LexiStats
      summary: Retrieve a list of frequencies of a word/words derived from a corpus.
      operationId: LexiStats_getWordFrequencies
      security:
        - appId: []
          appKey: []
      description: >
        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')
        ```
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            default: en
            type: string
        - description: >-
            For corpora other than 'nmc' (New Monitor Corpus) please contact
            api@oxforddictionaries.com
          in: query
          name: corpus
          required: false
          schema:
            default: nmc
            type: string
        - description: >-
            The written form of the word to look up (preserving case e.g., Book
            vs book)
          in: query
          name: wordform
          required: false
          schema:
            type: string
        - description: >-
            The written form of the word to look up with normalised case (Books
            --> books)
          in: query
          name: trueCase
          required: false
          schema:
            type: string
        - description: >-
            The lemma of the word to look up (e.g., Book, booked, books all have
            the lemma "book")
          in: query
          name: lemma
          required: false
          schema:
            default: test
            type: string
        - description: >-
            The lexical category of the word(s) to look up (e.g., adjective or
            noun)
          in: query
          name: lexicalCategory
          required: false
          schema:
            type: string
        - description: >-
            The grammatical features of the word(s) to look up entered as a list
            of k:v (e.g., degree_type:comparative)
          in: query
          name: grammaticalFeatures
          required: false
          schema:
            type: string
        - description: >-
            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)
          in: query
          name: sort
          required: false
          schema:
            type: string
        - description: >-
            collate the results by wordform, trueCase, lemma, lexicalCategory.
            Multiple values can be separated by commas (e.g.,
            collate=trueCase,lemma,lexicalCategory).
          in: query
          name: collate
          required: false
          schema:
            type: string
        - description: >-
            Restrict the query to entries with frequency of at least
            `minFrequency`
          in: query
          name: minFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: >-
            Restrict the query to entries with frequency of at most
            `maxFrequency`
          in: query
          name: maxFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: >-
            Restrict the query to entries with frequency of at least
            `minNormalizedFrequency`
          in: query
          name: minNormalizedFrequency
          required: false
          schema:
            format: float
            type: number
        - description: >-
            Restrict the query to entries with frequency of at most
            `maxNormalizedFrequency`
          in: query
          name: maxNormalizedFrequency
          required: false
          schema:
            format: float
            type: number
        - description: pagination - results offset
          in: query
          name: offset
          required: false
          schema:
            default: 0
            format: int64
            type: integer
        - description: pagination - results limit
          in: query
          name: limit
          required: false
          schema:
            default: 100
            format: int64
            type: integer
      responses:
        '200':
          description: Successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StatsWordResultList'
            text/csv:
              schema:
                $ref: '#/components/schemas/StatsWordResultList'
        '400':
          description: >-
            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':
          description: |
            language is not in...
        '500':
          description: |
            Internal Error. An error occurred while processing the data.
components:
  parameters:
    appId:
      description: App ID Authentication Parameter
      in: header
      name: app_id
      required: true
      schema:
        default: 5037d509
        type: string
      x-data-threescale-name: app_ids
    appKey:
      description: App Key Authentication Parameter
      in: header
      name: app_key
      required: true
      schema:
        default: 4dc1aebaa63721f0f8e79a55e2514bc7
        type: string
      x-data-threescale-name: app_keys
    entriesWordId:
      description: An Entry identifier. Case-sensitive.
      in: path
      name: word_id
      required: true
      schema:
        default: ace
        type: string
    keyValFilters:
      description: >-
        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.
      in: path
      name: filters
      required: true
      schema:
        default: grammaticalFeatures=singular,past;lexicalCategory=noun
        items:
          pattern: (lexicalCategory|grammaticalFeatures)=.+
          type: string
        type: string
      style: simple
    monolingual-lemmatron-source_lang:
      description: IANA language code
      in: path
      name: source_lang
      required: true
      schema:
        enum:
          - en
          - es
          - hi
          - nso
          - tn
          - zu
          - de
          - pt
        type: string
    monolingual-source_lang:
      description: IANA language code
      in: path
      name: source_lang
      required: true
      schema:
        enum:
          - en
          - es
          - lv
          - hi
          - sw
          - ta
          - gu
          - fr
        type: string
    monolingual-wordlist-source_lang:
      description: IANA language code
      in: path
      name: source_lang
      required: true
      schema:
        enum:
          - en
          - es
          - hi
          - lv
          - sw
          - ta
          - gu
        type: string
    thesaurus-source_lang:
      description: IANA language code
      in: path
      name: source_lang
      required: true
      schema:
        enum:
          - en
        type: string
  schemas:
    ArrayOfRelatedEntries:
      description: A list of written or spoken words
      items:
        properties:
          domains:
            $ref: '#/components/schemas/arrayofstrings'
          id:
            description: The identifier of the word
            type: string
          language:
            description: IANA language code specifying the language of the word
            type: string
          regions:
            $ref: '#/components/schemas/arrayofstrings'
          registers:
            $ref: '#/components/schemas/arrayofstrings'
          text:
            type: string
        required:
          - text
          - id
        type: object
      minItems: 1
      type: array
    CategorizedTextList:
      description: various types of notes that appear
      items:
        properties:
          id:
            description: The identifier of the word
            type: string
          text:
            description: A note text
            type: string
          type:
            description: The descriptive category of the text
            type: string
        required:
          - text
          - type
        type: object
      minItems: 1
      type: array
    CrossReferencesList:
      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.
      items:
        description: cross references of a sense
        properties:
          id:
            description: The word id of cooccurrence
            type: string
          text:
            description: The word of cooccurrence
            type: string
          type:
            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.
            type: string
        required:
          - id
          - text
          - type
        type: object
      minItems: 1
      type: array
    Entry:
      minProperties: 1
      properties:
        etymologies:
          $ref: '#/components/schemas/arrayofstrings'
        grammaticalFeatures:
          $ref: '#/components/schemas/GrammaticalFeaturesList'
        homographNumber:
          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.
          type: string
        notes:
          $ref: '#/components/schemas/CategorizedTextList'
        pronunciations:
          $ref: '#/components/schemas/PronunciationsList'
        senses:
          description: Complete list of senses
          items:
            $ref: '#/components/schemas/Sense'
          minItems: 1
          type: array
        variantForms:
          $ref: '#/components/schemas/VariantFormsList'
      type: object
    ExamplesList:
      description: >-
        A list of written or spoken rendering of examples of use of a word or
        text
      items:
        properties:
          definitions:
            $ref: '#/components/schemas/arrayofstrings'
          domains:
            $ref: '#/components/schemas/arrayofstrings'
          notes:
            $ref: '#/components/schemas/CategorizedTextList'
          regions:
            $ref: '#/components/schemas/arrayofstrings'
          registers:
            $ref: '#/components/schemas/arrayofstrings'
          senseIds:
            $ref: '#/components/schemas/arrayofstrings'
          text:
            type: string
          translations:
            $ref: '#/components/schemas/TranslationsList'
        required:
          - text
        type: object
      minItems: 1
      type: array
    Filters:
      description: Schema for the Filters endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A mapping of filters available per endpoints.
          minProperties: 1
          properties:
            entries:
              $ref: '#/components/schemas/arrayofstrings'
            inflections:
              $ref: '#/components/schemas/arrayofstrings'
            translations:
              $ref: '#/components/schemas/arrayofstrings'
            wordlist:
              $ref: '#/components/schemas/arrayofstrings'
          type: object
    GrammaticalFeaturesList:
      description: >-
        The different forms are correlated with meanings or functions which we
        text as 'features'
      items:
        properties:
          text:
            type: string
          type:
            type: string
        required:
          - text
          - type
        type: object
      minItems: 1
      type: array
    HeadwordEntry:
      description: Description of a word
      properties:
        id:
          description: The identifier of a word
          type: string
        language:
          description: IANA language code
          type: string
        lexicalEntries:
          description: >-
            A grouping of various senses in a specific language, and a lexical
            category that relates to a word
          items:
            $ref: '#/components/schemas/lexicalEntry'
          minItems: 1
          type: array
        pronunciations:
          $ref: '#/components/schemas/PronunciationsList'
        type:
          description: The json object type. Could be 'headword', 'inflection' or 'phrase'
          type: string
        word:
          description: A given written or spoken realisation of a an entry, lowercased.
          type: string
      required:
        - id
        - language
        - lexicalEntries
        - word
      type: object
    HeadwordLemmatron:
      description: Description of an inflected form of a word
      properties:
        id:
          description: The identifier of a word
          type: string
        language:
          description: IANA language code
          type: string
        lexicalEntries:
          description: >-
            A grouping of various senses in a specific language, and a lexical
            category that relates to a word
          items:
            $ref: '#/components/schemas/LemmatronLexicalEntry'
          minItems: 1
          type: array
        type:
          description: The json object type. Could be 'headword', 'inflection' or 'phrase'
          type: string
        word:
          description: A given written or spoken realisation of a an entry, lowercased.
          type: string
      required:
        - id
        - language
        - lexicalEntries
        - word
      type: object
    HeadwordThesaurus:
      description: description of thesaurus information of a word
      properties:
        id:
          description: The identifier of a word
          type: string
        language:
          description: IANA language code
          type: string
        lexicalEntries:
          description: >-
            A grouping of various senses in a specific language, and a lexical
            category that relates to a word
          items:
            $ref: '#/components/schemas/ThesaurusLexicalEntry'
          minItems: 1
          type: array
        type:
          description: The json object type. Could be 'headword', 'inflection' or 'phrase'
          type: string
        word:
          description: A given written or spoken realisation of a an entry, lowercased.
          type: string
      required:
        - word
        - id
        - language
        - lexicalEntries
      type: object
    InflectionsList:
      description: >-
        A grouping of the modifications of a word to express different
        grammatical categories
      items:
        properties:
          id:
            description: The identifier of the word
            type: string
          text:
            type: string
        required:
          - text
          - id
        type: object
      minItems: 1
      type: array
    Languages:
      description: Schema for the languages endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of languages available.
          items:
            minProperties: 1
            properties:
              region:
                description: Name of region.
                type: string
              source:
                description: Name of source dictionary.
                type: string
              sourceLanguage:
                description: Source language of the results
                properties:
                  id:
                    description: IANA language code
                    type: string
                  language:
                    description: Language label.
                    type: string
                type: object
              targetLanguage:
                description: Translation language of the results
                properties:
                  id:
                    description: IANA language code
                    type: string
                  language:
                    description: Language label.
                    type: string
                type: object
              type:
                description: whether monolingual or bilingual.
                enum:
                  - monolingual
                  - bilingual
                type: string
            type: object
          minItems: 1
          type: array
      type: object
    Lemmatron:
      description: Schema for the inflections endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of inflections matching a given word
          items:
            $ref: '#/components/schemas/HeadwordLemmatron'
          minItems: 1
          type: array
      type: object
    LemmatronLexicalEntry:
      description: >-
        Description of an entry for a particular part of speech and grammatical
        features
      properties:
        grammaticalFeatures:
          $ref: '#/components/schemas/GrammaticalFeaturesList'
        inflectionOf:
          $ref: '#/components/schemas/InflectionsList'
        language:
          description: IANA language code
          type: string
        lexicalCategory:
          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
          type: string
        text:
          description: A given written or spoken realisation of a an entry.
          type: string
      required:
        - inflectionOf
        - language
        - lexicalCategory
        - text
      type: object
    NgramsResult:
      description: Schema for corpus ngrams.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of found ngrams along with their frequencies
          items:
            description: Ngrams matching the given options
            additionalProperties: true
            properties:
              frequency:
                description: >-
                  The number of times the ngram (a sequence of n words) appears
                  in the corpus
                type: integer
              tokens:
                description: A list of tokens
                items:
                  type: string
                minItems: 1
                type: array
            required:
              - tokens
              - frequency
            type: object
          minItems: 0
          type: array
      type: object
    PronunciationsList:
      description: A list of possible pronunciations of a word
      items:
        description: A grouping of pronunciation information
        minProperties: 1
        properties:
          audioFile:
            description: The URL of the sound file
            type: string
          dialects:
            $ref: '#/components/schemas/arrayofstrings'
          phoneticNotation:
            description: The alphabetic system used to display the phonetic spelling
            type: string
          phoneticSpelling:
            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
            type: string
          regions:
            $ref: '#/components/schemas/arrayofstrings'
        type: object
      minItems: 1
      type: array
    Regions:
      description: Schema for region endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A mapping of regions available.
          additionalProperties:
            $ref: '#/components/schemas/arrayofstrings'
          type: object
    RetrieveEntry:
      description: Schema for the 'entries' endpoints
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of entries and all the data related to them
          items:
            $ref: '#/components/schemas/HeadwordEntry'
          minItems: 1
          type: array
      type: object
    Sense:
      description: >-
        A lexical sense represents the lexical meaning of a lexical entry when
        interpreted as referring to the corresponding ontology element
      minProperties: 1
      properties:
        crossReferenceMarkers:
          $ref: '#/components/schemas/arrayofstrings'
        crossReferences:
          $ref: '#/components/schemas/CrossReferencesList'
        definitions:
          $ref: '#/components/schemas/arrayofstrings'
        domains:
          $ref: '#/components/schemas/arrayofstrings'
        examples:
          $ref: '#/components/schemas/ExamplesList'
        id:
          description: The id of the sense that is required for the delete procedure
          type: string
        notes:
          $ref: '#/components/schemas/CategorizedTextList'
        pronunciations:
          $ref: '#/components/schemas/PronunciationsList'
        regions:
          $ref: '#/components/schemas/arrayofstrings'
        registers:
          $ref: '#/components/schemas/arrayofstrings'
        short_definitions:
          $ref: '#/components/schemas/arrayofstrings'
        subsenses:
          description: Ordered list of subsenses of a sense
          items:
            $ref: '#/components/schemas/Sense'
          minItems: 1
          type: array
        thesaurusLinks:
          description: Ordered list of links to the Thesaurus Dictionary
          items:
            $ref: '#/components/schemas/thesaurusLink'
          minItems: 1
          type: array
        translations:
          $ref: '#/components/schemas/TranslationsList'
        variantForms:
          $ref: '#/components/schemas/VariantFormsList'
      type: object
    SentencesEntry:
      description: Description of a word
      properties:
        id:
          description: The identifier of a word
          type: string
        language:
          description: IANA language code
          type: string
        lexicalEntries:
          description: >-
            A grouping of various senses in a specific language, and a lexical
            category that relates to a word
          items:
            $ref: '#/components/schemas/SentencesLexicalEntry'
          minItems: 1
          type: array
        type:
          description: The json object type. Could be 'headword', 'inflection' or 'phrase'
          type: string
        word:
          description: A given written or spoken realisation of a an entry, lowercased.
          type: string
      required:
        - id
        - language
        - lexicalEntries
        - word
      type: object
    SentencesLexicalEntry:
      description: Description of an entry for a particular part of speech
      properties:
        grammaticalFeatures:
          $ref: '#/components/schemas/GrammaticalFeaturesList'
        language:
          description: IANA language code
          type: string
        lexicalCategory:
          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
          type: string
        sentences:
          $ref: '#/components/schemas/ExamplesList'
        text:
          description: A given written or spoken realisation of a an entry.
          type: string
      required:
        - language
        - sentences
        - text
      type: object
    SentencesResults:
      description: Schema for the 'sentences' endpoint
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of entries and all the data related to them
          items:
            $ref: '#/components/schemas/SentencesEntry'
          minItems: 1
          type: array
      type: object
    StatsWordResult:
      description: >-
        Schema for lexi-stats results for a word/trueCase/lemma/lexicalCategory
        returned as a frequency
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        result:
          description: Frequency information for a given entity
          additionalProperties: true
          properties:
            frequency:
              description: The number of times a word appears in the entire corpus
              type: integer
            lemma:
              description: >-
                A lemma of the word (e.g., wordforms "lay", "laid" and "laying"
                have all lemma "lay")
              type: string
            lexicalCategory:
              description: A lexical category such as 'verb' or 'noun'
              type: string
            matchCount:
              description: >-
                The number of database records that matched the query params
                (stated frequency is the sum of the individual frequencies)
              type: integer
            normalizedFrequency:
              description: The number of times a word appears on average in 1 million words
              type: integer
            trueCase:
              description: >-
                A given written realisation of a an entry (e.g., "lay") usually
                lower case
              type: string
            wordform:
              description: >-
                A given written realisation of a an entry (e.g., "Lay")
                preserving case
              type: string
          required:
            - frequency
            - normalizedFrequency
            - matchCount
          type: object
      type: object
    StatsWordResultList:
      description: >-
        Schema for lexi-stats results for a word/trueCase/lemma/lexicalCategory
        returned as a list of frequencies per
        wordform-trueCase-lemma-lexicalCategory entry.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of found words along with their frequencies
          items:
            description: Statistical information about a word
            additionalProperties: true
            properties:
              frequency:
                description: The number of times a word appears in the entire corpus
                type: integer
              lemma:
                description: A lemma of the word.
                type: string
              lexicalCategory:
                description: A lexical category such as 'verb' or 'noun'
                type: string
              normalizedFrequency:
                description: >-
                  The number of times a word appears on average in 1 million
                  words
                type: integer
              trueCase:
                description: >-
                  A given written realisation of a an entry (e.g., "lay")
                  usually lower case
                type: string
              wordform:
                description: >-
                  A given written realisation of a an entry (e.g., "lay")
                  preserving case
                type: string
            required:
              - wordform
              - trueCase
              - lemma
              - lexicalCategory
              - frequency
              - normalizedFrequency
            type: object
          minItems: 0
          type: array
      type: object
    SynonymsAntonyms:
      items:
        properties:
          domains:
            $ref: '#/components/schemas/arrayofstrings'
          id:
            type: string
          language:
            type: string
          regions:
            $ref: '#/components/schemas/arrayofstrings'
          registers:
            $ref: '#/components/schemas/arrayofstrings'
          text:
            type: string
        required:
          - id
          - text
        type: object
      minItems: 1
      type: array
    Thesaurus:
      description: Schema for thesaurus endpoint
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of found synonyms or antonyms
          items:
            $ref: '#/components/schemas/HeadwordThesaurus'
          minItems: 1
          type: array
      type: object
    ThesaurusEntry:
      minProperties: 1
      properties:
        homographNumber:
          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.
          type: string
        senses:
          description: Complete list of senses
          items:
            $ref: '#/components/schemas/ThesaurusSense'
          minItems: 1
          type: array
        variantForms:
          $ref: '#/components/schemas/VariantFormsList'
      type: object
    ThesaurusLexicalEntry:
      description: Description of an entry for a particular part of speech
      properties:
        entries:
          items:
            $ref: '#/components/schemas/ThesaurusEntry'
          minItems: 1
          type: array
        language:
          description: IANA language code
          type: string
        lexicalCategory:
          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
          type: string
        text:
          description: A given written or spoken realisation of a an entry.
          type: string
        variantForms:
          $ref: '#/components/schemas/VariantFormsList'
      required:
        - language
        - lexicalCategory
        - text
      type: object
    ThesaurusSense:
      description: >-
        A lexical sense represents the lexical meaning of a lexical entry when
        interpreted as referring to the corresponding ontology element
      minProperties: 1
      properties:
        antonyms:
          $ref: '#/components/schemas/SynonymsAntonyms'
        domains:
          $ref: '#/components/schemas/arrayofstrings'
        examples:
          $ref: '#/components/schemas/ExamplesList'
        id:
          description: The id of the sense that is required for the delete procedure
          type: string
        regions:
          $ref: '#/components/schemas/arrayofstrings'
        registers:
          $ref: '#/components/schemas/arrayofstrings'
        subsenses:
          description: subsenses of word
          items:
            $ref: '#/components/schemas/ThesaurusSense'
          minItems: 1
          type: array
        synonyms:
          $ref: '#/components/schemas/SynonymsAntonyms'
      type: object
    TranslationsList:
      description: >-
        A list of written or spoken rendering of the meaning of a word or text
        in another language(s)
      items:
        properties:
          domains:
            $ref: '#/components/schemas/arrayofstrings'
          grammaticalFeatures:
            $ref: '#/components/schemas/GrammaticalFeaturesList'
          language:
            description: IANA language code specifying the language of the translation
            type: string
          notes:
            $ref: '#/components/schemas/CategorizedTextList'
          regions:
            $ref: '#/components/schemas/arrayofstrings'
          registers:
            $ref: '#/components/schemas/arrayofstrings'
          text:
            type: string
        required:
          - text
          - language
        type: object
      minItems: 1
      type: array
    UtilityLabels:
      description: Schema for lexicalcategories, registers utility endpoints.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: Mapping of labels available.
          additionalProperties:
            description: >-
              the list of labels for an object. Every object can be a lexical
              category, or a register, or a domain.
            properties:
              en:
                description: Label in English
                type: string
            type: object
          type: object
    VariantFormsList:
      description: >-
        Various words that are used interchangeably depending on the context,
        e.g 'aluminium' and 'aluminum'
      items:
        properties:
          regions:
            $ref: '#/components/schemas/arrayofstrings'
          text:
            type: string
        required:
          - text
        type: object
      minItems: 1
      type: array
    Wordlist:
      description: Schema for wordlist endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of found words
          items:
            description: Description of found word
            additionalProperties: true
            properties:
              id:
                description: The identifier of a word
                type: string
              matchString:
                nullable: true
                type: string
              matchType:
                type: string
              region:
                description: Name of region.
                type: string
              word:
                description: >-
                  A given written or spoken realisation of a an entry,
                  lowercased.
                type: string
            required:
              - id
              - word
            type: object
          minItems: 0
          type: array
      type: object
    arrayofstrings:
      items:
        type: string
      type: array
    lexicalEntry:
      description: Description of an entry for a particular part of speech
      properties:
        derivativeOf:
          $ref: '#/components/schemas/ArrayOfRelatedEntries'
        derivatives:
          $ref: '#/components/schemas/ArrayOfRelatedEntries'
        entries:
          items:
            $ref: '#/components/schemas/Entry'
          minItems: 1
          type: array
        grammaticalFeatures:
          $ref: '#/components/schemas/GrammaticalFeaturesList'
        language:
          description: IANA language code
          type: string
        lexicalCategory:
          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
          type: string
        notes:
          $ref: '#/components/schemas/CategorizedTextList'
        pronunciations:
          $ref: '#/components/schemas/PronunciationsList'
        text:
          description: A given written or spoken realisation of a an entry.
          type: string
        variantForms:
          $ref: '#/components/schemas/VariantFormsList'
      required:
        - language
        - lexicalCategory
        - text
      type: object
    thesaurusLink:
      description: Link to a sense of a specific entry in the thesaurus Dictionary
      properties:
        entry_id:
          description: identifier of a word
          type: string
        sense_id:
          description: identifier of a sense
          type: string
      required:
        - entry_id
        - sense_id
      type: object
  securitySchemes:
    appId:
      type: apiKey
      in: header
      name: app_id
    appKey:
      type: apiKey
      in: header
      name: app_key
security:
  - appId: []
  - appKey: []
x-hasEquivalentPaths: true