.. This work is licensed under a Creative Commons Attribution 4.0 International License.
.. http://creativecommons.org/licenses/by/4.0
.. _offeredapis:

================
SDC Offered APIs
================

The list of APIs that SDC offers can be found from the following table:

.. csv-table::
   :header: "API name", "OpenAPI JSON", "OpenAPI YAML"
   :widths: 10,5,5

   "SDCE-1", ":download:`link <openapi/openapi-sdce-1.json>`", ":download:`link <openapi/openapi-sdce-1.yaml>`"
   "SDCE-2 & SDCE-5", ":download:`link <openapi/openapi-sdce-2-sdce-5.json>`", ":download:`link <openapi/openapi-sdce-2-sdce-5.yaml>`"
   "SDCE-4", ":download:`link <openapi/openapi-sdce-4.json>`", ":download:`link <openapi/openapi-sdce-4.yaml>`"
   "SDCE-6", ":download:`link <openapi/openapi-sdce-6.json>`", ":download:`link <openapi/openapi-sdce-6.yaml>`"
   "SDCE-7", ":download:`link <openapi/openapi-sdce-7.json>`", ":download:`link <openapi/openapi-sdce-7.yaml>`"
