OAS.yaml

openapi: 3.1.0
x-stoplight:
  id: x7yg9vhm1mt4z
info:
  title: Public Code
  version: '1.0'
  license:
    name: EUPL
  contact:
    name: Ruben van der Linde
    url: www.conduction.nl
    email: ruben@conduction.nl
  summary: 'The publiccode API is the engine under Open Catalogi, it provides an [joinUp](https://joinup.ec.europa.eu/) compliant implementation of the [publicCode](https://yml.publiccode.tools/index.html) freamwork. It also provides some spefic dutch extensions to that frame work in order to make it work in tendem with the dutch {componenten catalogus](https://componentencatalogus.commonground.nl/)  and [developer.overheid](https://developer.overheid.nl/).'
servers:
  - url: 'http://localhost:3000'
paths:
  /components:
    post:
      summary: Create component
      tags:
        - component
      responses:
        '201':
          description: Created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Component'
            application/xml:
              schema:
                $ref: '#/components/schemas/Component'
      operationId: post-components
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Component'
    get:
      summary: Search components
      tags:
        - component
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Component'
      operationId: get-components
      description: ''
      parameters: []
  '/components/{id}':
    parameters:
      - schema:
          type: string
        name: id
        in: path
        required: true
    put:
      summary: Update a component
      tags:
        - components
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Component'
      operationId: put-components-id
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Component'
    get:
      summary: Get a single component
      tags:
        - components
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Component'
      operationId: get-components-id
    delete:
      summary: Delete Component
      operationId: delete-components-id
      responses:
        '200':
          description: OK
  /organizations:
    get:
      summary: GET organizations
      tags:
        - Organization
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Organisation'
      operationId: get-organizations
    post:
      summary: POST organization
      operationId: post-organizations
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: ../models/Organization.yaml
      requestBody:
        content:
          application/json:
            schema:
              $ref: ../models/Organization.yaml
      tags:
        - Organization
  '/organizations/{id}':
    parameters:
      - schema:
          type: string
        name: id
        in: path
        required: true
    get:
      summary: GET organization
      tags:
        - Organization
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Organisation'
      operationId: get-organizations-id
    put:
      summary: PUT organization
      operationId: put-organizations-id
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: ../models/Organization.yaml
      tags:
        - Organization
      requestBody:
        content:
          application/json:
            schema:
              $ref: ../models/Organization.yaml
    delete:
      summary: DELETE organization
      operationId: delete-organizations-id
      responses:
        '200':
          description: OK
      tags:
        - Organization
  /applications:
    get:
      summary: Your GET endpoint
      tags: []
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Application'
      operationId: get-applications
    post:
      summary: ''
      operationId: post-applications
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Application'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Application'
  '/applications/{id}':
    parameters:
      - schema:
          type: string
        name: id
        in: path
        required: true
    get:
      summary: Your GET endpoint
      tags: []
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Application'
      operationId: get-applications-id
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Application'
    put:
      summary: ''
      operationId: put-applications-id
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Application'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Application'
    delete:
      summary: ''
      operationId: delete-applications-id
      responses:
        '200':
          description: OK
  /catalogi:
    get:
      summary: Your GET endpoint
      tags: []
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Catalogi'
      operationId: get-catalogi
    post:
      summary: ''
      operationId: post-catalogi
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Catalogi'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Catalogi'
  '/catalogi/{id}':
    parameters:
      - schema:
          type: string
        name: id
        in: path
        required: true
    get:
      summary: Your GET endpoint
      tags: []
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Catalogi'
      operationId: get-catalogi-id
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Catalogi'
    put:
      summary: ''
      operationId: put-catalogi-id
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Catalogi'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Catalogi'
    delete:
      summary: ''
      operationId: delete-catalogi-id
      responses:
        '200':
          description: OK
  /repositories:
    get:
      summary: Your GET endpoint
      tags: []
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Repository'
      operationId: get-repositories
    post:
      summary: ''
      operationId: post-repositories
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: object
                properties: {}
            application/xml:
              schema:
                $ref: '#/components/schemas/Repository'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Repository'
  '/repositories/{id}':
    parameters:
      - schema:
          type: string
        name: id
        in: path
        required: true
    get:
      summary: Your GET endpoint
      tags: []
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Repository'
      operationId: get-repositories-id
    put:
      summary: ''
      operationId: put-repositories-id
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Repository'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Repository'
    delete:
      summary: ''
      operationId: delete-repositories-id
      responses:
        '200':
          description: OK
components:
  schemas:
    Application:
      title: Application
      x-stoplight:
        id: rxtjerlhpkxnm
      type: object
      description: ''
      x-tags:
        - application
      properties:
        id:
          type: string
        name:
          type: string
        shortDescription:
          type: string
        description:
          type: string
        detailPageImageUrl:
          type: string
        documentationUrl:
          type: string
        demoUrl:
          type: string
        bpmnProcessUrl:
          type: string
        isPublished:
          type: boolean
        owner:
          type: object
          properties:
            fullName:
              type: string
            email:
              type: string
            pictureUrl:
              type: string
        components:
          type: array
          items:
            $ref: '#/components/schemas/ComponentUrl'
      required:
        - name
    Catalogi:
      title: Catalogi
      x-stoplight:
        id: lvyd1ecf535j4
      type: object
      properties:
        source:
          type: object
          properties:
            name:
              type: string
            description:
              type: string
            location:
              type: string
        organisation:
          $ref: '#/components/schemas/Organisation'
        rsin:
          type: string
        pki:
          type: string
    Component:
      title: Component
      x-stoplight:
        id: 58v2ropv82qs8
      type: object
      description: |-
        Based on the [top level component](https://yml.publiccode.tools/schema.core.html#top-level-keys-and-sections) of public code. represent a pease of software that may iether be  standalone or part of a larger application.

        **The PublicCode standard has been extenden for this API in te following way's**
        - To the `type` property the following enums where added
        - - Api
        - - Schema
        - - Data
        - The `inputType` property was used (its depracticed in PublicCode)
        - The `outputType` property was uses (its depracticed in PublicCode)
        - The `nl` country exenstion was added in line with the [PublicCode country extensions](https://yml.publiccode.tools/country.html) guidelines
        - applicationId was added for the codebase repository (like a github repository id).
      examples:
        - id: 497f6eca-6276-4993-bfeb-53cbbbba6f08
          name: Medusa
          applicationSuite:
            id: string
            name: string
          url: 'https://example.com/italia/medusa.git'
          landingURL: 'https://example.com/italia/medusa'
          isBasedOn: 'https://github.com/italia/otello.git'
          softwareVersion: '1.0'
          logo: 'https://avatars0.githubusercontent.com/u/34739001?s=280&v=4'
          releaseDate: '2022-01-01'
          platforms: web
          categories:
            - Acounting
          usedBy:
            - City of Amsterdam
          roadmap: 'https://vng.nl/agenda'
          developmentStatus: concept
          softwareType: standalone/web
          layerType: interface
          installationType: self
          intendedAudience:
            countries:
              - nl
            unsupportedCountries:
              - de
            scope:
              - agriculture
              - culture
          description:
            NL: {}
      x-tags:
        - component
      properties:
        id:
          type: string
          format: uuid
        applicationId:
          type: string
          example: '487842915'
        name:
          type: string
          description: 'This key contains the name of the software. It contains the (short) public name of the product, which can be localised in the specific localisation section. It should be the name most people usually refer to the software. In case the software has both an internal “code” name and a commercial name, use the commercial name.'
          example: Medusa
        applicationSuite:
          $ref: '#/components/schemas/Application'
        url:
          $ref: '#/components/schemas/Repository'
        landingURL:
          type: string
          description: 'If the url parameter does not serve a human readable or browsable page, but only serves source code to a source control client, with this key you have an option to specify a landing page. This page, ideally, is where your users will land when they will click a button labeled something like “Go to the application source code”. In case the product provides an automated graphical installer, this URL can point to a page which contains a reference to the source code but also offers the download of such an installer.'
          format: url
          example: 'https://example.com/italia/medusa'
        isBasedOn:
          type: string
          description: |-
            In case this software is a variant or a fork of another software, which might or might not contain a publiccode.yml file, this key will contain the url of the original project(s).

            The existence of this key identifies the fork as a software variant, descending from the specified repositories.
          example: 'https://github.com/italia/otello.git'
        softwareVersion:
          type: string
          example: '1.0'
          description: |-
            This key contains the latest stable version number of the software. The version number is a string that is not meant to be interpreted and parsed but just displayed; parsers should not assume semantic versioning or any other specific version format.

            The key can be omitted if the software is currently in initial development and has never been released yet.
        releaseDate:
          type: string
          description: This key contains the date at which the latest version was released. This date is mandatory if the software has been released at least once and thus the version number is present.
          format: date
          example: '2022-01-01'
        logo:
          type: string
          description: 'This key contains the path to the logo of the software. Logos should be in vector format; raster formats are only allowed as a fallback. In this case, they should be transparent PNGs, minimum 1000px of width. The key value can be the relative path to the file starting from the root of the repository, or it can be an absolute URL pointing to the logo in raw version. In both cases, the file must reside inside the same repository where the publiccode.yml file is stored.'
          example: 'https://avatars0.githubusercontent.com/u/34739001?s=280&v=4'
        platforms:
          type: array
          description: |-
            This key specifies which platform the software runs on. It is meant to describe the platforms that users will use to access and operate the software, rather than the platform the software itself runs on.

            Use the predefined values if possible. If the software runs on a platform for which a predefined value is not available, a different value can be used.
          example: web
          enum:
            - web
            - windows
            - mac
            - linux
            - ios
            - android
          items:
            type: string
        categories:
          type: array
          description: |-
            A list of words that can be used to describe the software and can help building catalogs of open software.

            The controlled vocabulary List of software categories contains the list of allowed values.
          items:
            type: string
            enum:
              - accounting
              - agile-project-management
              - applicant-tracking
              - application-development
              - appointment-scheduling
              - backup
            example: accounting
        usedBy:
          description: |-
            A list of the names of prominent public administrations (that will serve as “testimonials”) that are currently known to the software maintainer to be using this software.

            Parsers are encouraged to enhance this list also with other information that can obtain independently; for instance, a fork of a software, owned by an administration, could be used as a signal of usage of the software.
          type: array
          items:
            $ref: '#/components/schemas/Organisation'
        roadmap:
          type: string
          description: A link to a public roadmap of the software.
          format: url
          example: 'https://vng.nl/agenda'
        developmentStatus:
          type: string
          description: |-
            The keys are:


            -  concept - The software is just a “concept”. No actual code may have been produced, and the repository could simply be a placeholder.
            - development - Some effort has gone into the development of the software, but the code is not ready for the end user, even in a preliminary version (beta or alpha) to be tested by end users.
            - beta - The software is in the testing phase (alpha or beta). At this stage, the software might or might not have had a preliminary public release.
            - stable - The software has seen a first public release and is ready to be used in a production environment.
            - obsolete - The software is no longer maintained or kept up to date. All of the source code is archived and kept for historical reasons.
          enum:
            - concept
            - development
            - beta
            - stable
            - obsolete
          example: concept
        softwareType:
          type: string
          description: |-
            The keys are:

            - standalone/mobile - The software is a standalone, self-contained The software is a native mobile app.
            - standalone/iot - The software is suitable for an IoT context.
            - standalone/desktop - The software is typically installed and run in a a desktop operating system environment.
            - standalone/web - The software represents a web application usable by means of a browser.
            - standalone/backend - The software is a backend application.
            - standalone/other - The software has a different nature from the once listed above.
            - softwareAddon - The software is an addon, such as a plugin or a theme, for a more complex software (e.g. a CMS or an office suite).
            -  library - The software contains a library or an SDK to make it easier to third party developers to create new products.
            - configurationFiles - The software does not contain executable script but a set of configuration files. They may document how to obtain a certain deployment. They could be in the form of plain configuration files, bash scripts, ansible playbooks, Dockerfiles, or other instruction sets.
          example: standalone/web
          enum:
            - standalone/mobile
            - standalone/iot
            - standalone/desktop
            - standalone/web
            - standalone/backend
            - standalone/other
            - softwareAddon
            - library
            - configurationFiles
            - api
            - schema
            - data
            - process
            - model
        intendedAudience:
          type: object
          properties:
            countries:
              description: 'This key explicitly includes certain countries in the intended audience, i.e. the software explicitly claims compliance with specific processes, technologies or laws. All countries are specified using lowercase ISO 3166-1 alpha-2 two-letter country codes.'
              type: array
              items: {}
            unsupportedCountries:
              type: array
              description: 'This key explicitly marks countries as NOT supported. This might be the case if there is a conflict between how software is working and a specific law, process or technology. All countries are specified using lowercase ISO 3166-1 alpha-2 two-letter country codes.'
              items:
                type: string
            scope:
              type: array
              description: This key contains a list of tags related to the field of application of the software.
              items:
                type: string
                example: agriculture
                enum:
                  - agriculture
                  - culture
                  - defence
                  - education
                  - emergency-services
                  - employment
                  - energy
                  - environment
                  - finance-and-economic-development
                  - foreign-affairs
                  - government
                  - healthcare
                  - infrastructures
                  - justice
                  - local-authorities
                  - manufacturing
                  - research
                  - science-and-technology
                  - security
                  - society
                  - sport
                  - tourism
                  - transportation
                  - welfare
        description:
          $ref: '#/components/schemas/Description'
        legal:
          type: object
          description: |-
            This section provides information on the legalstatus of the software, useful to evaluate whether the software can be used or not.

            In the following part of the document, all keys are assumed to be in a sub-section with the name of the language (we will note this with [lang]).
          properties:
            license:
              type: string
              description: 'This string describes the license under which the software is distributed. The string must contain a valid SPDX expression, referring to one (or multiple) open-source license. Please refer to the SPDX documentation for further information.'
              example: EUPL-1.0-or-later
            mainCopyrightOwner:
              $ref: '#/components/schemas/Organisation'
            repoOwner:
              $ref: '#/components/schemas/Organisation'
            authorsFile:
              type: string
              description: 'Some open-source software adopt a convention of identify the copyright holders through a file that lists all the entities that own the copyright. This is common in projects strongly backed by a community where there are many external contributors and no clear single/main copyright owner. In such cases, this key can be used to refer to the authors file, using a path relative to the root of the repository.'
              example: doc/AUTHORS.txt
        maintenance:
          type: object
          description: 'This section provides information on the maintenance status of the software, useful to evaluate whether the software is actively developed or not.'
          properties:
            type:
              type: string
              description: |-
                This key describes how the software is currently maintained.

                internal - means that the software is internally maintained by the repository owner;

                contract - means that there is a commercial contract that binds an entity to the maintenance of the software;

                community - means that the software is currently maintained by one or more people that donate their time to the project;

                none - means that the software is not actively maintained.
              enum:
                - internal
                - contract
                - community
              example: none
            contractors:
              type: array
              description: 'This key describes the entity or entities, if any, that are currently contracted for maintaining the software. They can be companies, organizations, or other collective names.'
              items:
                $ref: '#/components/schemas/Contractor'
            contacts:
              description: |-
                One or more contacts maintaining this software.

                This key describes the technical people currently responsible for maintaining the software. All contacts need to be a physical person, not a company or an organisation. If somebody is acting as a representative of an institution, it must be listed within the affiliation of the contact.

                In case of a commercial agreement (or a chain of such agreements), specify the final entities actually contracted to deliver the maintenance. Do not specify the software owner unless it is technically involved with the maintenance of the product as well.
              type: array
              items:
                $ref: '#/components/schemas/Contact'
          required:
            - type
        localisation:
          type: object
          description: This section provides an overview of the localization features of the software.
          properties:
            localisationReady:
              type: boolean
              description: 'If true, the software has infrastructure in place or is otherwise designed to be multilingual. It does not need to be available in more than one language.'
            availableLanguages:
              type: array
              description: |
                If present, this is the list of languages in which the software is available. Of course, this list will contain at least one language. The primary language subtag cannot be omitted, as mandated by the BCP 47.
              items: {}
          required:
            - localisationReady
        dependsOn:
          type: object
          description: |-
            This section provides an overview on the system-level dependencies required to install and use this software.

            NOTE: do not list dependencies at the source code level (e.g.: software libraries being used), and focus only on runtime and/or system-level dependencies that must be installed and maintained separately. For instance, a database is a good example of such dependencies.
          properties:
            open:
              type: array
              description: This key contains a list of runtime dependencies that are distributed under an open-source license.
              items:
                $ref: '#/components/schemas/Dependency'
            proprietary:
              type: array
              description: This key contains a list of runtime dependencies that are distributed under a proprietary license.
              items:
                $ref: '#/components/schemas/Dependency'
            hardware:
              type: array
              description: This key contains a list of hardware dependencies that must be owned to use the software.
              items:
                $ref: '#/components/schemas/Dependency'
        nl:
          type: object
          description: 'Extension to the publiccode standard for the netherlands by [vng](https://vng.nl/) in accordance with the publiccode [Country-Specific Sections](https://yml.publiccode.tools/country.html)'
          properties:
            commonground:
              type: object
              description: 'Commonground specific properties for use with the [componnenten catalogue](https://componentencatalogus.commonground.nl/).'
              properties:
                intendedOrganisations:
                  type: array
                  description: A list of organisations that may use this component (wont be visable to other organisations)
                  items: {}
                installationType:
                  type: string
                  enum:
                    - self
                    - helm
                    - provision
                  example: self
                  description: |-
                    Extension to publiccode bassed on the componentencatalogus. Should be one of
                    - self
                    - helm
                layerType:
                  type: string
                  enum:
                    - interface
                    - integration
                    - data
                    - service
                    - process
                  example: interface
                  description: 'An extension to public code based on the componentencatalogus. Refers to the layer on wich the component oprates, see [documentation](https://commonground.nl/cms/view/12f73f0d-ae26-4021-ba52-849eef37d11f/de-common-ground-principes/03743740-a49f-48d8-9fc5-e24f86d748ed)'
            gemma:
              type: object
              properties:
                bedrijfsfuncties:
                  type: array
                  items:
                    type: string
                bedrijfsservices:
                  type: array
                  items:
                    type: string
                applicatiefunctie:
                  type: string
                model:
                  type: string
                  description: Het soort model (mag alleen worden gebruikt als het type schema is).
                  enum:
                    - Semantisch
                    - Conceptueel
                    - Logisch
                    - Fysiek
                  example: Semantisch
                referentieComponenten:
                  type: array
                  items:
                    type: string
            apm:
              type: object
            upl:
              type: array
              items:
                type: string
        inputTypes:
          type: array
          description: |-
            A list of Media Types (MIME Types) as mandated in RFC 6838 which the application can handle as input.

            In case the software does not support any input, you can skip this field or use application/x.empty
          items:
            type: string
        outputTypes:
          type: array
          description: |-
            A list of Media Types (MIME Types) as mandated in RFC 6838 which the application can handle as output.

            In case the software does not support any output, you can skip this field or use application/x.empty
          items:
            type: string
        rating:
          $ref: '#/components/schemas/Rating'
      required:
        - name
    ComponentUrl:
      title: ComponentUrl
      x-stoplight:
        id: yw083kveb0cc0
      type: object
      properties:
        repositoryUrl:
          type: string
    Contact:
      title: Contact
      x-stoplight:
        id: bspcro7twxzw5
      type: object
      examples:
        - id: string
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
          description: 'This key contains the full name of one of the technical contacts. It must be a real person; do NOT populate this key with generic contact information, company departments, associations, etc.'
        email:
          type: string
          description: 'This key contains the e-mail address of the technical contact. It must be an email address of where the technical contact can be directly reached; do NOT populate this key with mailing-lists or generic contact points like “info@acme.inc”. The e-mail address must not be obfuscated. To improve resistance against e-mail collection, use \x64 to replace @, as allowed by the YAML specification.'
          format: email
        phone:
          type: string
          description: phone number (with international prefix). This has to be a string.
        affiliation:
          type: string
          description: 'This key contains an explicit affiliation information for the technical contact. In case of multiple maintainers, this can be used to create a relation between each technical contact and each maintainer entity. It can contain for instance a company name, an association name, etc.'
      required:
        - name
      x-tags:
        - contact
    Contractor:
      title: Contractor
      x-stoplight:
        id: wmxrj9lq1v5y2
      type: object
      x-tags:
        - contractor
      properties:
        id:
          type: string
          format: uuid
        organisation:
          $ref: '#/components/schemas/Organisation'
        until:
          type: string
          description: 'This is a date (YYYY-MM-DD). This key must contain the date at which the maintenance is going to end. In case of community maintenance, the value should not be more than 2 years in the future, and thus will need to be regularly updated as the community continues working on the project.'
          format: date
      required:
        - id
        - organisation
    Dependency:
      title: Dependency
      x-stoplight:
        id: 9i3us044e6i0o
      type: object
      properties:
        id:
          type: string
      x-tags:
        - dependency
      examples:
        - id: string
    Description:
      title: Description
      x-stoplight:
        id: 8c1akpli341fd
      type: object
      x-tags:
        - description
      properties:
        id:
          type: string
          format: uuid
        localisedName:
          type: string
          description: 'This key is an opportunity to localise the name in a specific language. It contains the (short) public name of the product. It should be the name most people usually refer to the software. In case the software has both an internal “code” name and a commercial name, use the commercial name.'
          example: Medusa
        shortDescription:
          type: string
          maxLength: 150
          description: This key contains a short description of the software. It should be a single line containing a single sentence. Maximum 150 characters are allowed.
          example: Advanced booking system for hospitals
        longDescription:
          type: string
          description: |-
            This key contains a longer description of the software, between 150 and 10000 chars. It is meant to provide an overview of the capabilities of the software for a potential user. The audience for this text should be that of users of the software, not developers. You can think of this text as the description of the software that would be in its website (if the software had one).

            This description can contain some basic markdown: *italic*, **bold**, bullet points and [links](#).
          maxLength: 10000
        documentation:
          type: string
          description: |-
            This key contains a reference to the user-level (not developer-level) documentation of the software. The value must be a URL to a hosted version of the documentation.

            It is suggested that the URL points to a hosted version of the documentation that is immediately readable through a common web browser in both desktop and mobile format. The documentation should be rendered in HTML and browsable like a website (with a navigation index, a search bar, etc.).

            If the documentation is instead available only as a document, put a direct view/download link as URL in this key. You should commit the document as part of the source code repository, and then link to it using the code hosting source browser URL (e.g.: GitHub URL to the file). Prefer using open formats like PDF or ODT for maximum interoperability.

            Whichever the format for the documentation, remember to make its source files available under an open license, possibly by committing them as part of the repository itself.
          format: url
        apiDocumentation:
          type: string
          description: |-
            This key contains a reference to the API documentation of the software. The value must be a URL to a hosted version of the documentation.

            It is suggested that the URL points to a hosted version of the documentation that is immediately readable through a common web browser. The documentation should be rendered in HTML and browsable like a website (with a navigation index, a search bar, etc.), and if there is a reference or test deployment, possibly offer an interactive interface (e.g. Swagger).

            If the documentation is instead available only as a document, put a direct view/download link as URL in this key. You should commit the document as part of the source code repository, and then link to it using the code hosting source browser URL (e.g.: GitHub URL to the file). Prefer using open formats like PDF or ODT for maximum interoperability.

            Whichever the format for the documentation, remember to make its source files available under an open license, possibly by committing them as part of the repository itself.
          format: url
        features:
          description: |-
            This key contains a list of software features, describing what capabilities the software allows to do. The audience for this text should be that of public decision makers who will be commissioning the software. The features should thus not target developers; instead of listing technical features referring to implementation details, prefer listing user-visible functionalities of the software.

            While the key is mandatory, there is no mandatory minimum or maximum number of features that should be listed in this key.

            The suggested number of features to list is between 5 and 20, depending on the software size and complexity. There is no need for exhaustiveness, as users can always read the documentation for additional information.
          type: array
          items:
            type: string
        screenshots:
          type: array
          description: |-
            This key contains one or multiple paths to files showing screenshots of the software. They are meant to give a quick idea on how the software looks like and how it works. The key value can be the relative path to the file starting from the root of the repository, or it can be an absolute URL pointing to the screenshot in raw version. In both cases, the file must reside inside the same repository where the publiccode.yml file is stored.

            Screenshots can be of any shape and size; the suggested formats are:

            - Desktop: 1280x800 @1x
            - Tablet: 1024x768 @2x
            - Mobile: 375x667 @2x
          items:
            type: string
        videos:
          description: |-
            This key contains one or multiple URLs of videos showing how the software works. Like screenshots, videos should be used to give a quick overview on how the software looks like and how it works. Videos must be hosted on a video sharing website that supports the oEmbed standard; popular options are YouTube and Vimeo.

            Since videos are an integral part of the documentation, it is recommended to publish them with an open license.
          type: array
          items:
            type: string
            format: url
        awards:
          description: A list of awards won by the software.
          type: array
          items:
            type: string
            format: url
      required:
        - features
    Organisation:
      title: Organisation
      x-stoplight:
        id: n9bmvlkld52vx
      type: object
      description: '[extension of the publiccode standard] [extension of  the klanten API organisatie object] '
      examples:
        - id: string
          name: string
          description: string
          logo: 'http://example.com'
          supports:
            - 497f6eca-6276-4993-bfeb-53cbbbba6f08
          owns:
            - 497f6eca-6276-4993-bfeb-53cbbbba6f08
          uses:
            - 497f6eca-6276-4993-bfeb-53cbbbba6f08
          token: string
          github: string
          gitlab: string
          website: string
          phone: string
          email: string
      properties:
        id:
          type: string
        name:
          type: string
        description:
          type: string
        logo:
          type: string
          format: uri
          description: The logo of this organisation
        supports:
          type: array
          uniqueItems: true
          description: A list of  components supported by this organisation
          items:
            type: string
            format: uuid
        owns:
          type: array
          uniqueItems: true
          description: A list of  components supported by this organisation
          items:
            type: string
            format: uuid
        uses:
          type: array
          uniqueItems: true
          description: A list of  components supported by this organisation
          items:
            type: string
            format: uuid
        token:
          type: string
          description: An optional NL-Design token that contains the organisations style
        github:
          type: string
          format: url
          description: 'A link the the organisations github '
        gitlab:
          type: string
          format: url
          description: A link to the organisations gitlab
        website:
          type: string
        phone:
          type: string
        email:
          type: string
        type:
          type: string
          enum:
            - public
            - private
            - unkown
          example: public
          description: The type of this organisation
        catalogusAPI:
          type:
            - string
            - 'null'
          format: uri
    Rating:
      title: Rating
      x-stoplight:
        id: jx42f4gh3wm7u
      type: object
      properties:
        id:
          type: string
        rating:
          type: integer
        maxRating:
          type: integer
        results:
          type: array
          items:
            type: string
    Repository:
      title: Repository
      x-stoplight:
        id: ugq6xzv7o1vlt
      type: object
      properties:
        id:
          type: string
          format: uuid
        organisation:
          $ref: '#/components/schemas/Organisation'
        component:
          $ref: '#/components/schemas/Component'
        source:
          type: string
          enum:
            - github
            - gitlab
        name:
          type: string
        url:
          type: string
        avatar_url:
          type: string
        last_change:
          type: string
        stars:
          type: number
        fork_count:
          type: number
        issue_open_count:
          type: number
        merge_request_open_count:
          type: number
        programming_languages:
          type: array
          items: {}
        topics:
          type: array
          items: {}
        content:
          type: string
        publiccode_url:
          type: string
        default_owner:
          type: string