Map current documentation to new structure

docs/apis/delivery-service.mdx

 ---
-title: Zustelldienst
+title: Zustelldienst-API
 ---
 import ApiSpec from '../../src/components/ApiSpec'
 
-<ApiSpec />
\ No newline at end of file
+<ApiSpec specUrl="https://fitko.uber.space/v1.0.0-alpha12/zustelldienst.yml"/>
\ No newline at end of file

docs/apis/routing.mdx

+# Routing-API
+
+> Für diesen Dienst ist die API-Spezifikation noch ausstehend!
+
+import ApiSpec from '../../src/components/ApiSpec'
+
+<ApiSpec specUrl="https://restapi-v3-st.zfinder.de/swagger.json"/>

docs/authentication.md

 # Registrierung und Client-Verwaltung
 
-Der bisherige Proof of Concept ist ausgelaufen und FIT-Connect wird nun als Projekt des IT-Planungsrats aufgebaut. Im Rahmen der Projektumsetzung wird die aktuelle API finalisiert und technisch umgesetzt.
-
-Bei Interesse an einem Zugang zu einem Testsystem zur technischen Evaluierung der Anbindung von Fachverfahren und Onlinediensten an FIT-Connect melden Sie sich gerne unter fit-connect@fitko.de.
-
-## Hinweise zum Aufruf der API mit OAuth2
-
-Um das von ihnen gewünschte API im Rahmen ihrer Anwendung aufzurufen, Gehen sie wie folgt vor:
-
-![API Zugriff](https://raw.githubusercontent.com/fiep-poc/assets/master/images/oauth/13_api_zugriff.png)
-
-Verfahrensschritte:
-
-1) Die Clientanwendung sendet die Authentifizierungsanforderung an den Autorisierungsserver, um ein Zugriffstoken zu erhalten.
-
-2) Der Autorisierungsserver überprüft die Anforderung und generiert ein Zugriffstoken für den Client.
-
-3) Der Client verwendet dieses Zugriffstoken, um HTTP-Anforderungen an das API-Gateway zu senden.
-
-4) Das API-Gateway führt dann folgendes aus:
-    - Identifiziert die Anwendung anhand der client_Id.
-    - Überprüft das Token lokal oder remote, wenn es lokal nicht möglich ist.
-    - Überprüft, ob die angeforderte Ressource Teil des Bereichs im Token ist.
-
-Wurden alle Prüfschritte erfolgreich absolviert, wird die Anfrage an den Zustelldienst übergeben.
-
-Nach Bearbeitung der Anfrage im Zustelldienst wird die Antwort des Zustelldienstes an den Client zurückgesendet.
-
-FÜr nähere Details und Beispiele siehe:
-➡ [OAuth](./Detailinformationen/OAuth.md)
-
+- Doku zur Nutzung von OAuth und ggf. Nutzung des Self-Service-Portals bzw. Kontaktmöglichkeiten

docs/event-log.mdx

+# Eventlog
+
+TBD
+
+> Ein neuer Artikel aber nochmal etwas zielgerichteter und knackiger die Verwertung und den Nutzen für die API-Nutzer beschreiben. Ebenfalls sollte man dann auch die Verarbeitung der des Log mit kurzen Beispielen/technischen Erläuterungen beschreiben (Erläuterungen Validierung von einzelner Claims und der Signatur, Hinweis das der Log ein Array aus JWTs mit Compact Serialization mit Base64 ist, weshalb jedes Objekt entnommen und dekodiert werden muss, etc.).
\ No newline at end of file

docs/getting-started/account.mdx

+# OAuth Authentifizierung
+
+- Abgleichen mit Dokumentation von Lilith, ob Code-Beispiele vorhanden, ansonsten kann das weg
+
+Das folgende Dokument beschreibt wie die OAuth-basierte Authentifizierung mithilfe des FIT-Connect Commandline-Tools funktioniert. Dafür werden entweder OAuth-Credentials (Client-ID, Client-Secret) sowie die Adresse des OAuth-Token-Endpunktes oder ein Zugang zum FIT-Connect Developer Portal benötigt. Weitere Informationen dazu wie die OAuth-Authentifizierung selbst implementiert werden kann befinden sich in [Authentifizierung von Fachanwendungen](Authentifizierung_von_Fachanwendungen.md) und [Authentifizierung von Usern an Zustelldiensten](Authentifizierung_von_Usern.md) - außerdem ist hier das Konzept zu [Zustellberechtiungs-Scopes](Zustellberechtigungs-Scopes.md) zu beachten.
+
+## Installation CLI-Tool
+
+Das CLI-Tool kann über den Python Paketmanager pip installiert werden. Dafür muss Python 3.6 oder neuer installiert sein.
+
+```bash
+pip install fitconnect-cli
+```
+
+Nach der Installation von fitconnect-cli kann mithilfe des folgenden Kommandos eine neue FIT-Connect API-Konfiguration angelegt werden.
+
+```bash
+ fitconnect create_config --config=test_sender.json  
+```
+
+Hierbei muss ausgewählt werden, ob ein Sende- oder Empfangsdienst betrieben werden und ob automatisch RSA-Keys für die Generierung von JWTs angelegt werden sollen.
+
+```bash
+ fitconnect create_config --config=test_sender.json  
+? Do you want to setup a config for a sender (e.g. onlineservice) or receiver?  sender
+? Oauth Token URL:  https://fit-connect.de/oauth/token
+? Client id:  nnXVC6DSPG9BkoMw5NXOur4RPOkEpLMMwYFbycIo
+? Client secret:  Yj9PduOSsjGzwsIDXGRLrzDarZdKE4QPXuil21FqJGlVnZTDqcM7S5FruJA4kv1L3K4PCmAqAuK11y2fwu2MDVBiDUgWTBLc1e3H8tV0sD5PzlEiV7nCUAYBP7u8tG01
+? Do you want to create a jwt signature key?  yes
+-----BEGIN PUBLIC KEY-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAv6ixhhwQm8nTAAtgSBRP
+gNUuucb4e9Y0G2n8SBy4aEflIfrqKqqM1LRzLLnqvFiiiXI8heTx6AvMjQsqScHt
+0SDONWliz2s+lA80xyW+nJRKI/WUxXOZX0xqQD8XL6ZksE+nhZ9bKo7o5lXwQF6C
+p3BGV30kPgfGOCNPg4P5QpsP9UUfGvz1OXNNUPoMKovyXHAd7k4gI6TWZSqCbJwG
+3Y3v7WZKIb/1PGhkc7oR+SJ3t0jYJByRnhTyQAoMpODBlPz27/MOkozoNaAkjf6b
+pKcnasYCJHkuAcCS7pI5VZz7YNZPl3dm0g4woOsJeEdV2B2fyv4E0uYw2eRFsxlu
+/TdAid6UAf1fMz4JVoJ3dsca+1zySX7S4P+pVjNXQW0cGVO4hksvQSFwhBpnEAEw
+rHBdVV15UVT98cFEfhlv3utI6KdXJqpnWBm8g9K3tFSAoTNXz81XAnFnZgLqA4If
+bws0R7Zu8fXYMQuGS2APzhH4QWVcqrgWizzg0P39W0f+44DIUgc6LJ344Iog3f2j
+ix3WeKi/VrKfJCLCisZyDUJNze9WfWVersGVMsgnND84y9+EG2Pp/m99jF+asrDi
+gJa7FZjjoXRJVhTBcGQ1eW95G+Vm/oKkAp+unFBCqNtS610vQzviM147KtIvUrpj
+q1r1v0Vzj+qk9WEGVz/Gl4MCAwEAAQ==
+-----END PUBLIC KEY-----
+```
+
+Nachdem der Assistent abgeschlossen wurde, sollte im aktuellen Verzeichnis eine JSON-Datei mit allen benötigten Konfigurationen angelegt worden sein. Diese lässt sich nun mit einem FIT-Connect-API-Client oder dem fitconnect-cli weiterbenutzten.
+
+## Generierung von JWTs
+
+Mithilfe der fitconnect-cli können JWTs zum Abrufen von bzw. Versenden von Anträgen generiert werden. Dabei wird zuerst über das OAuth 2 Client Credentials Verfahren ein JWT abgerufen und dann falls Antreäge versendet werden sollen der sogenannte Online-Service-Token mit eingeschränkten Berechtigungen davon abgeleitet.
+
+### Abrufen von JWTs für antragssendene Systeme (Onlineservices)
+
+Für die Generierung von JWTs zum Versenden von Anträgen muss neben der Konfiguration außerdem über den Parameter *destination* angegeben werden, an welche Destination-IDs Anträge gesendet werden sollen. 
+
+```bash
+fitconnect get_jwt --config=test_sender.json --destination "d771f1d8-6967-4740-9668-82c5a910a29b"
+```
+
+Bei erfolgreicher Generierung erhält man ein JSON-Objekt mit einem User-Token und einen Online-Service-Token zurück. Diese können dann dazu verwendet werden um mithilfe eines  FIT-Connect-API-Client oder CURL einen Antrag versenden. 
+
+```json
+{
+    "online-service-token": "..online-service-token...",
+    "token": "...token..."
+}
+```
+
+Der dekodierte Inhalt eines Online-Service-Tokens sieht z.B. so aus:
+
+```json
+{
+  "iss": "FITCONNECT",
+  "exp": 1623275003,
+  "iat": 1623260603,
+  "domains": [],
+  "publicKey": {
+    "n": "...RSA Token...",
+    "e": "AQAB",
+    "kty": "RSA"
+  },
+  "scope": [
+    "leika:991080082520",
+    "region:03254021",
+    "leika:991080082520+region:03254021"
+  ],
+  "clientType": "sender"
+}
+```
+
+Und der eines Tokens so:
+
+```json
+{
+  "iss": "Onlineservice",
+  "exp": 1623267803,
+  "iat": 1623260603,
+  "domains": [],
+  "scope": [
+    "destination:d771f1d8-6967-4740-9668-82c5a910a29b"
+  ],
+  "clientType": "user-sender"
+}
+```
+
+Ein CURL-Request um dann mit diesen Tokens auf die API zuzugreifen, könnte z.B. so aussehen:
+
+```bash
+curl -i -H "Accept: application/json" -H "Content-Type: application/json" -H "token: ...token..."  -H "online-service-token:  ...online-service-token..." https://fit-connect-url.einfügen
+```
+
+### Abrufen von JWTs für antragsempfangende Systeme (Fachverfahren / virtuelle Poststellen
+
+Wenn ein JWT zum Abrufen von Anträgen generiert werden soll, kann auf den Parameter destination verzichtet werden.
+
+```bash
+fitconnect get_jwt --config=test_receiver.json 
+```
+
+Als Antwort erhält man einen (vom Authentifizierungsserver via OAuth Client Credentials abgerufenen) JWT, welchen man zur Authentifizierung beim Abrufen von Anträgen verwenden kann.
+
+```bash
+curl -i -H "Accept: application/json" -H "Content-Type: application/json" -H "token: ...token..."  https://fit-connect-url.einfügen
+```

docs/getting-started/authentication/applications.mdx

+# Authentifizierung von Fachanwendungen
+
+**=> Beschreibt Zielkonzept, aber nich von v1, dadurch in Konzeption-Repo verschieben**
+
+Fachanwendungen haben die Möglichkeit FIT-Connect Anträge abzurufen. Dafür müssen sie sich mithilfe von oauth2 "Client-Credentials" authentifizieren. Diese erhalten Behörden und andere Abrufberechtigte, nach einer Anmeldung im Self-Service-Portal der FITKO. (TODO: link) 
+
+Für jede Destination müssen folgende Informationen im Self-Service-Portal bereitgestellt werden
+
+Entweder:
+
+- Liste der [LeiKa-IDs](https://www.it-planungsrat.de/DE/Projekte/Anwendungen/LeiKaPlus/leiKaPlus.html) und [Amtlicher Gemeindeschlüssel](https://www.statistikportal.de/de/gemeindeverzeichnis)
+
+Oder:
+
+- Name und Bezeichung der angeboteten Leistungen, wenn diese nicht Teil des Leistungskataloges sind
+
+Außerdem
+
+- Der Public Key zur Verschlüsselung der Antragsdaten
+- Der Public Key der Fachanwendung zur Signaturprüfung
+- Callback Endpunkte
+- Referenzen zu allen von diesem Endpunkt unterstützen Schemas
+
+Nach anlegen einer Destination erhält die Behörde, die für die Destination verantwortlich ist die OAuth Client Credentials. Mit diesen kann sich das Fachverfahren authentifizieren und erhält dafür einen JWT. Mit diesem JWT ist dann ein Abruf der hinterlegten Anträge möglich
+
+
+
+<img src="../../assets/images/oauth/JWT-Konzept-Fachanwendung.png" alt="JWT Konzept" width="400"/>
+
+### Anforderung an die JWT-Tokens
+
+Die vom Auth Server generierten JWTs müssen nach [RFC 7519](https://tools.ietf.org/html/rfc7519) über folgende Attribute verfügen:
+
+#### Header
+
+Entsprechend [RFC 7519 Abschnnitt 8](https://tools.ietf.org/html/rfc7519#section-8):
+
+| Feld | Inhalt | **Erläuterung**                           |
+| ---- | ------ | ----------------------------------------- |
+| typ  | JWT    | Es handelt sich um einen JWT.             |
+| alg  | RS512  | Der JWT verwendet RSASSA-PSS und SHA-512. |
+
+**Beispiel**
+
+```json
+{
+  "typ":"JWT",
+  "alg":"HS256"
+}
+```
+
+#### Body des User-JWT-Tokens
+
+Entsprechend den [standartisierten Feldern](http://www.iana.org/assignments/jose/jose.xhtml#web-signature-encryption-algorithms):
+
+| Feld       | Inhalt                                | **Erläuterung**                                              |
+| ---------- | ------------------------------------- | ------------------------------------------------------------ |
+| iat        | Unix Timestamp                        | Zeitpunkt wann der Token ausgestellt wurde als Unix Timestamp. |
+| exp        | Unix Timestamp                        | Zeitpunkt wann der Token abläuft als Unix Timestamp (Token sollte max. 2 Stunden gültig sein vgl [BSI APP.3.1](https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Grundschutz/Kompendium_Einzel_PDFs/06_APP_Anwendungen/APP_3_1_Webanwendungen_Edition_2020.pdf?__blob=publicationFile&v=1)). |
+| scope      | Liste von Zustellberechtigungs-Scopes | Eine Liste der Zustellberechtigungs-Scopes, für die der JWT einen Abruf erlaubt. |
+| clientType | subscriber                            | Gibt an, das es sich um einen Token für ein antragsempfangendes System (Fachanwendung oder virtuelle Poststelle) handelt. |
+
+**Beispiel**
+
+```json
+{
+  "iat":"1620072619",
+  "exp":"1620079819",
+  "scope": ["36141427-d405-40a4-8f8b-3592d544e85b", "655c6eb6-e80a-4d7b-a8d2-3f3250b6b9b1"],
+  "clientType": "subscriber"
+}
+
+```
+
+## Validierung der JWT-Tokens durch den Zustelldienst
+
+Beim Abruf am Zustelldienst muss dieser bzw. das API-Gateway überprüfen, ob der JWT-Token valide ist. Dafür sollten mindestes folgende Überprüfungen durchgeführt werden:
+
+1. Überprüfen, ob es sich um einen JWT mit einer **RSASSA-PSS (PS512)** Signatur handelt.
+2. Überprüfen, ob der JWT noch gültig ist.
+3. Überprüfen, ob der JWT für max. 4h ausgestellt wurde.
+3. Mithilfe des Public Keys des Authentifizierungsservers die Signatur des JWT überprüfen. 
+4. Überprüfen, ob die Destination-ID, die abgerufen werden soll teil der in den Zustellberechtigungs-Scopes (**scope** Parameter in den JWTs) des JWTs ist. (Zugangsberechtigung der Fachanwendung). 
+

docs/getting-started/authentication/users.mdx

+# Authentifizierung von Usern an Zustelldiensten
+
+**=> Beschreibt Zielkonzept, aber nich von v1, dadurch in Konzeption-Repo verschieben**
+
+Jeder Onlineantragsdienst muss bei FIT-Connect registriert sein, um FIT-Connect Formulare darstellen und übermitteln zu können. Bei der Registrierung von Onlinediensten wird festgelegt, welche Anträge die Onlinedienste auf welchen Domains ausspielen dürfen. Im Rahmen dieses Prozesses wird für jeden Onlinedienst außerdem ein Public Key hinterlegt. Nach der Anmeldung erhält jeder Onlineantragsdienst OAuth2-Credentials für den Authentifizierungstyp "Client-Credentials".
+
+Eine Registrierung eines Onlinedienstes ist über das Self-Service-Portal der FITKO möglich. (TODO: link) Dort müssen folgende Informationen über einen Onlinedienst hinterlegt werden:
+
+- Freigegebene Domains, von denen der Onlinedienst Formulare übermittelt.
+- Erlaubte Zustellberechtigungs-Scopes, an die Anträge übermittelt werden dürfen.
+- Ein Public Key des Onlinedienstes, die er für die Erstellung von JWTs benutzt.
+
+Wenn ein Onlinedienst einem User ermöglichen möchte, einen Antrag zu übermitteln, muss er mithilfe seiner Client-Credentials beim FIT-Connect-Authentifizierungsserver einen JWT-Access-Token (Onlinedienst-Token) abrufen. Dieser Onlinedienst-Token enthält den Public-Key, der für den Onlinedienst bei der Anmeldung festgelegt wurde, im signierten Datensatz.
+
+Nun muss der Onlinedienst auf Basis des zum Public Key gehörenden Private Key einen weiteren JWT Token (User-Token) erzeugen, der Informationen dazu enthält, das der Onlinedienst dem User erlaubt, einen Antrag an eine spezifische Destinationen zu übermitteln. 
+
+Wenn der User nun einen Antrag an den Onlinedienst übermittelt, muss dieser sowohl den User-Token als auch den Onlinedienst-Token im Header mitübermitteln. Mithilfe der beiden Tokens kann das FIT-Connect API-Gateway nachvollziehen, von wo ein Antrag zu welcher Destination übermittelt wird und kann somit überprüfen, ob der User/Onlinedienst dafür autorisiert ist.
+
+<img src="../../assets/images/oauth/JWT_konzept.png" alt="JWT Konzept" width="400"/>
+
+### Warum ist die anonyme Authentifizierung notwendig?
+
+Im Rahmen von FIT-Connect soll das massenhafte absenden (spammen) von Anträgen über Ratelimiting verhindert werden und es sollen nur vertrauenswürdige Webseiten, die dem FIT-Connect-Standards entsprechen, die Möglichkeit bekommen, Anträge über FIT-Connect zu übermitteln. Um diese Maßnahmen umsetzen und einen User über mehrere Requests hinweg sicher identifizieren zu können, ist eine Form der anonymen Authentifizierung notwendig.
+
+## Generierung der JWT-Tokens
+
+Jedes Backend eines FIT-Connect Onlineantragsdienstes muss über ein System verfügen, welches JWT-Tokens für diese Instanz erzeugen und an den Browser des Users übermitteln kann. Es sollte dabei eine geeignete Form von Rate-Limiting, für die Ausstellung der Public Keys passend zum Usecase des Onlinedienstes implementieren. Es sollte die Menge der mit einem JWT-Token freigegebenen Destinationen minimieren. **Es dürfen in denen vom Onlineservice generierten JWT-Tokens keinen Informationen hinterlegt werden, die zur Identifikation des Users führen könnten.**
+
+### Anforderungen an die Keypairs
+
+Der Onlinedienst muss zur Registrierung bei FIT-Connect neben den Angaben dazu, welche Destinationen er unter welchen Domains verwendenden möchte, auch noch einen Public Key eines Keypairs, das nach folgenden Standards erzeugt wurde, übermitteln:
+
+| Feld               | Inhalt     | **Erläuterung**                                              |
+| ------------------ | ---------- | ------------------------------------------------------------ |
+| Hashingalgorithmus | SHA-512    | Algorithmus der zur digitalen Signatur des Keys verwendet werden muss an. Dieser muss im Fall von FIT-Connect immer SHA-512 sein. (vgl. [BSI TR-02102-1 Tabelle 4.1](https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Publikationen/TechnischeRichtlinien/TR02102/BSI-TR-02102.html)) |
+| Keylänge           | 4096       | Länge des zugrundeliegenden RSA-Keys. Diese entspricht der Empfehlung des BSIs für ab dem Jahr 2023. (vgl. [BSI TR-02102-1 Tabelle 3.1](https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Publikationen/TechnischeRichtlinien/TR02102/BSI-TR-02102.html)) |
+| Signaturstandard   | RSASSA-PSS | Entspricht dem Standard beschrieben in [RFC 4056](https://tools.ietf.org/html/rfc4056)  und vom BSI empfohlen in [BSI TR-02102-1 Abschnitt 5.4.1.](https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Publikationen/TechnischeRichtlinien/TR02102/BSI-TR-02102.html) |
+
+Bei der Erstellung und Signierung des Keys sind alle Regeln und Standards aus BSI [TR-02103](https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Publikationen/TechnischeRichtlinien/TR02103/BSI-TR-02103.pdf?__blob=publicationFile&v=4) zu beachten. 
+
+### Anforderung an die JWT-Tokens
+
+Die vom Onlinedienst generierten JWT-Tokens müssen nach [RFC 7519](https://tools.ietf.org/html/rfc7519) über folgende Attribute verfügen:
+
+#### Header
+
+Entsprechend [RFC 7519 Abschnnitt 8](https://tools.ietf.org/html/rfc7519#section-8):
+
+| Feld | Inhalt | **Erläuterung**                                 |
+| ---- | ------ | ----------------------------------------------- |
+| typ  | JWT    | Es handelt sich um einen JWT-Token.             |
+| alg  | RS512  | Der JWT Token verwendet RSASSA-PSS und SHA-512. |
+|      |        |                                                 |
+
+**Beispiel**
+
+```json
+{
+  "typ":"JWT",
+  "alg":"PS512"
+}
+```
+
+#### Body des User-JWT-Tokens
+
+Entsprechend den [standartisierten Feldern](http://www.iana.org/assignments/jose/jose.xhtml#web-signature-encryption-algorithms):
+
+| Feld       | Inhalt                    | **Erläuterung**                                              |
+| ---------- | ------------------------- | ------------------------------------------------------------ |
+| iat        | Unix Timestamp            | Zeitpunkt wann der Token ausgestellt wurde als Unix Timestamp. |
+| exp        | Unix Timestamp            | Zeitpunkt wann der Token abläuft als Unix Timestamp (Token sollte max. 2 Stunden gültig sein vgl [BSI APP.3.1](https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Grundschutz/Kompendium_Einzel_PDFs/06_APP_Anwendungen/APP_3_1_Webanwendungen_Edition_2020.pdf?__blob=publicationFile&v=1)). |
+| scope      | Liste von Destination-IDs | Eine Liste der Destination-IDs (im Stile der Zustellberechtigungs-Scopes geprefixed), für die der JWT eine Übermittlung erlaubt. |
+| sid        | UUID4 der Session         | Eine unique ID zur Identifizierung der Session (muss garantiert für jede Übermittlung anders sein) |
+| iss        | ID des Onlinedienstes     | Wird bei der Anmeldung des Onlinedienstes festgelegt und dient zur Identifizierung am API-Gateway |
+| domains    | Liste von Domains         | Eine Liste der Domains, von denen der Onlineservice Anträge übermitteln kann.  Sie muss einem Subset der Domains entsprechen, die im domains Feld des Onlinedienst-JWT angegeben wurden. (Subdomains müssen explizit angegeben werden) |
+| clientType | user-sender               | Gibt an, das es sich um denn abgeleiteten User Token eines Onlineservices handelt,  mit dem Anträge eingereicht werden können. |
+
+**Beispiel**
+
+```json
+{  
+	"iat":"1620072619",  
+	"exp":"1620079819",
+	"scope": ["destination:655c6eb6-e80a-4d7b-a8d2-3f3250b6b9b1"],
+	"sid": "8d4dcbfd-a528-4e9b-abc3-477c4cc857aa",
+	"iss": "639c5be8-eb9c-4741-834e-4ad11629898a",
+  "clientType": "user-sender",
+}
+
+```
+
+#### Body des Onlinedienst-JWT-Tokens
+
+Entsprechend den [standartisierten Feldern](http://www.iana.org/assignments/jose/jose.xhtml#web-signature-encryption-algorithms):
+
+| Feld       | Inhalt                                | **Erläuterung**                                              |
+| ---------- | ------------------------------------- | ------------------------------------------------------------ |
+| iat        | Unix Timestamp                        | Zeitpunkt wann der Token ausgestellt wurde als Unix Timestamp. |
+| exp        | Unix Timestamp                        | Zeitpunkt wann der Token abläuft als Unix Timestamp (Token sollte max. 24 Stunden gültig sein vgl [BSI APP.3.1](https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Grundschutz/Kompendium_Einzel_PDFs/06_APP_Anwendungen/APP_3_1_Webanwendungen_Edition_2020.pdf?__blob=publicationFile&v=1)). |
+| scope      | Liste von Zustellberechtigungs-Scopes | Eine Liste der Zustellberechtigungs-Scopes oder Präfixes, für die der JWT eine Übermittlung erlaubt. |
+| publlicKey | Public Key des Onlinedienstes         | Der Public Key, der dem Onlinedienst bei der Anmeldung zugeordnet wurde im JWK Format nach [RFC-7517](https://tools.ietf.org/html/rfc7517) |
+| aud        | ID des Onlinedienstes                 | Wird bei der Anmeldung des Onlinedienstes festgelegt und dient zur Identifizierung des Onlineservices |
+| domains    | Liste von Domains                     | Eine Liste der Domains, von denen der Onlineservice Anträge übermitteln kann. (Subdomains müssen explizit angegeben werden) |
+| clientType | sender                                | Gibt an, das es sich um einen Token für einen Onlineservice handelt, der Anträge versenden kann. |
+
+**Beispiel**
+
+```json
+{  
+	"iat":"1620072619",  
+	"exp":"1620079819",
+	"scope": ["leika:99108008252000", "leika:99108008252000+region:08110000"],
+  "clientType": "sender",
+	"publicKey": {
+    "kty": "RSA",
+    "e": "AQAB",
+    "key_ops": ["verify"],
+    "alg": "PS512",
+    "n": "...Public Key..."
+  },
+  "aud": "639c5be8-eb9c-4741-834e-4ad11629898a",
+  "domains": ["example.com", "sub.example.com"]
+}
+
+```
+
+## Validierung der JWT-Tokens durch die Sender-API/API-Gateway
+
+Bei jedem eingegangen Antrag muss der JWT-Token des Users validiert werden, um so Missbrauch der Antragsübermittlungsschnittstelle zu verhindern und nur korrekt implementierten FIT-Connect-Clients Zugang zur Antragsübermittlung zu geben.
+
+Nach dem Anlegen eines Antragsübertragungsprozesses kann auf diesen nur mit JWT-Tokens von demselben Onlinedienst und mit derselben Session-ID zugegriffen werden.	
+
+Das API-Gateway muss die JWT-Tokens validieren:
+
+1. Überprüfen ob es sich um einen JWT mit einer **RSASSA-PSS (PS512)** Signatur handelt.
+2. Überprüfen, ob diese noch gültig sind und
+   1.  der User-JWT-Token maximal für 2h ausgestellt wurde.
+   2. der Onlinedienst-JWT-Token für max. 24h ausgestellt wurde.
+3. Mithilfe des Public Keys des Authentifizierungsservers die Signatur des Onlinedienst-JWT überprüfen. 
+4. Mithilfe des im JWT-Token des Onlinedienst enthaltenen Public Key die Signatur des User JWT überprüfen
+5. Überprüfen, ob die Destination-ID teil der in den Zustellberechtigungs-Scopes (**scope** Parameter in den JWT Tokens) beider JWT-Tokens ist. (Zugangsberechtigung des Onlinedienstes und des Users). Bzw. ob die LeiKa/Region entsprechend der Destination freigegeben ist.
+6. Überprüfen, ob die Website (origin), von der der Antrag abgesendet wurde, im domain Feld beider JWKs verzeichnet ist. (Verhindern von gefälschten Onlinediensten, die nicht den FIT-Connect-Standards entsprechen)
+7. Das API-Gateway kann aufgrund der folgenden Parameter Rate-Limiting für API-Calls (angepasst an die jeweiligen Use Cases des Onlineservices) betreiben:
+
+- sid
+- IP-Addresse des Users
+- Website von der der Antrag übermittelt wird bzw. das Fehlen eines Referers
+- Onlineservice-ID

docs/getting-started/overview.mdx

+# Überblick
+
+## ① Account registrieren
+
+> Registrieren Sie sich für ein Zugriff, um mit Ihren Client auf die API zuzugreifen. Im Rahmen der Registrierung bekommen Sie für die gewünschte API die Client-ID und Zugriffdaten mitgeteilt. Da zum aktuellen Zeitpunkt keine Sandbox Umgebung bereitstellt, wird empfohlen, sich für beide Seiten zu registieren, um für komplexere Tests mit einem REST Client die API der Gegenseite anzusprechen (Siehe Postman Nutzung in Schritt 2). ➡ [Registrierung zur API Nutzung](./4_Authentifizierung_und_Autorisierung.md)
+
+## ② API ausprobieren
+
+> In der Navigation auf linken Seite finden Sie die jeweiligen API Referenzen für die Nutzung der APIs unter den Reitern `Application Sender API` und `Application Subscriber API`
+Für einen einfachen Einstieg zum Test der API können Sie die bereitgestellte Postman Collection nutzen und mit dem Postman REST Client die Anfragen an die API durchführen. Hiermit können Sie auch die Gegenseite (Sender oder Empfänger von Anträgen simulieren) (➡ [Testen mit Postman](./Detailinformationen/Postman.md). Nähere Informationen zu Postman siehe <https://www.postman.com/>)
+Alternativ können Sie die Anfragen auch mittels eigener Anwendungen oder alternativer REST Clients durchführen.
+
+## ③ OAuth Token vor der API Nutzung abrufen
+
+> Für jede Anfrage an die API Endpunkte ist ein gültiger JWT-Token mit der Anfrage mitzusenden. Für nähere Informationen zum Abruf eines JWT-Token siehe ➡ [OAuth Details](./Detailinformationen/OAuth.md)
+
+## ④ Spezifikation lokal nutzen
+
+> Sofern Sie einen lokalen Zugriff auf die Quellen der Spezifikation im OpenAPI Format (bspw. für Code Generatoren) benötigen, finden Sie diese hier: ➡[FIT-Connect-API-Spec.yml](https://fitko.uber.space/API_VERSION/zustelldienst.yml)
+
+## Beispiel mit `curl`
+
+Token holen und in `$TOKEN` speichern:
+
+```bash
+TOKEN=$(curl --silent --location --request POST https://sender-test-token.fiep-poc.de/auth/realms/test/protocol/openid-connect/token \
+--header 'Content-Type: application/x-www-form-urlencoded' \
+--data-urlencode 'client_id=beispiel' \
+--data-urlencode 'client_secret=29e03d25-7999-4e4c-aa9a-bb2b99404d09' \
+--data-urlencode 'scope=destination:send' \
+--data-urlencode 'grant_type=client_credentials' \
+| jq -r .access_token)
+```
+
+Sie können das Token mit `echo ${TOKEN}` ausgeben lassen.
+
+Server Version abfragen (API Test):
+
+```bash
+curl --silent --header "Authorization: Bearer ${TOKEN}" https://sender-test.fiep-poc.de/beta7/info
+```
\ No newline at end of file

docs/getting-started/receiving/decrypt.mdx

@@ -5,4 +5,36 @@ sidebar_position: 4
 
 Um den Antrag korrekt verarbeiten und überprüfen zu können müssen zuerst alle verschlüsselten Informationen entschlüsselt werden. Darunter fallen beispielsweise die Antragsmetadaten, die Fachdaten (falls vorhanden) oder Dokumente (falls vorhanden).
 
-Die Entschlüsselung eines solchen Objektes mit Hilfe von JWE ist im Bereich "[Verschlüsselte Übertragung](#overview--verschlüsselte-übertragung)" genauer beschrieben und kann dort nachgelesen werden.
\ No newline at end of file
+## Entschlüsseln von Daten im antragsempfangenden System (Java)
+
+Wenn ein antragsempfangendes System (z.B. eine Fachanwendung oder virtuelle Poststelle) einen Antrag erhält, kann es diesen mit Hilfe des privaten Schlüssels und der Java-Bibliothek `nimbus-jose-jwt` entschlüsseln.
+
+```xml
+<dependency>
+    <groupId>com.nimbusds</groupId>
+    <artifactId>nimbus-jose-jwt</artifactId>
+    <version>9.X.X</version>
+</dependency>
+```
+
+Hierfür muss zuerst der private Schlüssel eingelesen werden. Bei `nimbus-jose-jwt` gibt es für RSA Schlüssel die Klasse RSAKey, um diese zu lesen:
+
+```java
+String keyStr = new String(existingPrivateKey.readAllBytes());
+RSAKey jwk = RSAKey.parse(keyStr);
+```
+
+Nach dem Einlesen können die verschlüsselten Daten (repräsentiert als Base64URL-kodierter String) mit Hilfe des Schlüssels entschlüsselt werden. Auch hier wird wieder abhängig vom Schlüssel eine entsprechende Klasse für die Entschlüsselung verwendet.
+
+```java
+String encryptedStr = new String(jweString.readAllBytes());
+JWEObject jweObject = JWEObject.parse(encryptedStr);
+
+jweObject.decrypt(new RSADecrypter(jwk));
+```
+
+Abschliessend kann die entschlüsselte Payload weiterverarbeitet oder, wie in diesem Fall, ausgegeben werden.
+
+```java
+System.out.println(jweObject.getPayload().toString());
+```
\ No newline at end of file

docs/getting-started/sending/encrypt.mdx

@@ -3,3 +3,118 @@ title: Verschlüsseln
 sidebar_position: 2
 ---
 
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+## Verschlüsseln von Daten
+
+Gegeben, dass ein öffentlicher Teil eines JWK eines Zustellpunktes vorhanden ist, können mit diesem Daten für diesen Zustellpunkt verschlüsselt werden. Ein Beispiel für den öffentlichen Teil eines JWK ist unten aufgeführt.
+
+```json
+{
+  "kty": "RSA",
+  "e": "AQAB",
+  "keyops": ["wrapKey"],
+  "x5c": [
+    "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUVtakNDQW9LZ0F3SUJBZ0lHQVhueVZNOFVNQTBHQ1NxR1NJYjNEUUVCQ3dVQU1BNHhEREFLQmdOVkJBTU0KQTJGelpEQWVGdzB5TVRBMk1Ea3hPVFV4TlRSYUZ3MHlNakEwTURVeE9UVXhOVFJhTUE0eEREQUtCZ05WQkFNTQpBMkZ6WkRDQ0FpSXdEUVlKS29aSWh2Y05BUUVCQlFBRGdnSVBBRENDQWdvQ2dnSUJBTEY5ZzErNnh1UWFDWGR0CndOSlcrN05oVW1NV1FXYTdFTlVpTlY0aTB2OTNubi8vVUdOYStFa25wdlk0czJVRVVhbnUvSWJLamRpb01MbE4KMzI1dFN0MW13TUpZS1cwT1N4VjVUU3hzdE9GK09OVG1QcDM3UUxRY1J4WVV2dGtPbTZnTCs2eDBuN3BLVlVpYQpORjd5N0NTZXFESWM3YmpQVE9iNDAwYXVGaVlRVlJQbmlWT2tHMWcwdkx5ZEEzU3N5dEhJUDRwa3JveXVFOTd3ClFXcDZqTnZacU5xUWZlNkJEQ21uSU56cFJDV2E1TWxkb1VJcUJsekpSVy9DSTNDcVhkVHRtZlhTeGwzSGF3WkIKQ2VLR3ZoQlRUN05pL0RpY1EwN05JdFYzUndZY2UveFptTHlvOCtPelF5L0k4WTZKU1hiNzR4VGo3OER6WEJvNgpVRUZodDJRVXIwaW80UVAxZTlxaFkwcmtGNDlUR2ZDSk9pUjNWWitzQ0hpNEE0a093VWVaNVM1bnh6SmFjVStpCjVINisrNUdKRkIrdEhmV0V2WWVRdzRsVlZqQkdPNHVvdW0xSVo1dHJyb0tJOHVVNXJ3ZjVHa1h2SkNTK1VyMC8KbVJLVHVQalJkWVEzYnk3NkpUMlR4WXZMRDR2ZzlwUjhVdmZTUW9yMFYzTDlXdE56RXhuMC9UK0pVN0g3cEtIVgp6UDNMT1QzbkgyTjZPbFY4YWd3USt0UlArUlJiVExWM2c0cmlMWHhMaEFMeDJQS1ZlRi92dk1BRFVZT2pnMFIrCndVa3ZRRkFqcGNBZXYwNnpNK1dDMm5FT2lBZVl6UVY5L1pudUdicEhuZWhXb3FJbjRXajQwYzY1b2Z1UEx1T3QKUlpjUjJiZkUrbWFvMFd0VUhCWjVLdC96T1ByWkFnTUJBQUV3RFFZSktvWklodmNOQVFFTEJRQURnZ0lCQUlaTwpXdWNXQWxYZm5OVGZ5eExvMEEzQXM3ZGs5Rno0bVBzK1h2MW1RYlJSN0F2VnNSQyszeDJQTEJTd09aMDIveXFVCllVbk9WcFgxd2U2b2JHamtGVjJrQUs1NXc2M1poU1B1eXlPOEhBdlkzY1Y1ell6MW9KcmNtenpQblBzRlhJbUoKZTBINXFBYjhwNWx5emovbkJ0RTRkUXRGMlUwUEdadXRqSE82ZDgybytOclhJL1lOOUV5aUtIWUxZNGJTZ0syOAo1TC9jdEJBMmorRDJ4NlJEcjJ3YzlhTjFOUzZ4MXdXWmRpMmkyTXUyeGg4Nmc4cXV1dFNBL2Q1VElIUXpKTnR1CmY1blRMc3lFL3BqZDVnT0dyeGV0REREbW9rQUR0YnV6REFUUUNkaVVnbEliamYvME1Kc3o5QTlMUGhUKzNURGQKWXFOWVVJQ2k2WEhiTTU3bk5FQldwc3doZnl3RDkvWCt1US81OUJoVkFKTEJRT1NQNTdpSHgwUXo1elY0eldTegowcUR5dzVUU3N0U25GNDZrVm0xeHcvdkxNK0FVOE9oZmRlODFyWElydCs5bkdEdUNBWXN4YTRpeWZ3Y2dXaUF4CmIrQm04OHIvL0dZSndvdFEwRnI3SUVkekNaVFM0cm5Sb0lodVpkQ00xQ3BXS0dMOFVjQU9nTnlpR0t1eEY3emcKZjd4NysrWmhBeXBOV2s5OEtxYnZLOG1hcTYzTkt5ck1tNG9KQ3VIVWRzdHMxOU1RODdnekFvRnd1QkYzSEF2eQowVXRvdGY0bGZWNllYay85b3orWHNiS2x4ZlIrV3JYN2J6RkNYcnZueC8zNk1zZEp3UTF3aXhWaGhsYWdnUFF3CnQzUU5iMnBDc0hXdkVLcExWZUk5aHl1L1BqOFIycEhaYUtjN1NGKzQKLS0tLS1FTkQgQ0VSVElGSUNBVEUtLS0tLQo="
+  ],
+  "x5t": "MTg6NTU6RUY6MEY6RkI6NDM6QzM6QTY6QUE6QzI6Nzg6Q0U6Mzk6MDc6NEE6RDk6QjA6OTA6NjU6Qzc6ODE6OTc6RDI6RjQ6NTE6ODQ6MjM6MTA6Qjc6QUU6QjY6NkE6NDU6QTc6RjA6OTE6MUY6NjY6QUU6NEQ6MEM6MTg6RDI6MzI6REU6QzM6RDk6RjY6NTY6REM6MEU6NUM6Q0E6NDk6QkY6OUI6NkY6OUM6MEM6QzM6ODQ6QjA6MkE6RkMK",
+  "kid": "787f3a1c-7da7-44d7-9b79-9783b1ea9be8",
+  "alg": "RSA-OAEP-256",
+  "n": "sX2DX7rG5BoJd23A0lb7s2FSYxZBZrsQ1SI1XiLS_3eef_9QY1r4SSem9jizZQRRqe78hsqN2KgwuU3fbm1K3WbAwlgpbQ5LFXlNLGy04X441OY-nftAtBxHFhS-2Q6bqAv7rHSfukpVSJo0XvLsJJ6oMhztuM9M5vjTRq4WJhBVE-eJU6QbWDS8vJ0DdKzK0cg_imSujK4T3vBBanqM29mo2pB97oEMKacg3OlEJZrkyV2hQioGXMlFb8IjcKpd1O2Z9dLGXcdrBkEJ4oa-EFNPs2L8OJxDTs0i1XdHBhx7_FmYvKjz47NDL8jxjolJdvvjFOPvwPNcGjpQQWG3ZBSvSKjhA_V72qFjSuQXj1MZ8Ik6JHdVn6wIeLgDiQ7BR5nlLmfHMlpxT6Lkfr77kYkUH60d9YS9h5DDiVVWMEY7i6i6bUhnm2uugojy5TmvB_kaRe8kJL5SvT-ZEpO4-NF1hDdvLvolPZPFi8sPi-D2lHxS99JCivRXcv1a03MTGfT9P4lTsfukodXM_cs5PecfY3o6VXxqDBD61E_5FFtMtXeDiuItfEuEAvHY8pV4X--8wANRg6ODRH7BSS9AUCOlwB6_TrMz5YLacQ6IB5jNBX39me4Zuked6FaioifhaPjRzrmh-48u461FlxHZt8T6ZqjRa1QcFnkq3_M4-tk"
+}
+```
+
+
+
+<Tabs
+  defaultValue="js"
+  values={[
+    { label: 'JavaScript', value: 'js', },
+    { label: 'Java', value: 'java', },
+  ]
+}>
+<TabItem value="js">
+
+Die Umwandelung des JWK in eine Struktur, die für die Bibliothek [panva/jose](https://github.com/panva/jose) nutzbar ist, kann mit Hilfe einer Methode aus dieser durchgeführt werden.
+
+```javascript
+import { parseJwk } from "jose/jwk/parse"
+import { CompactEncrypt } from "jose/jwe/compact/encrypt"
+
+const publicKey = await parseJwk({
+  "kty": "RSA",
+  "e": "AQAB",
+  "keyops": ["wrapKey"],
+  "x5c": [
+    "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"
+  ],
+  "x5t": "MTg6NTU6RUY6MEY6RkI6NDM6QzM6QTY6QUE6QzI6Nzg6Q0U6Mzk6MDc6NEE6RDk6QjA6OTA6NjU6Qzc6ODE6OTc6RDI6RjQ6NTE6ODQ6MjM6MTA6Qjc6QUU6QjY6NkE6NDU6QTc6RjA6OTE6MUY6NjY6QUU6NEQ6MEM6MTg6RDI6MzI6REU6QzM6RDk6RjY6NTY6REM6MEU6NUM6Q0E6NDk6QkY6OUI6NkY6OUM6MEM6QzM6ODQ6QjA6MkE6RkMK",
+  "kid": "787f3a1c-7da7-44d7-9b79-9783b1ea9be8",
+  "alg": "RSA-OAEP-256",
+  "n": "sX2DX7rG5BoJd23A0lb7s2FSYxZBZrsQ1SI1XiLS_3eef_9QY1r4SSem9jizZQRRqe78hsqN2KgwuU3fbm1K3WbAwlgpbQ5LFXlNLGy04X441OY-nftAtBxHFhS-2Q6bqAv7rHSfukpVSJo0XvLsJJ6oMhztuM9M5vjTRq4WJhBVE-eJU6QbWDS8vJ0DdKzK0cg_imSujK4T3vBBanqM29mo2pB97oEMKacg3OlEJZrkyV2hQioGXMlFb8IjcKpd1O2Z9dLGXcdrBkEJ4oa-EFNPs2L8OJxDTs0i1XdHBhx7_FmYvKjz47NDL8jxjolJdvvjFOPvwPNcGjpQQWG3ZBSvSKjhA_V72qFjSuQXj1MZ8Ik6JHdVn6wIeLgDiQ7BR5nlLmfHMlpxT6Lkfr77kYkUH60d9YS9h5DDiVVWMEY7i6i6bUhnm2uugojy5TmvB_kaRe8kJL5SvT-ZEpO4-NF1hDdvLvolPZPFi8sPi-D2lHxS99JCivRXcv1a03MTGfT9P4lTsfukodXM_cs5PecfY3o6VXxqDBD61E_5FFtMtXeDiuItfEuEAvHY8pV4X--8wANRg6ODRH7BSS9AUCOlwB6_TrMz5YLacQ6IB5jNBX39me4Zuked6FaioifhaPjRzrmh-48u461FlxHZt8T6ZqjRa1QcFnkq3_M4-tk"
+})
+```
+
+Mit diesem umgewandelten Schlüssel können nun Texte und Binärdaten verschlüsselt werden. Im großen und ganzen kann alles verschlüsselt werden, was vorher in ein `Uint8Array` umgewandelt wurde.
+
+Für Texte kann man hier den TextEncoder aus der Browser-Runtime nutzen, der den String in die UTF8-Bytes und damit in ein `Uint8Array` umwandelt.
+
+```javascript
+const encodedText = new TextEncoder().encode("{ \"Hello\": \"World\"}")
+const encryptedText = await new CompactEncrypt(encodedText)
+  .setProtectedHeader({ alg: "RSA-OAEP-256", enc: "A256GCM" })
+  .encrypt(publicKey)
+```
+
+Anhänge, wie PDF-Dateien, Bilder o. ä. liegen meist in einem `Uint8Array` vor bzw. können einfach darin umgewandelt werden. Im Folgenden Beispiel wird eine Datei aus einem HTML-File-Input direkt heraus verschlüsselt. 
+
+```javascript
+// .arrayBuffer() => https://developer.mozilla.org/en-US/docs/Web/API/Blob/arrayBuffer
+// Verschlüsselung der ersten Datei aus einem Datei-Input: <input type="file" id="my-file-input" />
+const buffer = await document.getElementById("my-file-input").files[0].arrayBuffer()
+const encryptedText = await new CompactEncrypt(buffer)
+  .setProtectedHeader({ alg: "RSA-OAEP-256", enc: "A256GCM" })
+  .encrypt(publicKey)
+```
+
+</TabItem>
+<TabItem value="java">
+
+```xml
+<dependency>
+    <groupId>com.nimbusds</groupId>
+    <artifactId>nimbus-jose-jwt</artifactId>
+    <version>9.X.X</version>
+</dependency>
+```
+
+```java
+String publicKeyAsString = new String(existingPublicKey.readAllBytes());
+// Only RSA keys with RSA-OAEP-256 and A256GCM are allowed 
+// => Therefore we need to parse a RSAKey
+RSAKey publicKey = RSAKey.parse(publicKeyAsString).toRSAPublicKey();
+```
+
+```java
+JWEHeader header = new JWEHeader(JWEAlgorithm.RSA_OAEP_256, EncryptionMethod.A256GCM);
+
+Payload payload = new Payload("{ \"Hello\": \"World\"}");
+/// Alternativ, bei einer Datei
+Payload payload = new Payload(aFileInputStream.readAllBytes());
+
+JWEObject jweObject = new JWEObject(header, payload);
+
+try {
+    jweObject.encrypt(new RSAEncrypter(publicKey));
+    // Serialisierung gemäß JWE Compact Serialization, siehe https://datatracker.ietf.org/doc/html/rfc7516#section-3.1
+    String encrypted = jweObject.serialize();
+
+    System.out.println("Encrypted Text:");
+    System.out.println(encrypted);
+} catch (JOSEException e) {
+    e.printStackTrace();
+}
+```
+</TabItem>
+</Tabs>
\ No newline at end of file

docs/rate-limiting.mdx

 ---
-title: Begrenzung von Abrufen
+title: Begrenzung von Abrufen (Rate-Limiting & Throttling)
 ---
 
 ...

docusaurus.config.js

 /** @type {import('@docusaurus/types').DocusaurusConfig} */
 module.exports = {
-  title: 'Fit Connect APIs',
-  tagline: 'Dokumentation für die APIs von Fit Connect',
-  url: 'https://fitko.uber.space',
-  baseUrl: '/',
-  onBrokenLinks: 'throw',
-  onBrokenMarkdownLinks: 'warn',
-  favicon: 'img/favicon.ico',
-  organizationName: 'fitko', // Usually your GitHub org/user name.
-  projectName: 'api', // Usually your repo name.
+  title: "FIT-Connect APIs",
+  tagline: "Dokumentation für die APIs von FIT-Connect",
+  url: "https://fitko.uber.space",
+  baseUrl: "/",
+  onBrokenLinks: "throw",
+  onBrokenMarkdownLinks: "warn",
+  favicon: "img/favicon.ico",
+  organizationName: "fitko", // Usually your GitHub org/user name.
+  projectName: "api", // Usually your repo name.
   i18n: {
-    defaultLocale: 'de',
-    locales: ['de']
+    defaultLocale: "de",
+    locales: ["de"],
   },
   themeConfig: {
     colorMode: {
       disableSwitch: true,
     },
+    prism: {
+      additionalLanguages: ["java", "csharp"],
+    },
     navbar: {
-      title: 'Fit Connect API Dokumentation',
+      title: "FIT-Connect Dokumentation",
       logo: {
-        alt: 'FITKO',
-        src: '/images/logo-fitko.svg',
+        alt: "FITKO",
+        src: "/images/logo-fitko.svg",
       },
       items: [
         {
-          href: 'https://git.fitko.de/fit-connect/api',
-          label: 'Gitlab',
-          position: 'right',
+          href: "https://git.fitko.de/fit-connect/api",
+          label: "Gitlab",
+          position: "right",
         },
       ],
     },
     footer: {
-      style: 'light',
+      style: "light",
       copyright: `Copyright © ${new Date().getFullYear()} FITKO (Föderale IT-Kooperation) | Zum Gottschalkhof 3 | 60594 Frankfurt am Mail | E-Mail: poststelle@fitko.de | https://www.fitko.de | Die FITKO ist eine Anstalt des öffentlichen Rechts. Sie wird vertreten durch die Präsidentin Frau Dr. Annette Schmidt.`,
     },
   },
   presets: [
     [
-      '@docusaurus/preset-classic',
+      "@docusaurus/preset-classic",
       {
         docs: {
-          sidebarPath: require.resolve('./sidebars.js'),
-          editUrl: 'https://git.fitko.de/fit-connect/api',
-          routeBasePath: '/'
+          sidebarPath: require.resolve("./sidebars.js"),
+          editUrl: "https://git.fitko.de/fit-connect/api",
+          routeBasePath: "/",
         },
         theme: {
-          customCss: require.resolve('./src/css/custom.css'),
+          customCss: require.resolve("./src/css/custom.css"),
         },
       },
     ],

sidebars.js

@@ -11,73 +11,84 @@
 
 module.exports = {
   defaultSidebar: [
-    'overview',
-    'rate-limiting',
-    'status-and-error-codes',
+    "overview",
+    "rate-limiting",
+    "status-and-error-codes",
     {
-      type: 'category',
-      label: 'Getting Started',
+      type: "category",
+      label: "Getting Started",
       items: [
+        "getting-started/overview",
+        "getting-started/account",
+        "getting-started/authentication/applications",
+        "getting-started/authentication/users",
+        "getting-started/encryption",
         {
-          type: 'category',
-          label: 'Versenden',
-          items: [{
-            type: 'autogenerated',
-            dirName: 'getting-started/sending'
-          }]
+          type: "category",
+          label: "Versenden",
+          items: [
+            {
+              type: "autogenerated",
+              dirName: "getting-started/sending",
+            },
+          ],
         },
         {
-          type: 'category',
-          label: 'Empfangen',
-          items: [{
-            type: 'autogenerated',
-            dirName: 'getting-started/receiving'
-          }]
-        }
-      ]
-    },
-    {
-      type: 'category',
-      label: 'SDK',
-      items: [{
-        type: 'autogenerated',
-        dirName: 'sdk'
-      }]
+          type: "category",
+          label: "Empfangen",
+          items: [
+            {
+              type: "autogenerated",
+              dirName: "getting-started/receiving",
+            },
+          ],
+        },
+      ],
     },
+    // {
+    //   type: 'category',
+    //   label: 'SDK',
+    //   items: [{
+    //     type: 'autogenerated',
+    //     dirName: 'sdk'
+    //   }]
+    // },
     {
-      type: 'category',
-      label: 'API Spezifikationen',
-      items: [{
-        type: 'autogenerated',
-        dirName: 'apis'
-      }]
+      type: "category",
+      label: "API Spezifikationen",
+      items: [
+        {
+          type: "autogenerated",
+          dirName: "apis",
+        },
+      ],
     },
     {
-      type: 'category',
-      label: 'Weiteres',
+      type: "category",
+      label: "Weiteres",
       items: [
-        { 
-          type: 'doc',
-          label: 'Glossar', 
-          id: 'more/glossary'
+        {
+          type: "doc",
+          label: "Glossar",
+          id: "more/glossary",
         },
         {
-          type: 'link',
-          label: 'Feedback',
-          href: 'https://jira.fiep-poc.de/servicedesk/customer/portal/1'
+          type: "link",
+          label: "Feedback",
+          href: "https://jira.fiep-poc.de/servicedesk/customer/portal/1",
         },
         {
-          type: 'link',
-          label: 'Terms of Service',
-          href: 'https://www.fitko.de/'
+          type: "link",
+          label: "Terms of Service",
+          href: "https://www.fitko.de/",
         },
         {
-          type: 'link',
-          label: 'Impressum',
-          href: 'https://www.fitko.de/Impressum'
-        }
-      ]
-    }
+          type: "link",
+          label: "Impressum",
+          href: "https://www.fitko.de/Impressum",
+        },
+      ],
+    },
   ],
 
   // anotherSidebar: [{

src/components/ApiSpec.js

 import React from 'react'
 import 'rapidoc'
 
-export default function ApiSpec() {
+export default function ApiSpec(props) {
   return (
-    <rapi-doc id="thedoc"
-      render-style="focused"
-
+    <rapi-doc
+      render-style="view"
+      spec-url={props.specUrl}
       theme="light"
+
       xprimary-color="#11171a"
       header-color="#263238"
       nav-bg-color="#263238"
-
-      show-info="true"
-      show-header="true"
-      show-components="true"
+      show-info="false"
+      show-header="false"
+      show-components="false"
       allow-spec-file-load="false"
-
-      info-description-headings-in-navbar="true"></rapi-doc>
-  )
+      info-description-headings-in-navbar="false"
+    ></rapi-doc>
+  );
 }
\ No newline at end of file