openapi: 3.0.0
servers:
  - url: https://www.data.gv.at/katalog/api/3
info:
  description: >
    data.gv.at API Documentation
  version: 1.0.0
  title: data.gv.at API
  contact:
    email: info@data.gv.at
  license:
    name: CC BY 4.0
    url: https://creativecommons.org/licenses/by/4.0/
tags:
  - name: datasets
    description: datasets
  - name: datamanagement
    description: datamanagement
  - name: organizations
    description: organizations
  - name: authentication
    description: authentication
  - name: activity
    description: activity
  - name: social
    description: social
  - name: serveradmin
    description: Secured Admin-only calls
security: []
paths:
  /action/package_list:
    get:
      tags:
        - datasets
      summary: List all datasets within given limit
      description: |
        List or search all datasets
      operationId: listInventory
      parameters:
        - name: offset
          in: query
          description: when limit is given, the offset to start returning packages from
          required: false
          schema:
            type: integer
        - name: limit
          in: query
          description: if given, the list of datasets will be broken into pages of at most limit datasets per page and only one page will be returned at a time
          required: false
          schema:
            type: integer
      responses:
        "200":
          description: search results matching criteria
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: array
                    items:
                      type: string
                    example: [dataset-1, dataset-2]
        "400":
          description: bad input parameter
  /action/package_search:
    get:
      tags:
        - datasets
      summary: Search among all datasets
      description: |
        List or search all datasets
      operationId: searchInventory
      parameters:
        - name: q
          in: query
          description: the solr query. For example ``name:pdf-testi``
          required: false
          schema:
            type: string
            default: "*:*"
        - name: fq
          in: query
          description: >
            any filter queries to apply. Note: +site_id:{ckan_site_id} is added to this string prior to the query being executed.
          required: false
          schema:
            type: string
        - name: sort
          in: query
          description: >
            sorting of the search results. Optional. **Default: 'relevance asc, metadata_modified desc'**. As per the solr documentation, this is a comma-separated string of field names and sort-orderings.
          required: false
          schema:
            type: string
            default: relevance asc, metadata_modified desc
        - name: rows
          in: query
          description: the number of matching rows to return. There is a hard limit of 1000 datasets per query.
          required: false
          schema:
            type: integer
        - name: start
          in: query
          description: the offset in the complete result for where the set of returned datasets should begin.
          required: false
          schema:
            type: integer
        - name: include_drafts
          in: query
          description: if True, draft datasets will be included in the results. A user will only be returned their own draft datasets, and a sysadmin will be returned all draft datasets. Optional, the default is False.
          required: false
          schema:
            type: boolean
            default: false
      responses:
        "200":
          description: search results matching criteria
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: "#/components/schemas/MetadataEntry"
        "400":
          description: bad input parameter
        "409":
          description: Conflict (can result e.g. from incorrectly formatted solr query)
  /action/package_show:
    get:
      tags:
        - datasets
      summary: Get details of one package
      description: |
        List or search all datasets
      operationId: showInventory
      parameters:
        - name: id
          in: query
          description: the id or name of the dataset
          required: true
          schema:
            type: string
        - name: include_tracking
          in: query
          description: |
            add tracking information to dataset and resources (default: False)
          required: false
          schema:
            type: boolean
            default: false
      responses:
        "200":
          description: search results matching criteria
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    $ref: "#/components/schemas/MetadataEntry"
        "400":
          description: bad input parameter
  /action/organization_list:
    get:
      tags:
        - datasets
      summary: List all groups within given parameters
      description: |
        List or search all datasets
      operationId: listOrgs
      parameters:
        - name: sort
          in: query
          description: >
            sorting of the search results. Optional. Default: “name asc” string of field name and sort-order. The allowed fields are 'name', 'package_count' and 'title'
          required: false
          schema:
            type: string
            default: name asc
        - name: limit
          in: query
          description: >
            if given, the list of organizations will be broken into pages of at most limit organizations per page and only one page will be returned at a time
          required: false
          schema:
            type: integer
        - name: offset
          in: query
          description: >
            when limit is given, the offset to start returning organizations from
          required: false
          schema:
            type: integer
        - name: organizations
          in: query
          description: >
            a list of names of the groups to return, if given only groups whose names are in this list will be returned
          required: false
          schema:
            type: string
        - name: all_fields
          in: query
          description: >
            return group dictionaries instead of just names. Only core fields are returned - get some more using the include_* options. Returning a list of packages is too expensive, so the packages property for each group is deprecated, but there is a count of the packages in the package_count property.
          required: false
          schema:
            type: boolean
            default: false
        - name: include_dataset_count
          in: query
          description: >
            if all_fields, include the full package_count
          required: false
          schema:
            type: boolean
            default: true
        - name: include_extras
          in: query
          description: >
            if all_fields, include the organization extra fields
          required: false
          schema:
            type: boolean
            default: false
        - name: include_tags
          in: query
          description: >
            if all_fields, include the organization tags
          required: false
          schema:
            type: boolean
            default: false
        - name: include_groups
          in: query
          description: >
            if all_fields, include the organizations the organizations are in
          required: false
          schema:
            type: boolean
            default: false
        - name: include_users
          in: query
          description: >
            if all_fields, include the organization users
          required: false
          schema:
            type: boolean
            default: false
      responses:
        "200":
          description: search results matching criteria
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: "#/components/schemas/Organization"
        "400":
          description: bad input parameter
  /action/current_package_list_with_resources:
    get:
      tags:
        - datasets
      operationId: current_package_list_with_resources
      summary: Return a list of the site's datasets (packages) and their resources.
      description: >
        The list is sorted most-recently-modified first.
      parameters:
        - name: limit
          in: query
          description: if given, the list of datasets will be broken into pages of at most ``limit`` datasets per page and only one page will be returned at a time
          required: false
          schema:
            type: integer
        - name: offset
          in: query
          description: when ``limit`` is given, the offset to start returning packages from
          schema:
            type: integer
        - name: page
          in: query
          description: >
            when ``limit`` is given, which page to return, Deprecated: use ``offset``
          schema:
            type: integer
      responses:
        "200":
          description: list of packaged with resource
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: "#/components/schemas/MetadataEntry"
        "400":
          description: bad input parameter
  /action/package_autocomplete:
    get:
      operationId: package_autocomplete
      tags:
        - datasets
      summary: Return a list of datasets (packages) that match a string.
      description: >
        Datasets with names or titles that contain the query string will be returned.
      parameters:
        - name: q
          in: query
          required: true
          description: the string to search for
          schema:
            type: string
        - name: limit
          in: query
          required: false
          description: the maximum number of resource formats to return
          schema:
            type: integer
            default: 10
      responses:
        "400":
          description: bad input parameter
        "200":
          description: list of packages
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: "#/components/schemas/MetadataEntry"
  /action/group_package_show:
    get:
      operationId: group_package_show
      tags:
        - datasets
      summary: Return the datasets (packages) of a group
      parameters:
        - name: id
          required: true
          in: query
          description: the id or name of the group
          schema:
            type: string
        - name: limit
          required: false
          in: query
          description: the maximum number of datasets to return
          schema:
            type: integer
      responses:
        "400":
          description: bad input parameter
        "200":
          description: list of packages
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: "#/components/schemas/MetadataEntry"
  /action/resource_show:
    get:
      operationId: resource_show
      tags:
        - datasets
      summary: Return the metadata of a resource.
      parameters:
        - name: id
          in: query
          required: true
          description: the id of the resource
          schema:
            type: string
        - name: include_tracking
          in: query
          required: false
          description: Success tracking information to dataset and resources
          schema:
            type: boolean
            default: false
      responses:
        "400":
          description: bad input parameter
        "200":
          description: details of the package
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Resource"
  /action/resource_view_show:
    get:
      operationId: resource_view_show
      tags:
        - datasets
      summary: Return the metadata of a resource_view.
      parameters:
        - name: id
          in: query
          required: true
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: the resource view
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: array
                    items:
                      $ref: "#/components/schemas/ResourceView"
  /action/resource_view_list:
    get:
      operationId: resource_view_list
      tags:
        - datasets
      summary: Return the list of resource views for a particular resource
      description: >
        :param id: the id of the resource
          :type id: string\n
          :rtype: list of dictionaries.\n
      parameters:
        - name: id
          in: query
          required: true
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: list of resource views
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    $ref: "#/components/schemas/ResourceView"
  /action/resource_search:
    get:
      operationId: resource_search
      tags:
        - datasets
      summary: Searches for resources satisfying a given search criteria
      description: >
        It returns a dictionary with 2 fields: ``count`` and ``results``.  The ``count`` field contains the total number of Resources found without the limit or query parameters having an effect.  The ``results`` field is a list of dictized Resource objects.

        The 'query' parameter is a required field.  It is a string of the form ``{field}:{term}`` or a list of strings, each of the same form.  Within each string, ``{field}`` is a field or extra field on the Resource domain object.


        If ``{field}`` is ``"hash"``, then an attempt is made to match the `{term}` as a *prefix* of the ``Resource.hash`` field.

        If ``{field}`` is an extra field, then an attempt is made to match against the extra fields stored against the Resource.

        Note: The search is limited to search against extra fields declared in the config setting ``ckan.extra_resource_fields``.

        Note: Due to a Resource's extra fields being stored as a json blob, the match is made against the json string representation.  As such, false positives may occur:

        If the search criteria is:
            query = "field1:term1"

        Then a json blob with the string representation of:

            {field1": "foo, field2: term1}

        will match the search criteria!  This is a known short-coming of this approach.

        All matches are made ignoring case; and apart from the ``hash`` field, a term matches if it is a substring of the field's value.

        Finally, when specifying more than one search criteria, the criteria are AND-ed together.

        The ``order`` parameter is used to control the ordering of the results. Currently only ordering one field is available, and in ascending order only.

        The ``fields`` parameter is deprecated as it is not compatible with calling this action with a GET request to the action API. 

        The context may contain a flag, `search_query`, which if True will make this action behave as if being used by the internal search api.  ie - the results will not be dictized, and SearchErrors are thrown for bad search queries (rather than ValidationErrors).
      parameters:
        - name: query
          required: true
          in: query
          schema:
            type: string
          example: "name:data"
          description: The search criteria.  See above for description.
        - name: fields
          required: false
          in: query
          deprecated: true
          description: dict of fields to search terms
          schema:
            type: string
        - name: order_by
          in: query
          schema:
            type: string
        - name: offset
          in: query
          schema:
            type: string
        - name: limit
          in: query
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: list of packages
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                  success:
                    type: boolean
                  result:
                    type: object
                    properties:
                      count:
                        type: integer
                      results:
                        type: array
                        items:
                          $ref: "#/components/schemas/Resource"

  /action/api_token_list:
    get:
      operationId: api_token_list
      tags:
        - authentication
      summary: Return list of all available API Tokens for current user
      security:
        - ckanapikey: []
      responses:
        "400":
          description: bad input parameter
        "200":
          description: collection of all API Tokens
          content:
            application/json:
              schema:
                type: array
                items:
                  type: string
  /action/api_token_create:
    post:
      operationId: api_token_create
      tags:
        - authentication
      summary: Create new API Token for current user.
      description: >
        Apart from the `user` and `name` field that are required by default implementation, there may be additional fields registered by extensions
      parameters:
        - name: user
          in: query
          description: name or id of the user who owns new API Token
          schema:
            type: string
        - name: name
          in: query
          description: distinctive name for API Token
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Returns a dict with the key token containing the encoded token value. Extensions can privide additional fields via `add_extra` method of `~ckan.plugins.interfaces.IApiToken`
      security:
        - ckanapikey: []
  /action/user_generate_apikey:
    post:
      operationId: user_generate_apikey
      tags:
        - authentication
      summary: Cycle a user's API key
      parameters:
        - name: user
          in: query
          description: the name or id of the user whose key needs to be updated
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: the updated user
  /action/api_token_revoke:
    post:
      operationId: api_token_revoke
      tags:
        - authentication
      summary: Delete API Token
      parameters:
        - name: token
          in: query
          description: Token to remove(required if `jti` not specified).
          schema:
            type: string
        - name: jti
          in: query
          description: Id of the token to remove(overrides `token` if specified).
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success

  /action/package_activity_list:
    get:
      operationId: package_activity_list
      tags:
        - activity
      summary: Return a package's activity stream (not including detail)
      description: >
        You must be authorized to view the package.
      parameters:
        - name: id
          in: query
          description: the id or name of the dataset
          required: true
          schema:
            type: string
        - name: offset
          in: query
          description: >
            where to start getting activity items from (optional, default: ``0``)
          schema:
            type: integer
        - name: limit
          in: query
          description: >
            the maximum number of activities to return (optional, default: ``31`` unless set in site's configuration ``ckan.activity_list_limit``, upper limit: ``100`` unless set in site's configuration ``ckan.activity_list_limit_max``)
          schema:
            type: integer
        - name: include_hidden_activity
          in: query
          description: >
            whether to include 'hidden' activity, which is not shown in the Activity Stream page. Hidden activity includes activity done by the site_user, such as harvests, which are not shown in the activity stream because they can be too numerous, or activity by other users specified in config option `ckan.hide_activity_from_users`. NB Only sysadmins may set include_hidden_activity to true. (default: false)
          schema:
            type: boolean
      responses:
        "400":
          description: bad input parameter
        "200":
          description: activity of the package
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: array
                    items:
                      $ref: "#/components/schemas/Activity"
  /action/group_activity_list:
    get:
      operationId: group_activity_list
      tags:
        - activity
      summary: Return a group's activity stream
      description: >
        You must be authorized to view the group.
      parameters:
        - name: id
          in: query
          description: the id or name of the group
          required: true
          schema:
            type: string
        - name: offset
          in: query
          description: >
            where to start getting activity items from (optional, default: ``0``)
          schema:
            type: integer
        - name: limit
          in: query
          description: >
            the maximum number of activities to return (optional, default: ``31`` unless set in site's configuration ``ckan.activity_list_limit``, upper limit: ``100`` unless set in site's configuration ``ckan.activity_list_limit_max``)
          schema:
            type: integer
        - name: include_hidden_activity
          in: query
          description: >
            whether to include 'hidden' activity, which is not shown in the Activity Stream page. Hidden activity includes activity done by the site_user, such as harvests, which are not shown in the activity stream because they can be too numerous, or activity by other users specified in config option `ckan.hide_activity_from_users`. NB Only sysadmins may set include_hidden_activity to true. (default: false)
          schema:
            type: boolean
      responses:
        "400":
          description: bad input parameter
        "200":
          description: activity of the group
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: array
                    items:
                      $ref: "#/components/schemas/Activity"
  /action/organization_activity_list:
    get:
      operationId: organization_activity_list
      tags:
        - activity
      summary: Return a organization's activity stream
      parameters:
        - name: id
          in: query
          description: the id or name of the organization
          required: true
          schema:
            type: string
        - name: offset
          in: query
          description: >
            where to start getting activity items from (optional, default: ``0``)
          schema:
            type: integer
        - name: limit
          in: query
          description: >
            the maximum number of activities to return (optional, default: ``31`` unless set in site's configuration ``ckan.activity_list_limit``, upper limit: ``100`` unless set in site's configuration ``ckan.activity_list_limit_max``)
          schema:
            type: integer
        - name: include_hidden_activity
          in: query
          description: >
            whether to include 'hidden' activity, which is not shown in the Activity Stream page. Hidden activity includes activity done by the site_user, such as harvests, which are not shown in the activity stream because they can be too numerous, or activity by other users specified in config option `ckan.hide_activity_from_users`. NB Only sysadmins may set include_hidden_activity to true. (default: false)
          schema:
            type: boolean
      responses:
        "400":
          description: bad input parameter
        "200":
          description: activity of the organization
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: array
                    items:
                      $ref: "#/components/schemas/Activity"
  /action/recently_changed_packages_activity_list:
    get:
      operationId: recently_changed_packages_activity_list
      tags:
        - activity
      summary: Return the activity stream of all recently added or changed packages
      parameters:
        - name: offset
          in: query
          description: >
            where to start getting activity items from (optional, default: ``0``)
          schema:
            type: integer
        - name: limit
          in: query
          description: >
            the maximum number of activities to return (optional, default: ``31`` unless set in site's configuration ``ckan.activity_list_limit``, upper limit: ``100`` unless set in site's configuration ``ckan.activity_list_limit_max``)
          schema:
            type: integer
      responses:
        "400":
          description: bad input parameter
        "200":
          description: recent activities
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: array
                    items:
                      $ref: "#/components/schemas/Activity"
  /action/activity_show:
    get:
      operationId: activity_show
      tags:
        - activity
      summary: Show details of an item of 'activity' (part of the activity stream).
      parameters:
        - name: id
          in: query
          description: the id of the activity
          required: true
          schema:
            type: string
        - name: include_data
          in: query
          required: true
          description: >
            include the data field, containing a full object dict (otherwise the data field is only returned with the object's title)
          schema:
            type: boolean
      responses:
        "400":
          description: bad input parameter
        "200":
          description: shows activity
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    $ref: "#/components/schemas/Activity"
  /action/activity_data_show:
    get:
      operationId: activity_data_show
      tags:
        - activity
      summary: Show the data from an item of 'activity' (part of the activity
        stream)
      parameters:
        - name: id
          in: query
          description: the id of the activity
          required: true
          schema:
            type: string
        - name: object_type
          in: query
          description: the id of the activity
          required: true
          schema:
            type: string
            enum: ["package", "user", "group", "organization"]
      responses:
        "400":
          description: bad input parameter
        "200":
          description: data of activity item
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: object
  /action/activity_diff:
    get:
      operationId: activity_diff
      tags:
        - activity
      summary:
        Returns a diff of the activity, compared to the previous version of the
        object
      parameters:
        - name: id
          in: query
          description: the id of the activity
          required: true
          schema:
            type: string
        - name: object_type
          in: query
          description: the id of the activity
          required: true
          schema:
            type: string
            enum: ["package", "user", "group", "organization"]
        - name: diff_type
          in: query
          description: the id of the activity
          schema:
            type: string
            enum: ["unified", "context", "html"]
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: object
                    properties:
                      diff:
                        type: string
                      activies:
                        type: array
                        items:
                          type: object

  /action/package_create:
    post:
      tags:
        - datamanagement
      summary: Create a new dataset (package)
      description: Creates a new dataset (package) to the system. You must be authorized to create new datasets. If you specify any groups for the new dataset, you must also be authorized to edit these groups.
      operationId: addDataset
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/MetadataEntry"
        description: Metadata to add
      responses:
        "201":
          description: item created
        "400":
          description: invalid input, object invalid
        "409":
          description: An existing item already exists
      security:
        - ckanapikey: []
  /action/package_update:
    post:
      tags:
        - datamanagement
      summary: Update a dataset (package).
      description:
        Update a dataset (package). You must be authorized to edit the dataset
        and the groups that it belongs to.
      operationId: updateDataset
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/MetadataEntry"
        description: Metadata to add
      responses:
        "200":
          description: OK, dataset updated.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/package_patch:
    post:
      operationId: package_patch
      tags:
        - datamanagement
      summary: Patch a dataset (package).
      description: >
        The difference between the update and patch methods is that the patch will perform an update of the provided parameters, while leaving all other parameters unchanged, whereas the update methods deletes all parameters not explicitly provided in the data_dict.

        You are able to partially update and/or create resources with package_patch. If you are updating existing resources be sure to provide the resource id. Existing resources excluded from the package_patch data_dict will be removed. Resources in the package data_dict without an id will be treated as new resources and will be added. New resources added with the patch method do not create the default views.

        You must be authorized to edit the dataset and the groups that it belongs to.
      parameters:
        - name: id
          in: body
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/MetadataEntry"
      responses:
        "200":
          description: OK, dataset updated.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/package_revise:
    post:
      operationId: package_revise
      tags:
        - datamanagement
      summary: Revise a dataset (package) selectively with match, filter and
        update parameters
      description: >
        You must be authorized to edit the dataset and the groups that it belongs to.

          ``match`` and ``update`` parameters may also be passed as flattened keys, using either the item numeric index or its unique id (with a minimum of 5 characters), e.g. ``update__resource__1f9ab__description=guidebook`` would set the description of the resource with id starting with 1f9ab to guidebook, and ``update__resource__-1__description=guidebook`` would do the same on the last resource in the dataset.

          The ``extend`` suffix can also be used on the update parameter to add a new item to a list, e.g. ``update__resources__extend=[{name: new resource, url: https://example.com}]`` will add a new resource to the dataset with the provided ``name`` and ``url``.

          Usage examples:

          * Change description in dataset, checking for old description::

              match={notes: old notes, name: xyz}
              update={notes: new notes}

          * Identical to above, but using flattened keys::

              match__name=xyz
              match__notes=old notes
              update__notes=new notes

          * Replace all fields at dataset level only, keep resources (note: dataset id
            and type fields can't be deleted) ::

              match={id: 1234abc-1420-cbad-1922}
              filter=[+resources, -*]
              update={name: fresh-start, title: Fresh Start}

          * Add a new resource (__extend on flattened key)::

              match={id: abc0123-1420-cbad-1922}
              update__resources__extend=[{name: new resource, url: http://example.com}]

          * Update a resource by its index::
              match={name: my-data}
              update__resources__0={name: new name, first resource}

          * Update a resource by its id (provide at least 5 characters)::
          
              match={name: their-data}
              update__resources__19cfad={description: right one for sure}

          * Replace all fields of a resource::

              match={id: 34a12bc-1420-cbad-1922}
              filter=[+resources__1492a__id, -resources__1492a__*]
              update__resources__1492a={name: edits here, url: http://example.com}

          :returns: a dict containing 'package':the updated dataset with fields filtered by include parameter
          :rtype: dictionary\n\n
      parameters:
        - name: match
          in: query
          description: >
            a dict containing id or name values of the dataset to update, all values provided must match the current dataset values or a ValidationError will be raised. e.g. ``{name: my-data, resources: {[name: big.csv]}}`` would abort if the my-data dataset's first resource name is not big.csv.
          schema:
            type: string
        - name: filter
          in: query
          schema:
            type: string
          description: >
            a list of string patterns of fields to remove from the current dataset. e.g. ``-resources__1`` would remove the second resource, ``+title, +resources, -*`` would remove all fields at the dataset level except title and all resources (default: ``[]``)
        - name: update
          in: query
          schema:
            type: string
          description: >
            a dict with values to update/create after filtering e.g. ``{resources: [{description: file here}]}`` would update the description for the first resource
        - name: include
          in: query
          schema:
            type: string
          description: >
            a list of string pattern of fields to include in response e.g. ``-*`` to return nothing (default: ``[]`` all fields returned)
      responses:
        "200":
          description: OK, dataset updated.

        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/package_owner_org_update:
    post:
      operationId: package_owner_org_update
      tags:
        - datamanagement
      summary: Update the owning organization of a dataset
      parameters:
        - name: id
          in: query
          schema:
            type: string
          description: the name or id of the dataset to update
        - name: organization_id
          in: query
          schema:
            type: string
          description: the name or id of the owning organization
      responses:
        "200":
          description: OK, dataset updated.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/package_resource_reorder:
    post:
      operationId: package_resource_reorder
      tags:
        - datamanagement
      summary: Reorder resources against datasets.
      parameters:
        - name: id
          in: query
          description: the id or name of the package to update
          schema:
            type: string
        - name: order
          in: query
          description: Success list of resource ids in the order needed. If only partial resource ids are supplied then these are assumed to be first and the other resources will stay in their original order
          schema:
            type: array
            items:
              type: string
      responses:
        "200":
          description: OK, dataset updated.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/package_delete:
    post:
      tags:
        - datamanagement
      summary: Delete a dataset (package)
      description:
        This makes the dataset disappear from all web & API views, apart from
        the trash.
      operationId: deleteDataset
      parameters:
        - name: id
          in: body
          description: the id or name of the dataset to delete
          schema:
            type: string
      responses:
        "200":
          description: OK, dataset updated.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/dataset_purge:
    post:
      operationId: dataset_purge
      tags:
        - datamanagement
      summary: Purge a dataset.
      description: >
        Purging a dataset cannot be undone!

        Purging a database completely removes the dataset from the CKAN database, whereas deleting a dataset simply marks the dataset as deleted (it will no longer show up in the front-end, but is still in the db).

        You must be authorized to purge the dataset.
      parameters:
        - name: id
          in: body
          description: the id or name of the dataset to be purged
          schema:
            type: string
      responses:
        "200":
          description: OK, dataset updated.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found.
      security:
        - ckanapikey: []
  /action/resource_create:
    post:
      operationId: resource_create
      tags:
        - datamanagement
      summary: Appends a new resource to a datasets list of resources
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/Resource"
      responses:
        "201":
          description: OK, resource created.
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    $ref: "#/components/schemas/Resource"
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/resource_update:
    post:
      operationId: resource_update
      tags:
        - datamanagement
      summary: Update a resource
      description: >
        To update a resource you must be authorized to update the dataset that the resource belongs to.

        Update methods may delete parameters not explicitly provided in the data_dict. If you want to edit only a specific attribute use `resource_patch` instead.
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/Resource"
      responses:
        "200":
          description: OK, resource updated.
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    $ref: "#/components/schemas/Resource"
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/resource_patch:
    post:
      operationId: resource_patch
      tags:
        - datamanagement
      summary: Patch a resource
      description: >
        The difference between the update and patch methods is that the patch will perform an update of the provided parameters, while leaving all other parameters unchanged, whereas the update methods deletes all parameters not explicitly provided in the data_dict
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/Resource"
      responses:
        "200":
          description: OK, resource updated.
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    $ref: "#/components/schemas/Resource"
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/resource_delete:
    post:
      operationId: resource_delete
      tags:
        - datamanagement
      summary: Delete a resource from a dataset.
      description: >
        You must be a sysadmin or the owner of the resource to delete it.
      parameters:
        - name: id
          in: query
          description: the id or name of the resource to delete
          schema:
            type: string
      responses:
        "200":
          description: OK, resource deleted.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found for update.
      security:
        - ckanapikey: []
  /action/resource_view_create:
    post:
      operationId: resource_view_create
      tags:
        - datamanagement
      summary: Creates a new resource view
      description: To create the Resource View with a specific config add the expected parameters to the json. For example for a webpage_view you should add 'page_url' to set the page_url.
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/ResourceView"
        description: ResourceView to add
      responses:
        "201":
          description: item created
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    $ref: "#/components/schemas/ResourceView"
        "400":
          description: invalid input, object invalid
        "409":
          description: An existing item already exists
      security:
        - ckanapikey: []
  /action/resource_view_update:
    post:
      operationId: resource_view_update
      tags:
        - datamanagement
      summary: Update a resource view.
      description: >
        To update the Resource View with a specific config add the expected parameters to the json. For example for a webpage_view you should add 'page_url' to set the page_url.
      parameters:
        - name: id
          in: body
          description: the id of the activity
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/ResourceView"
        description: ResourceView to add
      responses:
        "400":
          description: bad input parameter
        "201":
          description: item created
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    $ref: "#/components/schemas/ResourceView"
        "404":
          description: Item Not found
      security:
        - ckanapikey: []
  /action/resource_view_reorder:
    post:
      operationId: resource_view_reorder
      tags:
        - datamanagement
      summary: Reorder resource views
      parameters:
        - name: id
          in: query
          schema:
            type: string
          description: the id of the resource
        - name: order
          in: query
          schema:
            type: array
            items:
              type: string
          description: the list of id of the resource to update the order of the views
      responses:
        "400":
          description: bad input parameter
        "200":
          description: the updated order of the view
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: array
                    items:
                      $ref: "#/components/schemas/ResourceView"
      security:
        - ckanapikey: []
  /action/resource_view_delete:
    post:
      operationId: resource_view_delete
      tags:
        - datamanagement
      summary: Delete a resource_view.
      parameters:
        - name: id
          in: body
          schema:
            type: string
          description: the id of the resource
      responses:
        "200":
          description: OK, resource view deleted.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found.
      security:
        - ckanapikey: []
  /action/bulk_update_private:
    post:
      operationId: bulk_update_private
      tags:
        - datamanagement
      summary: Make a list of datasets private
      parameters:
        - name: datasets
          in: query
          description: list of ids of the datasets to update
          schema:
            type: array
            items:
              type: string
        - name: org_id
          in: query
          description: id of the owning organization
          schema:
            type: string
      responses:
        "200":
          description: OK, datasets updated.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found.
      security:
        - ckanapikey: []
  /action/bulk_update_public:
    post:
      operationId: bulk_update_public
      tags:
        - datamanagement
      summary: Make a list of datasets public
      parameters:
        - name: datasets
          in: query
          description: list of ids of the datasets to update
          schema:
            type: array
            items:
              type: string
        - name: org_id
          in: query
          description: id of the owning organization
          schema:
            type: string
      responses:
        "200":
          description: OK, datasets updated.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found.
      security:
        - ckanapikey: []
  /action/bulk_update_delete:
    post:
      operationId: bulk_update_delete
      tags:
        - datamanagement
      summary: Make a list of datasets deleted
      parameters:
        - name: datasets
          in: query
          description: list of ids of the datasets to delete
          schema:
            type: array
            items:
              type: string
        - name: org_id
          in: query
          description: id of the owning organization
          schema:
            type: string
      responses:
        "200":
          description: OK, datasets deleted.
        "400":
          description: Invalid input, object invalid.
        "404":
          description: Object not found.
      security:
        - ckanapikey: []
  /action/package_relationships_list:
    get:
      operationId: package_relationships_list
      tags:
        - datamanagement
      summary: Return a dataset (package)'s relationships.
      description: >
        :param id: the id or name of the first package
          :type id: string
          :param id2: the id or name of the second package
          :type id2: string
          :param rel: relationship as string see
              :py:func:`~ckan.logic.action.create.package_relationship_create` for
              the relationship types (optional)\n
          :rtype: list of dictionaries\n\n
      parameters:
        - name: id
          in: query
          description: the id or name of the first package
          schema:
            type: string
        - name: id2
          in: query
          description: the id or name of the second package
          schema:
            type: string
        - name: rel
          in: query
          description: relationship as string
          schema:
            type: string
            enum:
              [
                "depends_on",
                "dependency_of",
                "derives_from",
                "has_derivation",
                "links_to",
                "linked_from",
                "child_of",
                "parent_of",
              ]
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: object
      security:
        - ckanapikey: []
  /action/package_relationship_create:
    post:
      operationId: package_relationship_create
      tags:
        - datamanagement
      summary: Create a relationship between two datasets (packages)
      parameters:
        - name: subject
          in: query
          description: the id or name of the dataset that is the subject of the relationship
          schema:
            type: string
        - name: object
          in: query
          description: the id or name of the dataset that is the object of the relationship
          schema:
            type: string
        - name: type
          in: query
          description: relationship as string
          schema:
            type: string
            enum:
              [
                "depends_on",
                "dependency_of",
                "derives_from",
                "has_derivation",
                "links_to",
                "linked_from",
                "child_of",
                "parent_of",
              ]
        - name: comment
          in: query
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: object
      security:
        - ckanapikey: []
  /action/package_relationship_update:
    post:
      operationId: package_relationship_update
      tags:
        - datamanagement
      summary: Update a relationship between two datasets (packages)
      description: >
        The subject, object and type parameters are required to identify the
          relationship. Only the comment can be updated.\n
          You must be authorized to edit both the subject and the object datasets.
      parameters:
        - name: subject
          in: query
          description: the id or name of the dataset that is the subject of the relationship
          schema:
            type: string
        - name: object
          in: query
          description: the id or name of the dataset that is the object of the relationship
          schema:
            type: string
        - name: type
          in: query
          description: relationship as string
          schema:
            type: string
            enum:
              [
                "depends_on",
                "dependency_of",
                "derives_from",
                "has_derivation",
                "links_to",
                "linked_from",
                "child_of",
                "parent_of",
              ]
        - name: comment
          in: query
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: object
      security:
        - ckanapikey: []
  /action/package_relationship_delete:
    post:
      operationId: package_relationship_delete
      tags:
        - datamanagement
      summary: Delete a dataset (package) relationship.
      description: >
        You must be authorised to delete dataset relationships, and to edit both the subject and the object datasets.
      parameters:
        - name: subject
          in: query
          description: the id or name of the dataset that is the subject of the relationship
          schema:
            type: string
        - name: object
          in: query
          description: the id or name of the dataset that is the object of the relationship
          schema:
            type: string
        - name: type
          in: query
          description: relationship as string
          schema:
            type: string
            enum:
              [
                "depends_on",
                "dependency_of",
                "derives_from",
                "has_derivation",
                "links_to",
                "linked_from",
                "child_of",
                "parent_of",
              ]
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success
      security:
        - ckanapikey: []
  /action/tag_list:
    get:
      operationId: tag_list
      tags:
        - datamanagement
      summary: Return a list of the site's tags.
      parameters:
        - name: query
          in: query
          description: a tag name query to search for, if given only tags whose names contain this string will be returned (optional)
          schema:
            type: string
        - name: vocabulary_id
          in: query
          description: the id or name of a vocabulary, if give only tags that belong to this vocabulary will be returned (optional)
          schema:
            type: string
        - name: all_fields
          in: query
          description: >
            return full tag dictionaries instead of just names (optional, default: ``False``)
          schema:
            type: boolean
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: array
                    items:
                      type: string
      security:
        - ckanapikey: []
  /action/tag_show:
    get:
      operationId: tag_show
      tags:
        - datamanagement
      summary: Return the details of a tag and all its datasets.
      parameters:
        - name: id
          in: query
          description: the name or id of the tag
          required: true
          schema:
            type: string
        - name: vocabulary_id
          in: query
          description: the id or name of the tag vocabulary that the tag is in - if it is not specified it will assume it is a free tag.
          schema:
            type: string
        - name: include_datasets
          in: query
          description: >
            include a list of the tag's datasets. (Up to a limit of 1000 - for more flexibility, use package_search - see :py:func:`package_search` for an example.)
          schema:
            type: boolean
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: object
                    properties:
                      id:
                        type: string
                      name:
                        type: string
                      vocabulary_id:
                        type: string
                      display_name:
                        type: string
                      packages:
                        type: array
                        items:
                          $ref: "#/components/schemas/MetadataEntry"
      security:
        - ckanapikey: []
  /action/tag_search:
    get:
      operationId: tag_search
      tags:
        - datamanagement
      summary: Return a list of tags whose names contain a given string.
      description: >
        By default only free tags (tags that don't belong to any vocabulary) are
          searched. If the ``vocabulary_id`` argument is given then only tags
          belonging to that vocabulary will be searched instead.\n

          :returns: A dictionary with the following keys:\n
            ``'count'``
              The number of tags in the result.\n
            ``'results'``
              The list of tags whose names contain the given string, a list of
              dictionaries.\n
          :rtype: dictionary\n\n
      parameters:
        - name: query
          in: query
          description: the string(s) to search for
          required: true
          schema:
            type: string
        - name: vocabulary_id
          in: query
          description: the id or name of the tag vocabulary to search in
          schema:
            type: string
        - name: limit
          in: query
          description: the maximum number of tags to return
          schema:
            type: string
        - name: offset
          in: query
          description: when ``limit`` is given, the offset to start returning tags from
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: object
                    properties:
                      count:
                        type: integer
                      results:
                        type: array
                        items:
                          type: string
      security:
        - ckanapikey: []

  /action/help_show:
    get:
      operationId: help_show
      tags:
        - serveradmin
      summary: >
        Return the help string for a particular API action.
      parameters:
        - name: name
          in: query
          description: Action function name (eg `user_create`, `package_search`)
          schema:
            type: string
      responses:
        "400":
          description: bad input parameter
        "200":
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  help:
                    type: string
                    description: location of the help
                  success:
                    type: boolean
                  result:
                    type: string
                    description:
                      The help string for the action function, or None if the function
                      does not have a docstring.

components:
  securitySchemes:
    ckanapikey:
      type: apiKey
      name: Authorization
      in: header
  schemas:
    MetadataEntry:
      type: object
      properties:
        attribute_description:
          type: string
        author:
          type: string
        author_email:
          type: string
        begin_datetime:
          type: string
        categorization:
          type: string
        creator_user_id:
          type: string
        en_title_and_desc:
          type: string
        end_datetime:
          type: string
        geographic_toponym:
          type: string
        id:
          type: string
        isopen:
          type: boolean
        license_citation:
          type: string
        license_id:
          type: string
        license_title:
          type: string
        license_url:
          type: string
        openapi_schema:
          type: string
        lineage_quality:
          type: string
        maintainer:
          type: string
        maintainer_email:
          type: string
        maintainer_link:
          type: string
        metadata_created:
          type: string
        metadata_identifier:
          type: string
        metadata_linkage:
          type: string
        metadata_modified:
          type: string
        name:
          type: string
        notes:
          type: string
        num_resources:
          type: integer
        num_tags:
          type: integer
        Organization:
          $ref: "#/components/schemas/Organization"
        owner_org:
          type: string
        private:
          type: boolean
        publisher:
          type: string
        publisher_email:
          type: string
        schema_characterset:
          type: string
        schema_language:
          type: string
        schema_name:
          type: string
        state:
          type: string
        title:
          type: string
        type:
          type: string
        update_frequency:
          type: string
        url:
          type: string
        version:
          type: string
        extras:
          type: array
          items:
            type: object
            properties:
              key:
                type: string
              value:
                type: string
            required:
              - key
              - value
        resources:
          type: array
          items:
            $ref: "#/components/schemas/Resource"
        tags:
          type: array
          items:
            type: object
            properties:
              display_name:
                type: string
              id:
                type: string
              name:
                type: string
              state:
                type: string
              vocabulary_id:
                type: string
            required:
              - name
        groups:
          type: array
          items: {}
        relationships_as_subject:
          type: array
          items: {}
        relationships_as_object:
          type: array
          items: {}
      required:
        - metadata_modified
        - title
        - notes
        - categorization
        - tags
        - resources
        - maintainer
        - publisher
        - license_id
        - license_title
        - begin_datetime
    Organization:
      type: object
      properties:
        id:
          type: string
        name:
          type: string
        title:
          type: string
        type:
          type: string
        description:
          type: string
        image_url:
          type: string
        created:
          type: string
        is_organization:
          type: boolean
        approval_status:
          type: string
        state:
          type: string
      required:
        - name
        - title
        - type
        - description
        - created
        - is_organization
        - approval_status
        - state
    Resource:
      type: object
      properties:
        cache_last_updated:
          type: string
        cache_url:
          type: string
        characterset:
          type: string
        created:
          type: string
        datastore_active:
          type: boolean
        description:
          type: string
        format:
          type: string
        hash:
          type: string
        id:
          type: string
        language:
          type: string
        last_modified:
          type: string
        lastmodified:
          type: string
        metadata_modified:
          type: string
        mimetype:
          type: string
        mimetype_inner:
          type: string
        name:
          type: string
        package_id:
          type: string
        position:
          type: integer
        resource_type:
          type: string
        size:
          type: string
        state:
          type: string
        url:
          type: string
        url_type:
          type: string
      required:
        - url
        - format
    ResourceView:
      type: object
      properties:
        id:
          type: string
        resource_id:
          type: string
        package_id:
          type: string
        title:
          type: string
        description:
          type: string
        view_type:
          type: string
      required:
        - id
        - resource_id
        - package_id
        - title
        - view_type
    Activity:
      type: object
      properties:
        id:
          type: string
        timestamp:
          type: string
        user_id:
          type: string
        object_id:
          type: string
        activity_type:
          type: string
        data:
          type: object

  # /action/activity_create:
  #   post:
  #     operationId: activity_create
  #     tags:
  #       - activity
  #     summary: Create a new activity stream activity.
  #     description: >
  #       You must be a sysadmin to create new activities.\n
  #         :param user_id: the name or id of the user who carried out the activity,
  #             e.g. ``'seanh'``
  #         :type user_id: string
  #         :param object_id: the name or id of the object of the activity, e.g.
  #             ``'my_dataset'``
  #         :param activity_type: the type of the activity, this must be an activity
  #             type that CKAN knows how to render, e.g. ``'new package'``,
  #             ``'changed user'``, ``'deleted group'`` etc.
  #         :type activity_type: string
  #         :param data: any additional data about the activity
  #         :type data: dictionary\n
  #         :returns: the newly created activity
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/dashboard_new_activities_count:
  #   get:
  #     operationId: dashboard_new_activities_count
  #     tags:
  #       - activity
  #     summary: Return the number of new activities in the user's dashboard
  #     description: >
  #       Return the number of new activities in the authorized user's dashboard
  #         activity stream.\n
  #         Activities from the user herself are not counted by this function even
  #         though they appear in the dashboard (users don't want to be notified about
  #         things they did themselves).\n
  #         :rtype: int\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/dashboard_mark_activities_old:
  #   post:
  #     operationId: dashboard_mark_activities_old
  #     tags:
  #       - activity
  #     summary: Mark all the authorized user's new dashboard activities as old
  #     description: >
  #       This will reset
  #         :py:func:`~ckan.logic.action.get.dashboard_new_activities_count` to 0.\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a

  # /action/vocabulary_list:
  #   get:
  #     operationId: vocabulary_list
  #     tags:
  #       - datamanagement
  #     summary: Return a list of all the site's tag vocabularies
  #     description: >
  #       :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/vocabulary_show:
  #   get:
  #     operationId: vocabulary_show
  #     tags:
  #       - datamanagement
  #     summary: Return a single tag vocabulary
  #     description: >
  #       :param id: the id or name of the vocabulary
  #         :type id: string
  #         :return: the vocabulary.
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  #     security:
  #       - ckanapikey: []
  # /action/vocabulary_create:
  #   post:
  #     operationId: vocabulary_create
  #     tags:
  #       - datamanagement
  #     summary: Create a new tag vocabulary.
  #     description: >
  #       You must be a sysadmin to create vocabularies.\n
  #         :param name: the name of the new vocabulary, e.g. ``'Genre'``
  #         :type name: string
  #         :param tags: the new tags to add to the new vocabulary, for the format of
  #             tag dictionaries see :py:func:`tag_create`
  #         :type tags: list of tag dictionaries\n
  #         :returns: the newly-created vocabulary
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  #     security:
  #       - ckanapikey: []
  # /action/task_status_show:
  #   get:
  #     operationId: task_status_show
  #     tags:
  #       - datamanagement
  #     summary: Return a task status
  #     description: >
  #       Either the ``id`` parameter *or* the ``entity_id``, ``task_type`` *and*
  #         ``key`` parameters must be given.\n
  #         :param id: the id of the task status (optional)
  #         :type id: string
  #         :param entity_id: the entity_id of the task status (optional)
  #         :type entity_id: string
  #         :param task_type: the task_type of the task status (optional)
  #         :type task_type: string
  #         :param key: the key of the task status (optional)
  #         :type key: string\n
  #         :rtype: dictionary\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  #     security:
  #       - ckanapikey: []
  # /action/term_translation_show:
  #   get:
  #     operationId: term_translation_show
  #     tags:
  #       - datamanagement
  #     summary: Return the translations for the given term(s) and language(s)
  #     description: >
  #       :param terms: the terms to search for translations of, e.g. ``'Russian'``,
  #             ``'romantic novel'``
  #         :type terms: list of strings
  #         :param lang_codes: the language codes of the languages to search for
  #             translations into, e.g. ``'en'``, ``'de'`` (optional, default is to
  #             search for translations into any language)
  #         :type lang_codes: list of language code strings\n
  #         :rtype: a list of term translation dictionaries each with keys ``'term'``
  #             (the term searched for, in the source language), ``'term_translation'``
  #             (the translation of the term into the target language) and
  #             ``'lang_code'`` (the language code of the target language)\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  #     security:
  #       - ckanapikey: []

  # /action/organization_create:
  #   post:
  #     tags:
  #       - organizations
  #     summary: Create a new organization.
  #     description: Create a new organization. You must be authorized to create
  #       organizations.
  #     operationId: addOrg
  #     requestBody:
  #       content:
  #         application/json:
  #           schema:
  #             $ref: "#/components/schemas/dataset_organization_create"
  #       description: Inventory item to add
  #     responses:
  #       "201":
  #         description: Organization created
  #       "400":
  #         description: Invalid input, object invalid
  #       "409":
  #         description: An existing item already exists
  #     security:
  #       - ckanapikey: []
  # /action/organization_update:
  #   post:
  #     tags:
  #       - organizations
  #     summary: Update a organization.
  #     description: Update a organization. You must be authorized to edit the organization.
  #     operationId: updateOrg
  #     requestBody:
  #       content:
  #         application/json:
  #           schema:
  #             $ref: "#/components/schemas/dataset_organization_update"
  #       description: Inventory item to add
  #     responses:
  #       "200":
  #         description: OK, updated.
  #       "400":
  #         description: Invalid input, object invalid
  #       "404":
  #         description: Organization not found for update.
  #     security:
  #       - ckanapikey: []
  # /action/organization_delete:
  #   post:
  #     tags:
  #       - organizations
  #     summary: Delete an organization.
  #     description: Delete an organization. You must be authorized to delete the
  #       organization.
  #     operationId: deleteOrg
  #     requestBody:
  #       content:
  #         application/json:
  #           schema:
  #             $ref: "#/components/schemas/delete"
  #       description: id (string) – the id or name of the organization to delete
  #     responses:
  #       "200":
  #         description: OK, organization deleted.
  #       "400":
  #         description: Invalid input, object invalid.
  #       "404":
  #         description: Organization not found for deletion.
  #     security:
  #       - ckanapikey: []
  # /action/package_collaborator_list:
  #   get:
  #     operationId: package_collaborator_list
  #     tags:
  #       - organizations
  #     summary: Return the list of all collaborators for a given package
  #     description: >
  #       Currently you must be an Admin on the package owner organization to
  #         manage collaborators.\n
  #         Note: This action requires the collaborators feature to be enabled with
  #         the :ref:`ckan.auth.allow_dataset_collaborators` configuration option.\n
  #         :param id: the id or name of the package
  #         :type id: string
  #         :param capacity: (optional) If provided, only users with this capacity are
  #             returned
  #         :type capacity: string\n
  #         :returns: a list of collaborators, each a dict including the package and
  #             user id, the capacity and the last modified date
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/package_collaborator_list_for_user:
  #   get:
  #     operationId: package_collaborator_list_for_user
  #     tags:
  #       - organizations
  #     summary: Return a list of all package the user is a collaborator in
  #     description: >
  #       Note: This action requires the collaborators feature to be enabled with
  #         the :ref:`ckan.auth.allow_dataset_collaborators` configuration option.\n
  #         :param id: the id or name of the user
  #         :type id: string
  #         :param capacity: (optional) If provided, only packages where the user
  #             has this capacity are returned
  #         :type capacity: string\n
  #         :returns: a list of packages, each a dict including the package id, the
  #             capacity and the last modified date
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/member_roles_list:
  #   get:
  #     operationId: member_roles_list
  #     tags:
  #       - organizations
  #     summary: Return the possible roles for members of groups and organizations.
  #     description: >
  #       :param group_type: the group type, either ``group`` or ``organization``
  #             (optional, default ``organization``)
  #         :type group_type: string
  #         :returns: a list of dictionaries each with two keys: ``text`` (the
  #             display name of the role, e.g. ``Admin``) and ``value`` (the
  #             internal name of the role, e.g. ``admin``)
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/member_list:
  #   get:
  #     operationId: member_list
  #     tags:
  #       - organizations
  #     summary: Return the members of a group
  #     description: >
  #       The user must have permission to 'get' the group.\n
  #         :param id: the id or name of the group
  #         :type id: string
  #         :param object_type: restrict the members returned to those of a given type,
  #           e.g. ``'user'`` or ``'package'`` (optional, default: ``None``)
  #         :type object_type: string
  #         :param capacity: restrict the members returned to those with a given
  #           capacity, e.g. ``'member'``, ``'editor'``, ``'admin'``, ``'public'``,
  #           ``'private'`` (optional, default: ``None``)
  #         :type capacity: string\n
  #         :rtype: list of (id, type, capacity) tuples\n
  #         :raises: :class:`ckan.logic.NotFound`: if the group doesn't exist\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_list:
  #   get:
  #     operationId: group_list
  #     tags:
  #       - organizations
  #     summary: Return a list of the names of the site's groups
  #     description: >
  #       :param order_by: the field to sort the list by, must be ``'name'`` or
  #           ``'packages'`` (optional, default: ``'name'``) Deprecated use sort.
  #         :type order_by: string
  #         :param sort: sorting of the search results.  Optional.  Default:
  #             title asc string of field name and sort-order. The allowed fields are
  #             'name', 'package_count' and 'title'
  #         :type sort: string
  #         :param limit: the maximum number of groups returned (optional)
  #             Default: ``1000`` when all_fields=false unless set in site's
  #             configuration ``ckan.group_and_organization_list_max``
  #             Default: ``25`` when all_fields=true unless set in site's
  #             configuration ``ckan.group_and_organization_list_all_fields_max``
  #         :type limit: int
  #         :param offset: when ``limit`` is given, the offset to start
  #             returning groups from
  #         :type offset: int
  #         :param groups: a list of names of the groups to return, if given only
  #             groups whose names are in this list will be returned (optional)
  #         :type groups: list of strings
  #         :param all_fields: return group dictionaries instead of just names. Only
  #             core fields are returned - get some more using the include_* options.
  #             Returning a list of packages is too expensive, so the `packages`
  #             property for each group is deprecated, but there is a count of the
  #             packages in the `package_count` property.
  #             (optional, default: ``False``)
  #         :type all_fields: bool
  #         :param include_dataset_count: if all_fields, include the full package_count
  #             (optional, default: ``True``)
  #         :type include_dataset_count: bool
  #         :param include_extras: if all_fields, include the group extra fields
  #             (optional, default: ``False``)
  #         :type include_extras: bool
  #         :param include_tags: if all_fields, include the group tags
  #             (optional, default: ``False``)
  #         :type include_tags: bool
  #         :param include_groups: if all_fields, include the groups the groups are in
  #             (optional, default: ``False``).
  #         :type include_groups: bool
  #         :param include_users: if all_fields, include the group users
  #             (optional, default: ``False``).
  #         :type include_users: bool\n
  #         :rtype: list of strings\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_list_authz:
  #   get:
  #     operationId: group_list_authz
  #     tags:
  #       - organizations
  #     summary: Return the list of groups that the user is authorized to edit
  #     description: >
  #       :param available_only: remove the existing groups in the package
  #           (optional, default: ``False``)
  #         :type available_only: bool\n
  #         :param am_member: if ``True`` return only the groups the logged-in user is
  #           a member of, otherwise return all groups that the user is authorized to
  #           edit (for example, sysadmin users are authorized to edit all groups)
  #           (optional, default: ``False``)
  #         :type am_member: bool\n
  #         :returns: list of dictized groups that the user is authorized to edit
  #         :rtype: list of dicts\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_show:
  #   get:
  #     operationId: group_show
  #     tags:
  #       - organizations
  #     summary: Return the details of a group.
  #     description: >
  #       :param id: the id or name of the group
  #         :type id: string
  #         :param include_datasets: include a truncated list of the group's datasets
  #              (optional, default: ``False``)
  #         :type include_datasets: bool
  #         :param include_dataset_count: include the full package_count
  #              (optional, default: ``True``)
  #         :type include_dataset_count: bool
  #         :param include_extras: include the group's extra fields
  #              (optional, default: ``True``)
  #         :type include_extras: bool
  #         :param include_users: include the group's users
  #              (optional, default: ``True`` if ``ckan.auth.public_user_details`` is ``True``
  #              otherwise ``False``)
  #         :type include_users: bool
  #         :param include_groups: include the group's sub groups
  #              (optional, default: ``True``)
  #         :type include_groups: bool
  #         :param include_tags: include the group's tags
  #              (optional, default: ``True``)
  #         :type include_tags: bool
  #         :param include_followers: include the group's number of followers
  #              (optional, default: ``True``)
  #         :type include_followers: bool\n
  #         :rtype: dictionary\n
  #         .. note:: Only its first 1000 datasets are returned\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_autocomplete:
  #   get:
  #     operationId: group_autocomplete
  #     tags:
  #       - organizations
  #     summary: Return a list of group names that contain a string
  #     description: >
  #       :param q: the string to search for
  #         :type q: string
  #         :param limit: the maximum number of groups to return (optional,
  #             default: 20)
  #         :type limit: int\n
  #         :rtype: a list of group dictionaries each with keys ``'name'``,
  #             ``'title'``, and ``'id'``\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_list_for_user:
  #   get:
  #     operationId: organization_list_for_user
  #     tags:
  #       - organizations
  #     summary: Return the organizations that the user has a given permission for
  #     description: >
  #       Specifically it returns the list of organizations that the currently
  #         authorized user has a given permission (for example: manage_group)
  #         against.\n
  #         By default this returns the list of organizations that the currently
  #         authorized user is member of, in any capacity.\n
  #         When a user becomes a member of an organization in CKAN they're given a
  #         capacity (sometimes called a role), for example member, editor or
  #         admin.\n
  #         Each of these roles has certain permissions associated with it. For example
  #         the admin role has the admin permission (which means they have permission
  #         to do anything). The editor role has permissions like create_dataset,
  #         update_dataset and delete_dataset.  The member role has the read
  #         permission.\n
  #         This function returns the list of organizations that the authorized user
  #         has a given permission for. For example the list of organizations that the
  #         user is an admin of, or the list of organizations that the user can create
  #         datasets in. This takes account of when permissions cascade down an
  #         organization hierarchy.\n
  #         :param id: the name or id of the user to get the organization list for
  #             (optional, defaults to the currently authorized user (logged in or via
  #             API key))
  #         :type id: string\n
  #         :param permission: the permission the user has against the
  #             returned organizations, for example ``read`` or ``create_dataset``
  #             (optional, default: ``manage_group``)
  #         :type permission: string
  #         :param include_dataset_count: include the package_count in each org
  #             (optional, default: ``False``)
  #         :type include_dataset_count: bool\n
  #         :returns: list of organizations that the user has the given permission for
  #         :rtype: list of dicts\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_show:
  #   get:
  #     operationId: organization_show
  #     tags:
  #       - organizations
  #     summary: Return the details of a organization
  #     description: >
  #       :param id: the id or name of the organization
  #         :type id: string
  #         :param include_datasets: include a truncated list of the org's datasets
  #              (optional, default: ``False``)
  #         :type include_datasets: bool
  #         :param include_dataset_count: include the full package_count
  #              (optional, default: ``True``)
  #         :type include_dataset_count: bool
  #         :param include_extras: include the organization's extra fields
  #              (optional, default: ``True``)
  #         :type include_extras: bool
  #         :param include_users: include the organization's users
  #              (optional, default: ``True`` if ``ckan.auth.public_user_details`` is ``True``
  #              otherwise ``False``)
  #         :type include_users: bool
  #         :param include_groups: include the organization's sub groups
  #              (optional, default: ``True``)
  #         :type include_groups: bool
  #         :param include_tags: include the organization's tags
  #              (optional, default: ``True``)
  #         :type include_tags: bool
  #         :param include_followers: include the organization's number of followers
  #              (optional, default: ``True``)
  #         :type include_followers: bool\n\n
  #         :rtype: dictionary\n
  #         .. note:: Only its first 10 datasets are returned\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_autocomplete:
  #   get:
  #     operationId: organization_autocomplete
  #     tags:
  #       - organizations
  #     summary: Return a list of organization names that contain a string
  #     description: >
  #       :param q: the string to search for
  #         :type q: string
  #         :param limit: the maximum number of organizations to return (optional,
  #             default: ``20``)
  #         :type limit: int\n
  #         :rtype: a list of organization dictionaries each with keys ``'name'``,
  #             ``'title'``, and ``'id'``\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_list:
  #   get:
  #     tags:
  #       - organizations
  #     summary: List users
  #     description: Return a list of the site's user accounts.
  #     operationId: listUsers
  #     parameters:
  #       - name: q
  #         in: query
  #         description:
  #           Restrict the users returned to those whose names contain a string.
  #           Optional.
  #         required: false
  #         schema:
  #           type: string
  #           default: "*"
  #       - name: order_by
  #         in: query
  #         description:
  #           Which field to sort the list by. Can be any user field or edits
  #           (i.e. number_of_edits). Optional.
  #         required: false
  #         schema:
  #           type: string
  #           default: "*"
  #       - name: all_fields
  #         in: query
  #         description: Return full user dictionaries instead of just names.  Optional.
  #         required: false
  #         schema:
  #           type: boolean
  #           default: true
  #     responses:
  #       "200":
  #         description:
  #           Returns a list of users. if there is no match, empty list is
  #           returned.
  #         content:
  #           application/json:
  #             examples:
  #               response:
  #                 value:
  #                   help: https://beta.avoindata.fi/data/api/3/action/help_show?name=user_list
  #                   success: true
  #                   result:
  #                     - openid: null
  #                       about: null
  #                       apikey: 916f7088-5828-4e25-a0da-f5fcad281af2
  #                       display_name: makkonenmakkonen
  #                       name: etunimi sukunimi
  #                       created: 2017-10-31T15:05:59.402582
  #                       email: esa.merkki@apinf.io
  #                       sysadmin: false
  #                       activity_streams_email_notifications: false
  #                       state: active
  #                       number_of_edits: 3
  #                       fullname: null
  #                       id: 9d886b53-2f4a-4ed8-8482-bd2cb9d0d5fe
  #                       number_created_packages: 3
  #       "400":
  #         description: invalid input, object invalid.
  #       "403":
  #         description: Forbidden, authorization key missing.
  #       "409":
  #         description: Item already exists.
  #     security:
  #       - ckanapikey: []
  # /action/user_show:
  #   get:
  #     operationId: user_show
  #     tags:
  #       - organizations
  #     summary: Return a user account
  #     description: >
  #       Either the ``id`` or the ``user_obj`` parameter must be given.\n
  #         :param id: the id or name of the user (optional)
  #         :type id: string
  #         :param user_obj: the user dictionary of the user (optional)
  #         :type user_obj: user dictionary
  #         :param include_datasets: Include a list of datasets the user has created.
  #             If it is the same user or a sysadmin requesting, it includes datasets
  #             that are draft or private.
  #             (optional, default:``False``, limit:50)
  #         :type include_datasets: bool
  #         :param include_num_followers: Include the number of followers the user has
  #             (optional, default:``False``)
  #         :type include_num_followers: bool
  #         :param include_password_hash: Include the stored password hash
  #             (sysadmin only, optional, default:``False``)
  #         :type include_password_hash: bool
  #         :param include_plugin_extras: Include the internal plugin extras object
  #             (sysadmin only, optional, default:``False``)
  #         :type include_plugin_extras: bool\n\n
  #         :returns: the details of the user. Includes email_hash and
  #             number_created_packages (which excludes draft or private datasets
  #             unless it is the same user or sysadmin making the request). Excludes
  #             the password (hash) and reset_key. If it is the same user or a
  #             sysadmin requesting, the email and apikey are included.
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_autocomplete:
  #   get:
  #     operationId: user_autocomplete
  #     tags:
  #       - organizations
  #     summary: Return a list of user names that contain a string
  #     description: >
  #       :param q: the string to search for
  #         :type q: string
  #         :param limit: the maximum number of user names to return (optional,
  #             default: ``20``)
  #         :type limit: int\n
  #         :rtype: a list of user dictionaries each with keys ``'name'``,
  #             ``'fullname'``, and ``'id'``\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_create:
  #   post:
  #     operationId: user_create
  #     tags:
  #       - organizations
  #     summary: Create a new user.
  #     description: >
  #       You must be authorized to create users.\n
  #         :param name: the name of the new user, a string between 2 and 100
  #             characters in length, containing only lowercase alphanumeric
  #             characters, ``-`` and ``_``
  #         :type name: string
  #         :param email: the email address for the new user
  #         :type email: string
  #         :param password: the password of the new user, a string of at least 4
  #             characters
  #         :type password: string
  #         :param id: the id of the new user (optional)
  #         :type id: string
  #         :param fullname: the full name of the new user (optional)
  #         :type fullname: string
  #         :param about: a description of the new user (optional)
  #         :type about: string
  #         :param image_url: the URL to an image to be displayed on the group's page
  #             (optional)
  #         :type image_url: string
  #         :param plugin_extras: private extra user data belonging to plugins.
  #             Only sysadmin users may set this value. It should be a dict that can
  #             be dumped into JSON, and plugins should namespace their extras with
  #             the plugin name to avoid collisions with other plugins, eg::\n
  #                 {
  #                     name: test_user,
  #                     email: test@example.com,
  #                     plugin_extras: {
  #                         my_plugin: {
  #                             private_extra: 1
  #                         },
  #                         another_plugin: {
  #                             another_extra: True
  #                         }
  #                     }
  #                 }
  #         :type plugin_extras: dict\n\n
  #         :returns: the newly created user
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_invite:
  #   post:
  #     operationId: user_invite
  #     tags:
  #       - organizations
  #     summary: Invite a new user
  #     description: >
  #       You must be authorized to create group members.\n
  #         :param email: the email of the user to be invited to the group
  #         :type email: string
  #         :param group_id: the id or name of the group
  #         :type group_id: string
  #         :param role: role of the user in the group. One of ``member``, ``editor``,
  #             or ``admin``
  #         :type role: string\n
  #         :returns: the newly created user
  #         :rtype: dictionary\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/member_create:
  #   post:
  #     operationId: member_create
  #     tags:
  #       - organizations
  #     summary: Make an object (e.g. a user, dataset or group) a member of a group.
  #     description: >
  #       If the object is already a member of the group then the capacity of the
  #         membership will be updated.\n
  #         You must be authorized to edit the group.\n
  #         :param id: the id or name of the group to add the object to
  #         :type id: string
  #         :param object: the id or name of the object to add
  #         :type object: string
  #         :param object_type: the type of the object being added, e.g. ``'package'``
  #             or ``'user'``
  #         :type object_type: string
  #         :param capacity: the capacity of the membership
  #         :type capacity: string\n
  #         :returns: the newly created (or updated) membership
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_member_create:
  #   post:
  #     operationId: group_member_create
  #     tags:
  #       - organizations
  #     summary: Make a user a member of a group.
  #     description: >
  #       You must be authorized to edit the group.\n
  #         :param id: the id or name of the group
  #         :type id: string
  #         :param username: name or id of the user to be made member of the group
  #         :type username: string
  #         :param role: role of the user in the group. One of ``member``, ``editor``,
  #             or ``admin``
  #         :type role: string\n
  #         :returns: the newly created (or updated) membership
  #         :rtype: dictionary\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_member_create:
  #   post:
  #     operationId: organization_member_create
  #     tags:
  #       - organizations
  #     summary: Make a user a member of an organization.
  #     description: >
  #       You must be authorized to edit the organization.\n
  #         :param id: the id or name of the organization
  #         :type id: string
  #         :param username: name or id of the user to be made member of the
  #             organization
  #         :type username: string
  #         :param role: role of the user in the organization. One of ``member``,
  #             ``editor``, or ``admin``
  #         :type role: string\n
  #         :returns: the newly created (or updated) membership
  #         :rtype: dictionary\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_member_delete:
  #   post:
  #     operationId: group_member_delete
  #     tags:
  #       - organizations
  #     summary: Remove a user from a group.
  #     description: >
  #       You must be authorized to edit the group.\n
  #         :param id: the id or name of the group
  #         :type id: string
  #         :param username: name or id of the user to be removed
  #         :type username: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_member_delete:
  #   post:
  #     operationId: organization_member_delete
  #     tags:
  #       - organizations
  #     summary: Remove a user from an organization.
  #     description: >
  #       You must be authorized to edit the organization.\n
  #         :param id: the id or name of the organization
  #         :type id: string
  #         :param username: name or id of the user to be removed
  #         :type username: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/member_delete:
  #   post:
  #     operationId: member_delete
  #     tags:
  #       - organizations
  #     summary: Remove an object (e.g. a user, dataset or group) from a group.
  #     description: >
  #       You must be authorized to edit a group to remove objects from it.\n
  #         :param id: the id of the group
  #         :type id: string
  #         :param object: the id or name of the object to be removed
  #         :type object: string
  #         :param object_type: the type of the object to be removed, e.g. ``package``
  #             or ``user``
  #         :type object_type: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/package_collaborator_create:
  #   post:
  #     operationId: package_collaborator_create
  #     tags:
  #       - organizations
  #     summary: Make a user a collaborator in a dataset.
  #     description: >
  #       If the user is already a collaborator in the dataset then their
  #         capacity will be updated.\n
  #         Currently you must be an Admin on the dataset owner organization to
  #         manage collaborators.\n
  #         Note: This action requires the collaborators feature to be enabled with
  #         the :ref:`ckan.auth.allow_dataset_collaborators` configuration option.\n
  #         :param id: the id or name of the dataset
  #         :type id: string
  #         :param user_id: the id or name of the user to add or edit
  #         :type user_id: string
  #         :param capacity: the capacity or role of the membership. Must be one of
  #             editor or member. Additionally
  #             if :ref:`ckan.auth.allow_admin_collaborators` is set to True, admin
  #             is also allowed.
  #         :type capacity: string\n
  #         :returns: the newly created (or updated) collaborator
  #         :rtype: dictionary\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/package_collaborator_delete:
  #   post:
  #     operationId: package_collaborator_delete
  #     tags:
  #       - organizations
  #     summary: Remove a collaborator from a dataset.
  #     description: >
  #       Currently you must be an Admin on the dataset owner organization to
  #         manage collaborators.\n
  #         Note: This action requires the collaborators feature to be enabled with
  #         the :ref:`ckan.auth.allow_dataset_collaborators` configuration option.\n
  #         :param id: the id or name of the dataset
  #         :type id: string
  #         :param user_id: the id or name of the user to remove
  #         :type user_id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_create:
  #   post:
  #     operationId: group_create
  #     tags:
  #       - organizations
  #     summary: Create a new group
  #     description: >
  #       You must be authorized to create groups.\n
  #         Plugins may change the parameters of this function depending on the value
  #         of the ``type`` parameter, see the
  #         :py:class:`~ckan.plugins.interfaces.IGroupForm` plugin interface.\n
  #         :param name: the name of the group, a string between 2 and 100 characters
  #             long, containing only lowercase alphanumeric characters, ``-`` and
  #             ``_``
  #         :type name: string
  #         :param id: the id of the group (optional)
  #         :type id: string
  #         :param title: the title of the group (optional)
  #         :type title: string
  #         :param description: the description of the group (optional)
  #         :type description: string
  #         :param image_url: the URL to an image to be displayed on the group's page
  #             (optional)
  #         :type image_url: string
  #         :param type: the type of the group (optional, default: ``'group'``),
  #             :py:class:`~ckan.plugins.interfaces.IGroupForm` plugins
  #             associate themselves with different group types and provide custom
  #             group handling behaviour for these types
  #             Cannot be 'organization'
  #         :type type: string
  #         :param state: the current state of the group, e.g. ``'active'`` or
  #             ``'deleted'``, only active groups show up in search results and
  #             other lists of groups, this parameter will be ignored if you are not
  #             authorized to change the state of the group (optional, default:
  #             ``'active'``)
  #         :type state: string
  #         :param approval_status: (optional)
  #         :type approval_status: string
  #         :param extras: the group's extras (optional), extras are arbitrary
  #             (key: value) metadata items that can be added to groups, each extra
  #             dictionary should have keys ``'key'`` (a string), ``'value'`` (a
  #             string), and optionally ``'deleted'``
  #         :type extras: list of dataset extra dictionaries
  #         :param packages: the datasets (packages) that belong to the group, a list
  #             of dictionaries each with keys ``'name'`` (string, the id or name of
  #             the dataset) and optionally ``'title'`` (string, the title of the
  #             dataset)
  #         :type packages: list of dictionaries
  #         :param groups: the groups that belong to the group, a list of dictionaries
  #             each with key ``'name'`` (string, the id or name of the group) and
  #             optionally ``'capacity'`` (string, the capacity in which the group is
  #             a member of the group)
  #         :type groups: list of dictionaries
  #         :param users: the users that belong to the group, a list of dictionaries
  #             each with key ``'name'`` (string, the id or name of the user) and
  #             optionally ``'capacity'`` (string, the capacity in which the user is
  #             a member of the group)
  #         :type users: list of dictionaries\n
  #         :returns: the newly created group (unless 'return_id_only' is set to True
  #                   in the context, in which case just the group id will
  #                   be returned)
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_update:
  #   post:
  #     operationId: group_update
  #     tags:
  #       - organizations
  #     summary: Update a group
  #     description: >
  #       You must be authorized to edit the group.\n
  #         .. note:: Update methods may delete parameters not explicitly provided in the
  #             data_dict. If you want to edit only a specific attribute use `group_patch`
  #             instead.\n
  #         Plugins may change the parameters of this function depending on the value
  #         of the group's ``type`` attribute, see the
  #         :py:class:`~ckan.plugins.interfaces.IGroupForm` plugin interface.\n
  #         For further parameters see
  #         :py:func:`~ckan.logic.action.create.group_create`.\n
  #         :param id: the name or id of the group to update
  #         :type id: string\n
  #         :returns: the updated group
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_patch:
  #   post:
  #     operationId: group_patch
  #     tags:
  #       - organizations
  #     summary: Patch a group
  #     description: >
  #       :param id: the id or name of the group
  #         :type id: string\n
  #         The difference between the update and patch methods is that the patch will
  #         perform an update of the provided parameters, while leaving all other
  #         parameters unchanged, whereas the update methods deletes all parameters
  #         not explicitly provided in the data_dict\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_delete:
  #   post:
  #     operationId: group_delete
  #     tags:
  #       - organizations
  #     summary: Delete a group
  #     description: >
  #       You must be authorized to delete the group.\n
  #         :param id: the name or id of the group
  #         :type id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_purge:
  #   post:
  #     operationId: group_purge
  #     tags:
  #       - organizations
  #     summary: Purge a group.
  #     description: >
  #       .. warning:: Purging a group cannot be undone!\n
  #         Purging a group completely removes the group from the CKAN database,
  #         whereas deleting a group simply marks the group as deleted (it will no
  #         longer show up in the frontend, but is still in the db).\n
  #         Datasets in the organization will remain, just not in the purged group.\n
  #         You must be authorized to purge the group.\n
  #         :param id: the name or id of the group to be purged
  #         :type id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_patch:
  #   post:
  #     operationId: organization_patch
  #     tags:
  #       - organizations
  #     summary: Patch an organization
  #     description: >
  #       :param id: the id or name of the organization
  #         :type id: string\n
  #         The difference between the update and patch methods is that the patch will
  #         perform an update of the provided parameters, while leaving all other
  #         parameters unchanged, whereas the update methods deletes all parameters
  #         not explicitly provided in the data_dict\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_purge:
  #   post:
  #     operationId: organization_purge
  #     tags:
  #       - organizations
  #     summary: Purge an organization.
  #     description: >
  #       .. warning:: Purging an organization cannot be undone!\n
  #         Purging an organization completely removes the organization from the CKAN
  #         database, whereas deleting an organization simply marks the organization as
  #         deleted (it will no longer show up in the frontend, but is still in the
  #         db).\n
  #         Datasets owned by the organization will remain, just not in an
  #         organization any more.\n
  #         You must be authorized to purge the organization.\n
  #         :param id: the name or id of the organization to be purged
  #         :type id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_update:
  #   post:
  #     operationId: user_update
  #     tags:
  #       - organizations
  #     summary: Update a user account
  #     description: >
  #       Normal users can only update their own user accounts. Sysadmins can update
  #         any user account. Can not modify exisiting user's name.\n
  #         .. note:: Update methods may delete parameters not explicitly provided in the
  #             data_dict. If you want to edit only a specific attribute use `user_patch`
  #             instead.\n
  #         For further parameters see
  #         :py:func:`~ckan.logic.action.create.user_create`.\n
  #         :param id: the name or id of the user to update
  #         :type id: string\n
  #         :returns: the updated user account
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/get_site_user:
  #   get:
  #     operationId: get_site_user
  #     tags:
  #       - organizations
  #     summary: Return the ckan site user
  #     description: >
  #       :param defer_commit: by default (or if set to false) get_site_user will
  #             commit and clean up the current transaction. If set to true, caller
  #             is responsible for commiting transaction after get_site_user is
  #             called. Leaving open connections can cause cli commands to hang!
  #             (optional, default: ``False``)
  #         :type defer_commit: bool\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a

  # /action/group_follower_count:
  #   get:
  #     operationId: group_follower_count
  #     tags:
  #       - social
  #     summary: Return the number of followers of a group
  #     description: >
  #       :param id: the id or name of the group
  #         :type id: string\n
  #         :rtype: int\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_follower_list:
  #   get:
  #     operationId: group_follower_list
  #     tags:
  #       - social
  #     summary: Return the list of users that are following the given group
  #     description: >
  #       :param id: the id or name of the group
  #         :type id: string\n
  #         :rtype: list of dictionaries\n
  #         "
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_followee_count:
  #   get:
  #     operationId: group_followee_count
  #     tags:
  #       - social
  #     summary: Return the number of groups that are followed by the given user
  #     description: >
  #       :param id: the id of the user
  #         :type id: string\n
  #         :rtype: int\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/group_followee_list:
  #   get:
  #     operationId: group_followee_list
  #     tags:
  #       - social
  #     summary: Return the list of groups that are followed by the given user
  #     description: >
  #       :param id: the id or name of the user
  #         :type id: string\n
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/am_following_group:
  #   get:
  #     operationId: am_following_group
  #     tags:
  #       - social
  #     summary: Return ``True`` if you're following the given group, ``False`` if not
  #     description: >
  #       :param id: the id or name of the group
  #         :type id: string\n
  #         :rtype: bool\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_follower_list:
  #   get:
  #     operationId: organization_follower_list
  #     tags:
  #       - social
  #     summary: Return the list of users that are following the given organization
  #     description: >
  #       :param id: the id or name of the organization
  #         :type id: string\n
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_follower_count:
  #   get:
  #     operationId: organization_follower_count
  #     tags:
  #       - social
  #     summary: Return the number of followers of an organization
  #     description: >
  #       :param id: the id or name of the organization
  #         :type id: string\n
  #         :rtype: int\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/organization_followee_list:
  #   get:
  #     operationId: organization_followee_list
  #     tags:
  #       - social
  #     summary: Return the list of organizations that are followed by the given user.
  #     description: >
  #       :param id: the id or name of the user
  #         :type id: string\n
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_follower_count:
  #   get:
  #     operationId: user_follower_count
  #     tags:
  #       - social
  #     summary: Return the number of followers of a user
  #     description: >
  #       :param id: the id or name of the user
  #         :type id: string\n
  #         :rtype: int\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_follower_list:
  #   get:
  #     operationId: user_follower_list
  #     tags:
  #       - social
  #     summary: Return the list of users that are following the given user
  #     description: >
  #       :param id: the id or name of the user
  #         :type id: string\n
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/am_following_user:
  #   get:
  #     operationId: am_following_user
  #     tags:
  #       - social
  #     summary: Return ``True`` if you're following the given user, ``False`` if not.
  #     description: >
  #       :param id: the id or name of the user
  #         :type id: string\n
  #         :rtype: bool\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_followee_count:
  #   get:
  #     operationId: user_followee_count
  #     tags:
  #       - social
  #     summary: Return the number of users that are followed by the given user.
  #     description: >
  #       :param id: the id of the user
  #         :type id: string\n
  #         :rtype: int\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_followee_list:
  #   get:
  #     operationId: user_followee_list
  #     tags:
  #       - social
  #     summary: Return the list of users that are followed by the given user
  #     description: >
  #       :param id: the id of the user
  #         :type id: string\n
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/dataset_follower_count:
  #   get:
  #     operationId: dataset_follower_count
  #     tags:
  #       - social
  #     summary: Return the number of followers of a dataset
  #     description: >
  #       :param id: the id or name of the dataset
  #         :type id: string\n
  #         :rtype: int\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/dataset_follower_list:
  #   get:
  #     operationId: dataset_follower_list
  #     tags:
  #       - social
  #     summary: Return the list of users that are following the given dataset
  #     description: >
  #       :param id: the id or name of the dataset
  #         :type id: string\n
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/am_following_dataset:
  #   get:
  #     operationId: am_following_dataset
  #     tags:
  #       - social
  #     summary: Return ``True`` if you're following the given dataset, ``False`` if not
  #     description: >
  #       :param id: the id or name of the dataset
  #         :type id: string\n
  #         :rtype: bool\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/dataset_followee_count:
  #   get:
  #     operationId: dataset_followee_count
  #     tags:
  #       - social
  #     summary: Return the number of datasets that are followed by the given user
  #     description: >
  #       :param id: the id of the user
  #         :type id: string\n
  #         :rtype: int\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/dataset_followee_list:
  #   get:
  #     operationId: dataset_followee_list
  #     tags:
  #       - social
  #     summary: Return the list of datasets that are followed by the given user.
  #     description: >
  #       :param id: the id or name of the user
  #         :type id: string\n
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/followee_count:
  #   get:
  #     operationId: followee_count
  #     tags:
  #       - social
  #     summary: Return the number of objects that are followed by the given user
  #     description: >
  #       Counts all objects, of any type, that the given user is following
  #         (e.g. followed users, followed datasets, followed groups).\n
  #         :param id: the id of the user
  #         :type id: string\n
  #         :rtype: int\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/followee_list:
  #   get:
  #     operationId: followee_list
  #     tags:
  #       - social
  #     summary: Return the list of objects that are followed by the given user
  #     description: >
  #       Returns all objects, of any type, that the given user is following
  #         (e.g. followed users, followed datasets, followed groups.. ).\n
  #         :param id: the id of the user
  #         :type id: string\n
  #         :param q: a query string to limit results by, only objects whose display
  #             name begins with the given string (case-insensitive) wil be returned
  #             (optional)
  #         :type q: string\n
  #         :rtype: list of dictionaries, each with keys ``'type'`` (e.g. ``'user'``,
  #             ``'dataset'`` or ``'group'``), ``'display_name'`` (e.g. a user's
  #             display name, or a package's title) and ``'dict'`` (e.g. a dict
  #             representing the followed user, package or group, the same as the dict
  #             that would be returned by :py:func:`user_show`,
  #             :py:func:`package_show` or :py:func:`group_show`)\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/follow_user:
  #   post:
  #     operationId: follow_user
  #     tags:
  #       - social
  #     summary: Start following another user
  #     description: >
  #       You must provide your API key in the Authorization header.\n
  #         :param id: the id or name of the user to follow, e.g. ``'joeuser'``
  #         :type id: string\n
  #         :returns: a representation of the 'follower' relationship between yourself
  #             and the other user
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/follow_dataset:
  #   post:
  #     operationId: follow_dataset
  #     tags:
  #       - social
  #     summary: Start following a dataset
  #     description: >
  #       You must provide your API key in the Authorization header.\n
  #         :param id: the id or name of the dataset to follow, e.g. ``'warandpeace'``
  #         :type id: string\n
  #         :returns: a representation of the 'follower' relationship between yourself
  #             and the dataset
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/follow_group:
  #   post:
  #     operationId: follow_group
  #     tags:
  #       - social
  #     summary: Start following a group.
  #     description: >
  #       You must provide your API key in the Authorization header.\n
  #         :param id: the id or name of the group to follow, e.g. ``'roger'``
  #         :type id: string\n
  #         :returns: a representation of the 'follower' relationship between yourself
  #             and the group
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/unfollow_user:
  #   post:
  #     operationId: unfollow_user
  #     tags:
  #       - social
  #     summary: Stop following a user.
  #     description: >
  #       :param id: the id or name of the user to stop following
  #         :type id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/unfollow_dataset:
  #   post:
  #     operationId: unfollow_dataset
  #     tags:
  #       - social
  #     summary: Stop following a dataset.
  #     description: >
  #       :param id: the id or name of the dataset to stop following
  #         :type id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/unfollow_group:
  #   post:
  #     operationId: unfollow_group
  #     tags:
  #       - social
  #     summary: Stop following a group
  #     description: >
  #       :param id: the id or name of the group to stop following
  #         :type id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/rating_create:
  #   post:
  #     operationId: rating_create
  #     tags:
  #       - social
  #     summary: Rate a dataset (package).
  #     description: >
  #       You must provide your API key in the Authorization header.\n
  #         :param package: the name or id of the dataset to rate
  #         :type package: string
  #         :param rating: the rating to give to the dataset, an integer between 1 and
  #             5
  #         :type rating: int\n
  #         :returns: a dictionary with two keys: ``'rating average'`` (the average
  #             rating of the dataset you rated) and ``'rating count'`` (the number of
  #             times the dataset has been rated)
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a

  # /action/vocabulary_update:
  #   post:
  #     operationId: vocabulary_update
  #     tags:
  #       - serveradmin
  #     summary: Update a tag vocabulary
  #     description: >
  #       You must be a sysadmin to update vocabularies.\n
  #         For further parameters see
  #         :py:func:`~ckan.logic.action.create.vocabulary_create`.\n
  #         :param id: the id of the vocabulary to update
  #         :type id: string\n
  #         :returns: the updated vocabulary
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/vocabulary_delete:
  #   post:
  #     operationId: vocabulary_delete
  #     tags:
  #       - serveradmin
  #     summary: Delete a tag vocabulary.
  #     description: >
  #       You must be a sysadmin to delete vocabularies.\n
  #         :param id: the id of the vocabulary
  #         :type id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/user_delete:
  #   post:
  #     operationId: user_delete
  #     tags:
  #       - serveradmin
  #     summary: Delete a user.
  #     description: >
  #       Only sysadmins can delete users.\n
  #         :param id: the id or usernamename of the user to delete
  #         :type id: string\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/site_read:
  #   get:
  #     operationId: site_read
  #     tags:
  #       - serveradmin
  #     summary: Return True
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/license_list:
  #   get:
  #     operationId: license_list
  #     tags:
  #       - serveradmin
  #     summary: Return the list of licenses available for datasets on the site
  #     description: >
  #       :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/format_autocomplete:
  #   get:
  #     operationId: format_autocomplete
  #     tags:
  #       - serveradmin
  #     summary: Return a list of resource formats whose names contain a string
  #     description: >
  #       :param q: the string to search for
  #         :type q: string
  #         :param limit: the maximum number of resource formats to return (optional,
  #             default: ``5``)
  #         :type limit: int\n
  #         :rtype: list of strings\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/status_show:
  #   get:
  #     operationId: status_show
  #     tags:
  #       - serveradmin
  #     summary: Return a dictionary with information about the site's configuration
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a

  # /action/config_option_show:
  #   get:
  #     operationId: config_option_show
  #     tags:
  #       - serveradmin
  #     summary: Show the current value of a particular configuration option.
  #     description: >
  #       Only returns runtime-editable config options (the ones returned by
  #         :py:func:`~ckan.logic.action.get.config_option_list`), which can be updated with the
  #         :py:func:`~ckan.logic.action.update.config_option_update` action.\n
  #         :param key: The configuration option key
  #         :type key: string\n
  #         :returns: The value of the config option from either the system_info table
  #             or ini file.
  #         :rtype: string\n
  #         :raises: :class:`ckan.logic.ValidationError`: if config option is not in
  #             the schema (whitelisted as editable).\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/config_option_list:
  #   get:
  #     operationId: config_option_list
  #     tags:
  #       - serveradmin
  #     summary: Return a list of runtime-editable config options keys
  #     description: >
  #       Return a list of runtime-editable config options keys that can be
  #            updated with :py:func:`~ckan.logic.action.update.config_option_update`.\n
  #         :returns: A list of config option keys.
  #         :rtype: list\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/job_list:
  #   get:
  #     operationId: job_list
  #     tags:
  #       - serveradmin
  #     summary: List enqueued background jobs.
  #     description: >
  #       :param list queues: Queues to list jobs from. If not given then the
  #             jobs from all queues are listed.\n
  #         :returns: The currently enqueued background jobs.
  #         :rtype: list\n
  #         .. versionadded:: 2.7\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/job_show:
  #   get:
  #     operationId: job_show
  #     tags:
  #       - serveradmin
  #     summary: Show details for a background job
  #     description: >
  #       :param string id: The ID of the background job.\n
  #         :returns: Details about the background job.
  #         :rtype: dict\n
  #         .. versionadded:: 2.7\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/tag_create:
  #   post:
  #     operationId: tag_create
  #     tags:
  #       - serveradmin
  #     summary: Create a new vocabulary tag.
  #     description: >
  #       You must be a sysadmin to create vocabulary tags.\n
  #         You can only use this function to create tags that belong to a vocabulary,
  #         not to create free tags. (To create a new free tag simply add the tag to
  #         a package, e.g. using the
  #         :py:func:`~ckan.logic.action.update.package_update` function.)\n
  #         :param name: the name for the new tag, a string between 2 and 100
  #             characters long containing only alphanumeric characters and ``-``,
  #             ``_`` and ``.``, e.g. ``'Jazz'``
  #         :type name: string
  #         :param vocabulary_id: the id of the vocabulary that the new tag
  #             should be added to, e.g. the id of vocabulary ``'Genre'``
  #         :type vocabulary_id: string\n
  #         :returns: the newly-created tag
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/task_status_update:
  #   post:
  #     operationId: task_status_update
  #     tags:
  #       - serveradmin
  #     summary: Update a task status
  #     description: >
  #       :param id: the id of the task status to update
  #         :type id: string
  #         :param entity_id:
  #         :type entity_id: string
  #         :param entity_type:
  #         :type entity_type: string
  #         :param task_type:
  #         :type task_type: string
  #         :param key:
  #         :type key: string
  #         :param value: (optional)
  #         :type value:
  #         :param state: (optional)
  #         :type state:
  #         :param last_updated: (optional)
  #         :type last_updated:
  #         :param error: (optional)
  #         :type error:\n
  #         :returns: the updated task status
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/task_status_update_many:
  #   post:
  #     operationId: task_status_update_many
  #     tags:
  #       - serveradmin
  #     summary: Update many task statuses at once
  #     description: >
  #       :param data: the task_status dictionaries to update, for the format of task
  #             status dictionaries see
  #             :py:func:`~task_status_update`
  #         :type data: list of dictionaries\n
  #         :returns: the updated task statuses
  #         :rtype: list of dictionaries\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/term_translation_update:
  #   post:
  #     operationId: term_translation_update
  #     tags:
  #       - serveradmin
  #     summary: Create or update a term translation
  #     description: >
  #       You must be a sysadmin to create or update term translations.\n
  #         :param term: the term to be translated, in the original language, e.g.
  #             ``'romantic novel'``
  #         :type term: string
  #         :param term_translation: the translation of the term, e.g.
  #             ``'Liebesroman'``
  #         :type term_translation: string
  #         :param lang_code: the language code of the translation, e.g. ``'de'``
  #         :type lang_code: string\n
  #         :returns: the newly created or updated term translation
  #         :rtype: dictionary\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/term_translation_update_many:
  #   post:
  #     operationId: term_translation_update_many
  #     tags:
  #       - serveradmin
  #     summary: Create or update many term translations at once
  #     description: >
  #       param data: the term translation dictionaries to create or update,
  #             for the format of term translation dictionaries see
  #             :py:func:`~term_translation_update`
  #         :type data: list of dictionaries\n
  #         :returns: a dictionary with key ``'success'`` whose value is a string
  #             stating how many term translations were updated
  #         :rtype: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/send_email_notifications:
  #   post:
  #     operationId: send_email_notifications
  #     tags:
  #       - serveradmin
  #     summary: Send any pending activity stream notification emails to users.
  #     description: >
  #       You must provide a sysadmin's API key in the Authorization header of the
  #         request, or call this action from the command-line via a `paster post ...`
  #         command.\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/config_option_update:
  #   post:
  #     operationId: config_option_update
  #     tags:
  #       - serveradmin
  #     summary: Allows to modify some CKAN runtime-editable config options
  #     description: >
  #       It takes arbitrary key, value pairs and checks the keys against the
  #         config options update schema. If some of the provided keys are not present
  #         in the schema a :py:class:`~ckan.plugins.logic.ValidationError` is raised.
  #         The values are then validated against the schema, and if validation is
  #         passed, for each key, value config option:\n
  #         * It is stored on the ``system_info`` database table
  #         * The Pylons ``config`` object is updated.
  #         * The ``app_globals`` (``g``) object is updated (this only happens for
  #           options explicitly defined in the ``app_globals`` module.\n
  #         The following lists a ``key`` parameter, but this should be replaced by
  #         whichever config options want to be updated, eg::\n
  #             get_action('config_option_update)({}, {
  #                 'ckan.site_title': 'My Open Data site',
  #                 'ckan.homepage_layout': 2,
  #             })\n
  #         :param key: a configuration option key (eg ``ckan.site_title``). It must
  #             be present on the ``update_configuration_schema``
  #         :type key: string\n
  #         :returns: a dictionary with the options set
  #         :rtype: dictionary\n
  #         .. note:: You can see all available runtime-editable configuration options
  #             calling
  #             the :py:func:`~ckan.logic.action.get.config_option_list` action\n
  #         .. note:: Extensions can modify which configuration options are
  #             runtime-editable.
  #             For details, check :doc:`/extensions/remote-config-update`.\n
  #         .. warning:: You should only add config options that you are comfortable
  #             they can be edited during runtime, such as ones you've added in your
  #             own extension, or have reviewed the use of in core CKAN.\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/task_status_delete:
  #   post:
  #     operationId: task_status_delete
  #     tags:
  #       - serveradmin
  #     summary: Delete a task status.
  #     description: >
  #       You must be a sysadmin to delete task statuses.\n
  #         :param id: the id of the task status to delete
  #         :type id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/tag_delete:
  #   post:
  #     operationId: tag_delete
  #     tags:
  #       - serveradmin
  #     summary: Delete a tag.
  #     description: >
  #       You must be a sysadmin to delete tags.\n
  #         :param id: the id or name of the tag
  #         :type id: string
  #         :param vocabulary_id: the id or name of the vocabulary that the tag belongs
  #             to (optional, default: None)
  #         :type vocabulary_id: string\n\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/job_clear:
  #   post:
  #     operationId: job_clear
  #     tags:
  #       - serveradmin
  #     summary: Clear background job queues.
  #     description: >
  #       Does not affect jobs that are already being processed.\n
  #         :param list queues: The queues to clear. If not given then ALL
  #             queues are cleared.\n
  #         :returns: The cleared queues.
  #         :rtype: list\n
  #         .. versionadded:: 2.7\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a
  # /action/job_cancel:
  #   post:
  #     operationId: job_cancel
  #     tags:
  #       - serveradmin
  #     summary: Cancel a queued background job
  #     description: >
  #       Removes the job from the queue and deletes it.\n
  #         :param string id: The ID of the background job.\n
  #         .. versionadded:: 2.7\n
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: a

  # /action/resource_view_clear:
  #   post:
  #     operationId: resource_view_clear
  #     tags:
  #       - datamanagement
  #     summary: Delete all resource views, or all of a particular type.
  #     description: >
  #       Delete all resource views, or all of a particular type.
  #     responses:
  #       "400":
  #         description: bad input parameter
  #       "200":
  #         description: Success
  #     security:
  #       - ckanapikey: []