tree fc8628575130e8428a23b2b9b1db7a251e1c73f8
parent b1fc8c337d3b9750eff6e62b626c0bc3a1467a88
author MichaelMorris <michael.morris@est.tech> 1616067648 +0000
committer MichaelMorris <michael.morris@est.tech> 1616197445 +0000

Publish swagger files for SDC APIs

I have created a swagger file for each of the APIs as they are currently listed on the architecture page. Some of the files can be easily be combined if some of the APIs are combined. I have created a single file for SDCE-2 and SDCE-5 as it is not possible to seperate as they are both paritially implemented in the same class with overlapping paths

I have copied the generated swagger files to the docs directory as I suspect they need to be under source control for the generation of the readthedocs page

Signed-off-by: MichaelMorris <michael.morris@est.tech>
Issue-ID: SDC-3525
Change-Id: Id42412704311a573e3ebf911ad34d909c1c3f1b2
