@golemio/public-transport 0.1.0

package/docs/implementation_documentation.md

@@ -0,0 +1,1667 @@
+# Implementační dokumentace modulu _pid_
+
+## Záměr
+
+Modul slouží k ukládání a poskytování informací o jízdních řádech a real-time polohových datech v Praze a Středočeském kraji.
+
+## Vstupní data
+
+### Data aktivně stahujeme
+
+**Dostupní poskytovatelé**:
+
+-   ROPID FTP
+    -   GTFS (General Transit Feed Specification) jízdní rády
+    -   CIS (Celostátní informační systém) zastávkový číselník
+    -   OIS (Odbavovací a informační systém) mapovací číselník pro tramvaje
+    -   Oběhy vozidel
+    -   Presets (definice pro zkracovač URL)
+-   ROPID VYMI (Výluky a mimořádnosti)
+-   Seznam Autobusu API (informace o vozidlech, např. dostupnost klimatizace nebo USB zásuvek)
+-   Statická data
+    -   Ukazatelé směru jízdy
+    -   Kolejové obvody pro metro
+-   Grafana Loki
+    -   Request logy z URL proxy pro monitorovací centrum od ROPIDU
+-   JIS Infotexty
+
+#### _ROPID FTP (obecně)_
+
+-   přístupy
+    -   host: config.datasources.RopidFTP.host
+    -   user: config.datasources.RopidFTP.user
+    -   password: config.datasources.RopidFTP.password
+    -   secure: config.datasources.RopidFTP.secure
+
+#### _GTFS jízdní řády_
+
+-   identifikátor: GTFS
+-   zdroj dat
+    -   cesta: /GTFS (config.datasources.RopidGTFSPath)
+    -   soubory:
+        -   GTFS.zip (config.datasources.RopidGTFSFilename) -> agency.txt, calendar.txt, calendar_dates.txt, shapes.txt, stop_times.txt, stops.txt, routes.txt, route_sub_agencies.txt, transfers.txt, trips.txt
+-   formát dat
+    -   protokol: ftp
+    -   datový typ: csv
+    -   validační schéma: není, mapování rovnou do tabulek, viz [Dto jsonSchema](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/schema-definitions/ropid-gtfs/models)
+    -   příklad vstupnich dat https://gitlab.com/operator-ict/golemio/code/modules/pid/-/snippets/2462385
+-   frekvence stahování
+    -   cron definice:
+        -   cron.vehicle-positions.ropidgtfs.checkForNewData
+            -   rabin `0 35 5,12 * * *`
+            -   prod `0 20 5 * * *`, `0 50 12 * * *`
+-   názvy rabbitmq front
+    -   vehicle-positions.ropidgtfs.checkForNewData
+    -   vehicle-positions.ropidgtfs.downloadDatasets se zprávou `["GTFS"]`
+
+#### _CIS zastávkový číselník_
+
+-   identifikátor: CIS_STOPS
+-   zdroj dat
+    -   cesta: /PUBLIC/ZASTAVKY/JSON (config.datasources.RopidGTFSCisStopsPath)
+    -   soubory:
+        -   Stops.Min.json (config.datasources.RopidGTFSCisStopsFilename)
+-   formát dat
+    -   protokol: ftp
+    -   datový typ: json
+    -   validační schéma: [datasourceJsonSchema](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/schema-definitions/ropid-gtfs/RopidGTFSCisStops.ts#L31)
+    -   příklad vstupnich dat https://gitlab.com/operator-ict/golemio/code/modules/pid/-/snippets/2462390
+-   frekvence stahování
+    -   cron definice:
+        -   viz GTFS jízdní řády
+-   názvy rabbitmq front
+    -   vehicle-positions.ropidgtfs.checkForNewData
+    -   vehicle-positions.ropidgtfs.downloadDatasets se zprávou `["CIS_STOPS"]`
+
+#### _OIS mapovací číselník pro tramvaje_
+
+_:warning: Původním záměrem bylo využití OIS číselníku během zpracování poloh tramvají z MPVNETU. Momentálně zůstavá nevyužit, v budoucnu bude smazán_
+
+-   identifikátor: OIS_MAPPING
+-   zdroj dat
+    -   cesta: / (config.datasources.RopidGTFSOisPath)
+    -   soubory:
+        -   oisMapping.json (config.datasources.RopidGTFSOisFilename)
+-   formát dat
+    -   protokol: ftp
+    -   datový typ: json
+    -   validační schéma: [datasourceJsonSchema](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/schema-definitions/ropid-gtfs/RopidGTFSOisMapping.ts#L13)
+    -   příklad vstupnich dat
+    ```json
+    [
+        {
+            "ois": 5067,
+            "node": 67,
+            "name": "Čechovo náměstí"
+        }
+    ]
+    ```
+-   frekvence stahování
+    -   cron definice:
+        -   viz GTFS jízdní řády
+-   názvy rabbitmq front
+    -   vehicle-positions.ropidgtfs.checkForNewData
+    -   vehicle-positions.ropidgtfs.downloadDatasets se zprávou `["OIS_MAPPING"]`
+
+#### _Oběhy vozidel_
+
+-   identifikátor: RUN_NUMBERS
+-   zdroj dat
+    -   cesta: / (config.datasources.RopidGTFSRunNumbersPath)
+    -   soubory:
+        -   obehy.csv (config.datasources.RopidGTFSRunNumbersFilename)
+-   formát dat
+    -   protokol: ftp
+    -   datový typ: csv
+    -   validační schéma: [datasourceJsonSchema](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/schema-definitions/ropid-gtfs/RopidGTFSRunNumbers.ts#L19)
+    -   příklad vstupnich dat
+    ```csv
+    route_id,run_number,service_id,trip_id,vehicle_type
+    L991,1,1111100-1,991_1342_220901,3
+    L991,1,1111100-1,991_1343_220901,3
+    ```
+-   frekvence stahování
+    -   cron definice:
+        -   viz GTFS jízdní řády
+-   názvy rabbitmq front
+    -   vehicle-positions.ropidgtfs.checkForNewData
+    -   vehicle-positions.ropidgtfs.downloadDatasets se zprávou `["RUN_NUMBERS"]`
+
+#### _Presets definice pro zkracovač URL_
+
+-   identifikátor: DEPARTURES_PRESETS
+-   zdroj dat
+    -   cesta: / (config.datasources.RopidDeparturesPresetsPath)
+    -   soubory:
+        -   presets.json (config.datasources.RopidDeparturesPresetsFilename)
+-   formát dat
+    -   protokol: ftp
+    -   datový typ: json
+    -   validační schéma: [outputPresetsJsonSchema](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/schema-definitions/ropid-departures-presets/RopidDeparturesPresetsOutputSchemas.ts)
+    -   příklad vstupnich dat: [ropiddeparturespresets-data.json](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/test/integration-engine/ropid-gtfs/data/ropiddeparturespresets-data.json)
+-   frekvence stahování
+    -   cron definice:
+        -   cron.vehicle-positions.ropidpresets.checkForNewDeparturesPresets
+            -   rabin `15 */4 * * * *`
+            -   prod `15 */4 * * * *`
+-   názvy rabbitmq front
+    -   vehicle-positions.ropidpresets.checkForNewDeparturesPresets
+    -   vehicle-positions.ropidpresets.downloadDeparturesPresets
+
+#### _VYMI výluky a mimořádnosti_
+
+-   zdroj dat
+    -   url: https://vymipid.ropid.cz/ws/list_publ (config.datasources.RopidVYMIApiUrl)
+    -   parametry dotazu: config.datasources.RopidVYMIApiHeaders
+-   formát dat
+    -   protokol: http
+    -   datový typ: json
+    -   validační schéma: [datasourceJsonSchema](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/schema-definitions/ropid-vymi/index.ts#L62)
+    -   příklad vstupnich dat: [ropidvymi-datasource.json](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/test/integration-engine/ropid-vymi/data/ropidvymi-datasource.json)
+-   frekvence stahování
+    -   cron definice:
+        -   cron.vehicle-positions.ropidvymi.checkForNewEvents
+            -   rabin `*/30 * * * * *`
+            -   prod `*/30 * * * * *`
+-   názvy rabbitmq front
+    -   vehicle-positions.ropidvymi.checkForNewEvents
+
+#### _Seznam Autobusu API_
+
+-   zdroj dat
+    -   url: config.datasources.SeznamAutobusuApiUrl
+    -   parametry dotazu: config.datasources.SeznamAutobusuApiHeaders
+-   formát dat
+    -   protokol: http
+    -   datový typ: json
+    -   validační schéma: [seznamAutobusuJsonSchema](../src/schema-definitions/vehicle-descriptors/datasources/SeznamAutobusuJsonSchema.ts)
+    -   příklad vstupnich dat: [InputDataFixture](../test/integration-engine/vehicle-positions/workers/vehicle-descriptors/fixtures/InputDataFixture.ts)
+-   frekvence stahování
+    -   cron definice:
+        -   cron.vehicle-positions.vehicledescriptors.refreshDescriptors
+            -   rabin `0 15 5,12 * * *`
+            -   prod `0 10 5,12 * * *`
+-   názvy rabbitmq front
+    -   vehicle-positions.vehicledescriptors.refreshDescriptors
+-   filtrace dat
+    -   záznamy, jejichž evidenční číslo (`number`) není čistě číselná hodnota (např. obsahuje pomlčku ve tvaru `71-1102`), jsou před zpracováním odfiltrována
+
+#### _Ukazatelé směru jízdy_
+
+-   zdroj dat
+    -   pomocná statická data
+    -   data nahrávány přímo do tabulky https://gitlab.com/operator-ict/golemio/code/modules/pid/-/snippets/2462793
+-   formát dat
+    -   datový typ: sql
+    -   validační schéma: [outputDeparturesDirectionsJsonSchema](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/schema-definitions/ropid-departures-directions/RopidDeparturesDirectionsOutputSchemas.ts#L1)
+    -   příklad vstupnich dat: viz zdroj dat
+-   frekvence stahování
+    -   manuální refresh dat
+-   název rabbitmq fronty
+    -   neexistuje
+
+#### _Grafana Loki_
+
+-   zdroj dat
+    -   url: config.datasources.GrafanaLokiApiUrl
+    -   parametry dotazu: config.datasources.GrafanaLokiApiHeaders
+-   formát dat
+    -   protokol: http
+    -   datový typ: json
+    -   validační schéma: [grafanaLokiJsonSchema](../src/schema-definitions/ropid-departures-preset-logs/datasources/GrafanaLokiJsonSchema.ts)
+    -   příklad vstupnich dat: [InputLogsFixture](../test/integration-engine/ropid-gtfs/workers/presets/fixtures/InputLogsFixture.ts)
+-   frekvence stahování
+    -   cron definice:
+        -   cron.vehicle-positions.ropidpresets.collectAndSaveLogs
+            -   rabin `0 */1 * * * *`
+            -   prod `0 */1 * * * *`
+-   názvy rabbitmq front
+    -   vehicle-positions.ropidpresets.collectAndSaveLogs se zprávou `{ "targetMinutes": n }`
+
+#### _JIS Events_
+
+-   zdroj dat
+    -   baseUrl: module.pid.jis.vymiApi.baseUrl
+    -   VYMI events path: module.pid.jis.vymiApi.events.path
+    -   hlavičky VYMI events dotazu: module.pid.jis.vymiApi.events.headers a module.pid.jis.vymiApi.commonHeaders
+-   formát dat
+    -   protokol: http
+    -   datový typ: json
+    -   validační schéma: [JISEventsJsonSchema](../src/schema-definitions/jis/datasources/JISEventsJsonSchema.ts)
+    -   příklad vstupnich dat: [eventsDataSourceFixture](../test/integration-engine/jis/fixtures/eventsDataSourceFixture.ts)
+-   frekvence stahování
+    -   cron definice:
+        -   cron.vehicle-positions.jis.refreshJISEvents
+            -   rabin `0 */1 * * * *`
+            -   prod `0 */1 * * * *`
+    -   data mohou být stažena po manuálním zaslání zprávy do RabbitMQ fronty (primární způsob aktualizace dat je aktivní posílání a cron)
+    -   při pasivním stahování se využívá ETag, který umožňuje přenášet pouze nová či změněná data; pokud se data od posledního načtení nezměnila, server vrátí informaci o bezezměněném obsahu
+-   název rabbitmq fronty
+    -   vehicle-positions.jis.fetchJISEvents
+
+#### _JIS Infotexts_
+
+-   zdroj dat
+    -   baseUrl: module.pid.jis.vymiApi.baseUrl
+    -   VYMI infotexts path: module.pid.jis.vymiApi.infotexts.path
+    -   hlavičky VYMI infotexts dotazu: module.pid.jis.vymiApi.infotexts.headers a module.pid.jis.vymiApi.commonHeaders
+-   formát dat
+    -   protokol: http
+    -   datový typ: json
+    -   validační schéma: [JISInfotextsJsonSchema](../src/schema-definitions/jis/datasources/JISInfotextsJsonSchema.ts)
+    -   příklad vstupnich dat: [infotextsDataSourceFixture](../test/integration-engine/jis/fixtures/infotextsDataSourceFixture.ts)
+-   frekvence stahování
+    -   cron definice:
+        -   cron.vehicle-positions.jis.refreshJISInfotexts
+            -   rabin `0 */1 * * * *`
+            -   prod `0 */1 * * * *`
+    -   data mohou být stažena po manuálním zaslání zprávy do RabbitMQ fronty (primární způsob aktualizace dat je aktivní posílání a cron)
+    -   při pasivním stahování se využívá ETag, který umožňuje přenášet pouze nová či změněná data; pokud se data od posledního načtení nezměnila, server vrátí informaci o bezezměněném obsahu
+-   název rabbitmq fronty
+    -   vehicle-positions.jis.fetchJISInfotexts
+
+### _Ropid staticka data_
+
+-   zdroj dat
+    -   baseUrl: module.pid.staticData.baseUrl
+    -   departure directions url: module.pid.staticData.departuresDirection.path
+    -   metro rail track url: module.pid.staticData.metroRailTracks.path
+    -   not public vehicles url: module.pid.staticData.notPublicVehicles.path
+-   formát dat
+    -   protokol: http
+    -   datový typ: csv (DeparturesDirection, MetroRailTrack), json (NotPublicVehicles)
+    -   validační schéma:
+        -   [MetroRailTrack](../src/schema-definitions/datasources/static-data/MetroRailTrackJsonSchema.ts)
+        -   [DeparturesDirection](../src/schema-definitions/datasources/static-data/DeparturesDirectionsJsonSchema.ts)
+        -   [NotPublicVehicles](../src/schema-definitions/datasources/static-data/interfaces/NotPublicVehiclesDataInterface.ts) – interface `INotPublicVehicles`
+    -   příklad vstupnich dat: viz zdroj data
+-   frekvence stahování
+    -   Po nacteni jizdnich radu (fronta: vehicle-positions.ropidgtfs.checkForNewData)
+-   názvy rabbitmq front
+    -    vehicle-positions.ropidgtfs.saveStaticData
+
+### Data nám jsou posílána
+
+**Dostupní poskytovatelé**:
+
+-   MPVNET (Monitorování provozu vozidel) - ROPID + CHAPS
+    -   autobusy (mimo DPP), vlaky, přívozy, lanovky
+-   TCP zprávy o obězích vozidel - DPP + CHAPS
+    -   autobusy a trolejbusy, tramvaje
+    -   metro
+-   TCP zprávy o obězích vozidel - TELMAX
+    -   autobusy (ARRIVA City)
+
+#### _Vehicle Positions_
+
+-   formát dat
+    -   protokol: http
+    -   datový typ: xml
+    -   validační schéma: pro parsovaný json [SaveDataToDBSchema](../src/integration-engine/vehicle-positions/workers/vehicle-positions/schema/SaveDataToDBSchema.ts)
+    -   příklad vstupních dat
+    ```xml
+    <?xml version="1.0" encoding="UTF-8"?>
+    <m disp="http://77.93.194.81:8716/api">
+        <spoj lin="999999" alias="155" spoj="1" t="3" sled="2" np="true" zrus="false" lat="50.08323" lng="14.51035" cpoz="11:09:06" po="1" zast="56699" zpoz_prij="426" zpoz_odj="426">
+            <zast zast="57517" stan="C" prij="" odj="11:00" zpoz_typ="3" zpoz_prij="311" zpoz_odj="311"></zast>
+        </spoj>
+    </m>
+    ```
+-   endpoint v input-gateway
+    -   openapi specifikace [/vehiclepositions](https://api.golemio.cz/v2/pid/input/docs/openapi/#/%F0%9F%9B%A4%20Vehicle%20Positions/post_vehiclepositions)
+-   nastavení práv v permission-proxy
+    -   endpoint `/input-gateway/v1/vehiclepositions/spoje`
+    -   přeposíláno z [produkční data proxy](https://gitlab.com/operator-ict/golemio/devops/infrastructure/-/blob/master/cluster_production/golemio_data-proxy-values.yaml#L65)
+-   transformace raw dat
+    -   zprávy jsou xml body parserem převedeny do jsonu a přeposlány do rabbitmq fronty
+-   název rabbitmq fronty
+    -   vehicle-positions.vehiclepositions.saveDataToDB
+-   ukládání raw dat na blob storage
+    -   název kontejneru: {rabin,golem}-input-gateway
+    -   cesta: /vehiclepositions/yyyy-MM-dd/HH_mm_ss.SSS.xml
+    -   agregace dat: není
+-   odhadovaná zátěž
+    -   jednotky až desítky za minutu
+
+#### _Vehicle Positions Common Runs_
+
+-   formát dat
+    -   protokol: tcp
+    -   datový typ: xml
+    -   validační schéma: základní kontrola xml v [parserech](https://gitlab.com/operator-ict/golemio/code/tcp-input-gateway/-/tree/development/src/receivers/parsers), validační schéma pro parsovaný json [CommonRunsSchema](../src/integration-engine/vehicle-positions/workers/runs/schema/CommonRunsSchema.ts)
+    -   příklad vstupnich dat (autobus)
+    ```xml
+    <M>
+        <V turnus="134/3" line="134" evc="3738" np="ano" lat="50.03952" lng="14.42919" akt="07960001" takt="2022-06-29T17:28:13" konc="01100005" tjr="2022-06-29T17:23:00" pkt="12709236" tm="2022-06-29T17:28:22" events="O" />
+    </M>
+    ```
+    -   příklad vstupnich dat (trolejbus)
+    ```xml
+    <M>
+        <V turnus="58/1" line="58" evc="0509" lat="50.11614" lng="14.49470" akt="07540001" takt="2023-06-03T08:16:19" konc="03840001" tjr="2023-06-03T08:16:00" pkt="733775" tm="2023-06-03T08:16:18" events="O" />
+    </M>
+    ```
+-   adresa: api.golemio.cz:3003 (tramvaje) a api.golemio.cz:3004 (autobusy)
+    -   dokumentace tcp receiverů: [transport input gateway#dpp-trams](https://gitlab.com/operator-ict/golemio/code/tcp-input-gateway#dpp-trams), [transport input gateway#dpp-busses](https://gitlab.com/operator-ict/golemio/code/tcp-input-gateway#dpp-busses)
+-   řízení přístupů řešeno na síťové úrovni mimo permission proxy
+    -   přeposíláno z [produkční data proxy](https://gitlab.com/operator-ict/golemio/devops/infrastructure/-/blob/master/cluster_production/golemio_data-proxy-values.yaml#L35)
+-   transformace raw dat
+    -   úplné zprávy jsou knihovnou `xml2js` převedeny do jsonu a přeposlány do rabbitmq fronty
+    -   implementace tram/bus receiverů je totožná, pouze se zprávy přeposílají do jiných front a ukládají se do jiné složky na blob storage
+-   název rabbitmq front
+    -   vehicle-positions.vehiclepositions.saveTramRunsToDB
+    -   vehicle-positions.vehiclepositions.saveBusRunsToDB
+-   ukládání raw dat na blob storage
+    -   název kontejneru: {rabin,golem}-input-gateway
+    -   cesta: /tcp-dpp-{tram,bus}-data/yyyy-MM-dd/HH_mm_ss.SSS.xml
+    -   agregace dat: 1 MB
+-   odhadovaná zátěž
+    -   tramvaje - desítky zpráv za minutu
+    -   autobusy - jednotky až desítky zpráv za sekundu
+
+#### _Vehicle Positions Metro Runs_
+
+-   formát dat
+    -   protokol: tcp
+    -   datový typ: xml
+    -   validační schéma: základní kontrola xml v [parseru](https://gitlab.com/operator-ict/golemio/code/tcp-input-gateway/-/blob/development/src/receivers/parsers/dpp-metro.parser.ts), validační schéma pro parsovaný json [MetroRunsSchema](../src/integration-engine/vehicle-positions/workers/runs/schema/MetroRunsSchema.ts)
+    -   příklad vstupnich dat
+    ```xml
+    <m linka="A" tm="2022-07-20T13:45:34Z" gvd="GD20a">
+        <vlak csp=" 3" csr=" 3" cv="279" ko="1809" odch="25" />
+    </m>
+    ```
+-   adresa: tcp.golemio.cz:3006
+    -   dokumentace tcp receiveru: [transport input gateway#dpp-metro](https://gitlab.com/operator-ict/golemio/code/tcp-input-gateway#dpp-metro)
+-   řízení přístupů řešeno na síťové úrovni mimo permission proxy
+    -   přeposíláno z [produkční data proxy](https://gitlab.com/operator-ict/golemio/devops/infrastructure/-/blob/master/cluster_production/golemio_data-proxy-values.yaml#L55)
+-   transformace raw dat
+    -   úplné zprávy jsou knihovnou `xml2js` převedeny do jsonu a přeposlány do rabbitmq fronty
+-   název rabbitmq front
+    -   vehicle-positions.vehiclepositionsruns.saveMetroRunsToDB
+-   ukládání raw dat na blob storage
+    -   název kontejneru: {rabin,golem}-input-gateway
+    -   cesta: /tcp-dpp-metro-data/yyyy-MM-dd/HH_mm_ss.SSS.xml
+    -   agregace dat: 1 MB
+-   odhadovaná zátěž
+    -   desítky až stovky zpráv za minutu
+
+#### _Vehicle Positions ARRIVA City Bus Runs_
+
+-   formát dat
+    -   protokol: tcp
+    -   datový typ: xml
+    -   validační schéma: základní kontrola xml v [parseru](https://gitlab.com/operator-ict/golemio/code/tcp-input-gateway/-/blob/development/src/receivers/parsers/regional-bus.parser.ts), validační schéma pro parsovaný json [RegionalBusRunsSchema](../src/integration-engine/vehicle-positions/workers/runs/schema/RegionalBusRunsSchema.ts)
+    -   příklad vstupnich dat
+    ```xml
+    <M>
+        <V imei="867377023812625" rz="6AB8491" pkt="3107" lat="50.00201" lng="14.4054" tm="2023-07-02T23:59:44" events="R" rych="11" smer="149" />
+    </M>
+    ```
+-   adresa: tcp.golemio.cz:3008 (TELMAX)
+    -   dokumentace tcp receiveru: [transport input gateway#arriva-city-bus-data](https://gitlab.com/operator-ict/golemio/code/tcp-input-gateway/-/tree/development#arriva-city-bus-data)
+-   řízení přístupů řešeno na síťové úrovni mimo permission proxy
+    -   přeposíláno z [produkční data proxy](https://gitlab.com/operator-ict/security/golemio-golem/-/blob/master/data-proxy/values-secret.yaml)
+-   transformace raw dat
+    -   úplné zprávy jsou knihovnou `xml2js` převedeny do jsonu a přeposlány do rabbitmq fronty
+-   název rabbitmq front
+    -   vehicle-positions.vehiclepositionsruns.saveArrivaCityRunsToDB
+-   ukládání raw dat na blob storage
+    -   název kontejneru: {rabin,golem}-input-gateway
+    -   cesta: /tcp-arriva-city-data/yyyy-MM-dd/HH_mm_ss.SSS.xml
+    -   agregace dat: 1 MB
+-   odhadovaná zátěž
+    -   desítky až stovky zpráv za minutu
+
+#### _JIS Events_
+
+-   formát dat
+    -   protokol: http
+    -   datový typ: json
+    -   validační schéma: [JISEventsJsonSchema](../src/schema-definitions/jis/datasources/JISEventsJsonSchema.ts)
+    -   příklad vstupnich dat: [eventsDataSourceFixture](../test/integration-engine/jis/fixtures/eventsDataSourceFixture.ts)
+-   název rabbitmq fronty
+    -   vehicle-positions.jis.refreshJISEvents
+
+#### _JIS Infotexts_
+
+-   formát dat
+    -   protokol: http
+    -   datový typ: json
+    -   validační schéma: [JISInfotextsJsonSchema](../src/schema-definitions/jis/datasources/JISInfotextsJsonSchema.ts)
+    -   příklad vstupnich dat: [infotextsDataSourceFixture](../test/integration-engine/jis/fixtures/infotextsDataSourceFixture.ts)
+-   název rabbitmq fronty
+    -   vehicle-positions.jis.refreshJISInfotexts
+
+## Výstupní data
+
+### Data aktivně posíláme na push endpoint
+
+#### _ROPID monitorovací centrum_
+
+-   cíl dat
+    -   url: config.datasources.RopidMonitoringPushUrl
+    -   parametry dotazu: config.datasources.RopidMonitoringPushHeaders
+-   formát dat
+    -   protokol: http
+    -   datový typ: json
+    -   příklad dat
+    ```json
+    [
+        {
+            "deviceAlias": "test-povstani",
+            "receivedAt": "2023-06-27T14:39:58Z"
+        }
+    ]
+    ```
+-   frekvence stahování
+    -   cron definice:
+        -   cron.vehicle-positions.ropidpresets.collectAndSaveLogs
+            -   rabin `0 */1 * * * *`
+            -   prod `0 */1 * * * *`
+-   názvy rabbitmq front
+    -   vehicle-positions.ropidpresets.collectAndSaveLogs se zprávou `{ "targetMinutes": n }`
+
+## Zpracování dat / transformace
+
+Všechny tabulky se nachází ve schématu `pid`
+
+### TimetableWorker
+
+#### task _CheckForNewData_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidgtfs.checkForNewData
+    -   TTL: 19 minut
+    -   parametry: `{ forceRefresh }`
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.ropidgtfs.downloadDatasets
+-   datové zdroje
+    -   ROPID FTP
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidGTFSMetadataModel `ropidgtfs_metadata`
+
+#### task _DownloadDatasets_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidgtfs.downloadDatasets
+    -   TTL: 59 minut
+    -   parametry: `["GTFS", "CIS_STOPS", "OIS_MAPPING", "RUN_NUMBERS"]`
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.ropidgtfs.transformAndSaveData
+    -   název: vehicle-positions.ropidgtfs.checkSavedRowsAndReplaceTables
+-   datové zdroje
+    -   ROPID FTP
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidGTFSMetadataModel `ropidgtfs_metadata`
+
+#### task _TransformAndSaveData_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidgtfs.transformAndSaveData
+    -   TTL: 23 hodin
+    -   parametry: `{ filepath, name, mtime, type, dataset }`
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   ROPID FTP
+-   transformace
+    -   [RopidGTFSTransformation](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/integration-engine/ropid-gtfs/transformations/RopidGTFSTransformation.ts)
+    -   [RopidGTFSCisStopsTransformation](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/integration-engine/ropid-gtfs/transformations/RopidGTFSCisStopsTransformation.ts)
+    -   [RopidGTFSOisMappingTransformation](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/integration-engine/ropid-gtfs/transformations/RopidGTFSOisTransformation.ts)
+    -   [RopidGTFSRunNumbersTransformation](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/integration-engine/ropid-gtfs/transformations/RopidGTFSRunNumbersTransformation.ts)
+    -   [RopidGtfsRouteSubAgencyTransformation](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/integration-engine/ropid-gtfs/transformations/RopidGtfsRouteSubAgencyTransformation.ts)
+        -   on top of transformation functionality it also removes duplicates. Rule: If there are multiple rows with same `route_id` and `sub_agency_id` only the first with filled licence number is kept.
+-   rozšířené sloupce GTFS souborů (nestandardní rozšíření ROPID)
+    -   `trips.txt` – sloupec `headsign_icons`: řetězec dvouznakových kódů ikon (např. `"MbSb"`), uložen do `ropidgtfs_trips.headsign_icons`
+    -   `stop_times.txt` – sloupec `headsign_icons`: přepis na úrovni zastávky, uložen do `ropidgtfs_stop_times.headsign_icons`; má přednost před hodnotou z `trips.txt` pokud je zároveň vyplněn `stop_headsign`
+-   data modely
+    -   RopidGTFSMetadataModel `ropidgtfs_metadata`
+    -   RopidGTFSAgencyModel `ropidgtfs_agency`
+    -   RopidGTFSCalendarModel `ropidgtfs_calendar`
+    -   RopidGTFSCalendarDatesModel `ropidgtfs_calendar_dates`
+    -   RopidGTFSRoutesModel `ropidgtfs_routes`
+    -   RouteSubAgencyDto `ropidgtfs_route_sub_agencies`
+    -   RopidGTFSShapesModel `ropidgtfs_shapes`
+    -   RopidGTFSStopTimesModel `ropidgtfs_stop_times`
+    -   RopidGTFSStopsModel `ropidgtfs_stops`
+    -   RopidGTFSTripsModel `ropidgtfs_trips`
+    -   RopidGTFSCisStopsModel `ropidgtfs_cis_stops`
+    -   RopidGTFSCisStopGroupsModel `ropidgtfs_cis_stop_groups`
+    -   RopidGTFSOisModel `ropidgtfs_ois`
+    -   RopidGTFSRunNumbersModel `ropidgtfs_run_numbers`
+
+#### task _CheckSavedRowsAndReplaceTables_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidgtfs.checkSavedRowsAndReplaceTables
+    -   TTL: 23 hodin
+    -   parametry: `["GTFS", "CIS_STOPS", "OIS_MAPPING", "RUN_NUMBERS"]`
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.ropidgtfs.downloadDatasets
+    -   název: vehicle-positions.ropidgtfs.refreshPrecomputedTables
+    -   název: vehicle-positions.ropidgtfs.refreshPublicGtfsDepartureCache
+    -   název: vehicle-positions.vehiclepositions.refreshGTFSTripData
+    -   název: vehicle-positions.ropidgtfs.refreshGtfsStopsCache
+    -   název: vehicle-positions.ropidgtfs.refreshGtfsTripStopsCache
+    -   název: vehicle-positions.ropidgtfs.remapPresetsToGtfsStops
+-   datové zdroje
+    -   ROPID FTP
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidGTFSMetadataModel `ropidgtfs_metadata`
+    -   RopidGTFSAgencyModel `ropidgtfs_agency`
+    -   RopidGTFSCalendarModel `ropidgtfs_calendar`
+    -   RopidGTFSCalendarDatesModel `ropidgtfs_calendar_dates`
+    -   RouteSubAgencyDto `ropidgtfs_route_sub_agencies`
+    -   RopidGTFSRoutesModel `ropidgtfs_routes`
+    -   RopidGTFSShapesModel `ropidgtfs_shapes`
+    -   RopidGTFSStopTimesModel `ropidgtfs_stop_times`
+    -   RopidGTFSStopsModel `ropidgtfs_stops`
+    -   RopidGTFSTripsModel `ropidgtfs_trips`
+    -   RopidGTFSCisStopsModel `ropidgtfs_cis_stops`
+    -   RopidGTFSCisStopGroupsModel `ropidgtfs_cis_stop_groups`
+    -   RopidGTFSOisModel `ropidgtfs_ois`
+    -   RopidGTFSRunNumbersModel `ropidgtfs_run_numbers`
+    -   RopidGTFSPrecomputedServicesCalendarModel `ropidgtfs_precomputed_services_calendar`
+    -   RopidGTFSPrecomputedMinMaxStopSequencesModel `ropidgtfs_precomputed_minmax_stop_sequences`
+    -   RopidGTFSPrecomputedDeparturesModel `ropidgtfs_precomputed_departures`
+    -   RopidGTFSPrecomputedTripScheduleModel `ropidgtfs_precomputed_trip_schedule`
+    -   RopidGTFSPrecomputedTripConnectionsModel `ropidgtfs_precomputed_trip_connections`
+    -   materialized view `v_ropidgtfs_shapes_for_mvt` (geometrie tras linek pro MVT mapové dlaždice; obnovován na konci úlohy RefreshPrecomputedTables)
+
+#### task _RefreshPrecomputedTables_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidgtfs.refreshPrecomputedTables
+    -   TTL: 59 minut
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   ROPID FTP
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidGTFSMetadataModel `ropidgtfs_metadata`
+    -   RopidGTFSPrecomputedServicesCalendarModel `ropidgtfs_precomputed_services_calendar`
+    -   RopidGTFSPrecomputedMinMaxStopSequencesModel `ropidgtfs_precomputed_minmax_stop_sequences`
+    -   RopidGTFSPrecomputedDeparturesModel `ropidgtfs_precomputed_departures`
+    -   RopidGTFSPrecomputedTripScheduleModel `ropidgtfs_precomputed_trip_schedule`
+    -   RopidGTFSPrecomputedTripConnectionsModel `ropidgtfs_precomputed_trip_connections`
+-   po úspěšném nahrazení precomputed tabulek a vyčištění cache je provedena neblokující obnova
+    materializovaného pohledu `v_ropidgtfs_shapes_for_mvt` (`REFRESH MATERIALIZED VIEW CONCURRENTLY`);
+    pohled používá `CURRENT_DATE` — pokud je přeskočen reload GTFS, zůstane pohled do příštího
+    reloadu s geometriemi předchozího dne
+
+#### task _RefreshPublicGtfsDepartureCacheTask_
+
+Task se stará o aktualizaci cache pro public odjezdy. Pouští se pravidelně cronem a po dokončení načtení nových JŘ.
+
+-  vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidgtfs.refreshPublicGtfsDepartureCache
+    -   TTL: 59 minut
+    -   parametry: `{intervalFromHours, intervalToHours}`
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   ROPID FTP
+-   transformace
+    -   [PublicDepartureCacheTransformation](../src/integration-engine/ropid-gtfs/transformations/PublicDepartureCacheTransformation.ts)
+        -   výsledný cache záznam obsahuje pole `connections` (garantované přestupy – přednačtené z `ropidgtfs_precomputed_trip_connections`, původně z `transfers.txt` kde `transfer_type = 1`) a pole `wheelchair_accessible` (přístupnost vozidla pro vozíčkáře z GTFS `trips.txt`)
+        -   pole `trip_headsign_icons`: pokud je pro danou zastávku spoje vyplněn `stop_headsign`, použije se `stop_headsign_icons` z `ropidgtfs_stop_times`; jinak se použije `headsign_icons` z `ropidgtfs_trips`; výsledek je řetězec dvouznakových kódů (např. `"MbMcSb"`) nebo `null`
+-   data modely
+    -   RopidGTFSPrecomputedDeparturesModel `ropidgtfs_precomputed_departures` (obsahuje JOIN na `ropidgtfs_precomputed_trip_connections_tmp` přes `to_trip_id` a `to_stop_id`)
+
+#### task _SaveStaticData_
+
+Task se stará o aktualizaci statickych dat. Pouští se po dokončení načtení nových JŘ.
+
+-  vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidgtfs.saveStaticData
+    -   TTL: 5 minut
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   Blob storage
+-   transformace
+    -   [DeparturesDirectionTransformation](../src/integration-engine/ropid-gtfs/workers/timetables/tasks/transformations/DeparturesDirectionTransformation.ts)
+    -   [MetroRailtrackDataTransformation](../src/integration-engine/ropid-gtfs/workers/timetables/tasks/transformations/MetroRailtrackDataTransformation.ts)
+    -   `NotPublicVehicles` – data se ukládají přímo do cache klíče `config:notPublicVehicles` přes `NotPublicVehiclesRedisRepository` (žádná DB tabulka)
+-   data modely
+    -   RopidDeparturesDirections `ropid_departures_directions`
+    -   RopidGtfsMetroRailtrackGps `ropidgtfs_metro_railtrack_gps`
+    -   Cache `config:notPublicVehicles` – JSON blob struktury `INotPublicVehicles`:
+        ```json
+        {
+          "tram":  { "registrationNumbers": ["string"] },
+          "road":  { "registrationNumbers": ["string"] },
+          "routeIds": ["string"]
+        }
+        ```
+        `road` pokrývá autobusy i trolejbusy (evidenční čísla se mohou překrývat s tramvajemi, proto jsou oddělena). `routeIds` je whitelist číselných identifikátorů náhradních nebo dočasných linek (např. náhradní autobus za metro při výluce nebo mimořádné události), které se mají zobrazovat i bez platného JŘ spoje.
+
+#### task _RemapPresetsToGtfsStopsTask_
+
+Task přemapuje departure presety na aktuální GTFS zastávky a uloží výsledek do databáze. Pouští se automaticky po každém načtení nových GTFS dat.
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidgtfs.remapPresetsToGtfsStops
+    -   TTL: 59 minut
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   žádné
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidDeparturesPresetsModel `ropid_departures_presets`
+    -   RopidDeparturesPresetsRopidGTFSStopsModel `ropid_departures_presets_ropidgtfs_stops`
+
+#### task _EnsureCacheTask_
+
+Task slouží jako ruční spouštěč obnovení všech cache. Nespouští se automaticky – pouze manuálním odesláním zprávy do fronty.
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidgtfs.ensureCache
+    -   TTL: 5 minut
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.refreshGTFSTripData
+    -   název: vehicle-positions.ropidgtfs.refreshPublicGtfsDepartureCache
+    -   název: vehicle-positions.ropidgtfs.refreshGtfsStopsCache
+    -   název: vehicle-positions.ropidgtfs.refreshGtfsTripStopsCache
+    -   název: vehicle-positions.jis.refreshJISInfotextsCache
+-   datové zdroje
+    -   žádné
+-   transformace
+    -   žádné
+-   data modely
+    -   žádné
+
+
+
+### PresetWorker
+
+#### _Task ~ SavePresetsDataTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidpresets.savePresets
+    -   TTL: 5 minut
+    -   tělo zprávy: obsahuje příchozí json presetů
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   IG /ropidgtfs/presets
+-   transformace
+    -   [RopidDeparturesPresetsTransformation](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/integration-engine/ropid-gtfs/transformations/RopidDeparturesPresetsTransformation.ts)
+-   data modely
+    -   RopidGTFSMetadataModel `ropidgtfs_metadata`,
+    -   RopidDeparturesPresetsModel `ropid_departures_presets`
+
+#### _task: CollectAndSaveLogsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidpresets.collectAndSaveLogs
+    -   TTL: 59 sekund
+    -   parametry: `{ targetMinutes }`
+    -   validační schéma: [LogCollectionSchema](../src/integration-engine/ropid-gtfs/workers/presets/schema/LogCollectionSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.ropidpresets.processAndSendLogs
+-   datové zdroje
+    -   Loki
+-   transformace
+    -   [PresetLogTransformation](../src/integration-engine/ropid-gtfs/workers/presets/transformations/PresetLogTransformation.ts)
+-   data modely
+    -   PresetLogModel `ropid_departures_preset_logs`
+
+#### _task: ProcessAndSendLogsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidpresets.processAndSendLogs
+    -   TTL: 59 sekund
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   Loki
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidDeparturesPresetsModel `ropid_departures_presets`
+    -   PresetLogModel `ropid_departures_preset_logs`
+
+#### _task: CheckForNewDeparturesPresetsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidpresets.checkForNewDeparturesPresets
+    -   TTL: 4 minuty
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.ropidpresets.downloadDeparturesPresets
+-   datové zdroje
+    -   ROPID FTP
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidGTFSMetadataModel `ropidgtfs_metadata`
+
+#### _DownloadDeparturesPresetsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidpresets.downloadDeparturesPresets
+    -   TTL: 4 minuty
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   ROPID FTP
+-   transformace
+    -   [RopidDeparturesPresetsTransformation](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/integration-engine/ropid-gtfs/transformations/RopidDeparturesPresetsTransformation.ts)
+-   data modely
+    -   RopidGTFSMetadataModel `ropidgtfs_metadata`,
+    -   RopidDeparturesPresetsModel `ropid_departures_presets`
+
+### _RopidVYMIWorker_
+
+Worker má na starost přípravu podkladových dat pro infotexty pro odjezdové tabule a GTFS real-time alerty
+
+#### _task: CheckForNewEventsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidvymi.checkForNewEvents
+    -   TTL: 1 minuta
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.ropidvymi.fetchAndProcessEvents
+-   datové zdroje
+    -   ROPID VYMI
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidVYMIMetadataModel `ropidvymi_metadata`
+
+#### _task: FetchAndProcessEventsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.ropidvymi.fetchAndProcessEvents
+    -   TTL: 1 minuta
+    -   parametry: `{ digest, data }`
+    -   validační schéma: [EventFetchOutputValidationSchema](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/integration-engine/ropid-vymi/workers/tasks/schema/EventFetchOutputValidationSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   ROPID VYMI
+-   transformace
+    -   [RopidVYMIEventsTransformation](https://gitlab.com/operator-ict/golemio/code/modules/pid/-/blob/development/src/integration-engine/ropid-vymi/RopidVYMIEventsTransformation.ts)
+-   data modely
+    -   RopidVYMIMetadataModel `ropidvymi_metadata`
+    -   RopidVYMIEventsModel `ropidvymi_events`
+    -   RopidVYMIEventsRoutesModel `ropidvymi_events_routes`
+    -   RopidVYMIEventsStopsModel `ropidvymi_events_stops`
+
+### _VPWorker_
+
+Worker má na starost zpracování a transformaci polohových dat, výpočet zpoždění a přípravu GTFS real-time výstupních dat
+
+#### _task: SaveDataToDBTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.saveDataToDB
+    -   TTL: 5 minut
+    -   parametry: `{ $, zast }`
+    -   validační schéma: [SaveDataToDBSchema](../src/integration-engine/vehicle-positions/workers/vehicle-positions/schema/SaveDataToDBSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.updateGTFSTripId
+-   datové zdroje
+    -   MPVNET
+-   transformace
+    -   [PositionsTransformation](../src/integration-engine//vehicle-positions//workers//vehicle-positions/transformations/PositionsTransformation.ts)
+-   data modely
+    -   VPTripsModel `vehiclepositions_trips`
+    -   CisStopModel `vehiclepositions_cis_stops`
+
+#### _task: UpdateGtfsTripIdTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.updateGTFSTripId
+    -   TTL: 5 minut
+    -   parametry: `{ trips, positions }`
+    -   validační schéma: [UpdateGtfsTripIdSchema](../src/integration-engine/vehicle-positions/workers/vehicle-positions/schema/UpdateGtfsTripIdSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.updateDelay
+-   datové zdroje
+    -   MPVNET
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidGTFSPrecomputedTripScheduleModel `ropidgtfs_precomputed_trip_schedule`
+    -   VPPositionsModel `vehiclepositions_positions`
+
+#### _task: RefreshGtfsTripDataTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.refreshGTFSTripData
+    -   TTL: 10 minut
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   ROPID FTP
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidGTFSPrecomputedTripScheduleModel `ropidgtfs_precomputed_trip_schedule`
+    -   VPTripsModel `vehiclepositions_trips`
+    -   VPTripWithLastPositionModel `v_vehiclepositions_all_trips_with_last_position`
+
+#### _task: UpdateRunsGtfsTripIdTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.updateRunsGTFSTripId
+    -   TTL: 5 minut
+    -   parametry: `{ run, run_message, isNotPublic?, notPublicVehicleRouteType? }`
+        -   `run` - běh vozidla (ICommonRunsModel s volitelným notPublicVehicleRouteType)
+        -   `run_message` - zpráva o pozici vozidla
+        -   `isNotPublic` - volitelný příznak, zda se jedná o neveřejné vozidlo (např. náhradní autobus)
+        -   `notPublicVehicleRouteType` - volitelný typ vozidla (0=tram, 3=bus) pro správné mapování typu u ad-hoc vozidel
+    -   validační schéma: [UpdateRunsGtfsTripIdSchema](../src/integration-engine/vehicle-positions/workers/vehicle-positions/schema/UpdateRunsGtfsTripIdSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.updateDelay
+-   datové zdroje
+    -   CHAPS TCP
+-   transformace
+    -   oběh a nalezené GTFS scheduled trips se transformují na trips [TripsMapper.mapCommonRunToDto](../src/integration-engine/vehicle-positions/workers/vehicle-positions/data-access/helpers/TripsMapper.ts) a pozice [PositionsMapper.mapCommonRunToDto](../src/integration-engine/vehicle-positions/workers/vehicle-positions/data-access/helpers/PositionsMapper.ts) pro frontu `vehiclepositions.updateDelay`
+-   data modely
+    -   RopidGTFSPrecomputedTripScheduleModel `ropidgtfs_precomputed_trip_schedule`
+    -   VPTripsModel `vehiclepositions_trips`
+    -   VPPositionsModel `vehiclepositions_positions`
+
+#### _task: UpdateDelayTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.updateDelay
+    -   TTL: 50 sekund (včetně zpracování v předchozích frontách)
+    -   parametry: `{ updatedTrips, positions, schedule }`
+    -   validační schéma: [UpdateDelaySchema](../src/integration-engine/vehicle-positions/workers/vehicle-positions/schema/UpdateDelaySchema.ts)
+    -   očekává parametrech zprávy `timestamp` s časovou značkou z první fronty, která obdržela nová data např. saveDataToDB
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.propagateDelay
+-   datové zdroje
+    -   MPVNET, CHAPS TCP
+-   transformace
+    -   determinace pozic tripů v rámci jednoho GTFS block id (platí pouze pro některé vlakové linky)
+    -   [PositionsManager.computePositions](../src/integration-engine/vehicle-positions/workers/vehicle-positions/helpers/PositionsManager.ts#L32): obohacení pozicových dat, aproximace pozice, dopočet zpoždění
+-   data modely
+    -   VPTripsModel `vehiclepositions_trips`
+    -   VPPositionsModel `vehiclepositions_positions`
+
+#### _task: ProcessRegionalBusPositionsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.processRegionalBusPositions
+    -   TTL: 3 minuty
+    -   parametry: `{ updatedTrips }`
+    -   validační schéma: [UpdateDelaySchema](../src/integration-engine/vehicle-positions/workers/vehicle-positions/schema/UpdateDelaySchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.propagateDelay
+-   datové zdroje
+    -   TELMAX TCP
+-   transformace
+    -   [RegionalBusPositionsManager.computePositions](../src/integration-engine/vehicle-positions/workers/vehicle-positions/helpers/regional-bus/RegionalBusPositionsManager.ts): obohacení pozicových dat, aproximace pozice, dopočet zpoždění
+-   data modely
+    -   VPTripsModel `vehiclepositions_trips`
+    -   VPPositionsModel `vehiclepositions_positions`
+
+#### _task: PropagateDelayTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.propagateDelay
+    -   TTL: 5 minut
+    -   parametry: `{ processedPositions, trips }`
+    -   validační schéma: [PropagateDelaySchema](../src/integration-engine/vehicle-positions/workers/vehicle-positions/schema/PropagateDelaySchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   vehicle-positions.vehiclepositions.propagateTrainDelay
+-   datové zdroje
+    -   MPVNET, CHAPS TCP, TELMAX TCP
+-   transformace
+    -   [mapDelayedPositionsToRunTrips](../src/integration-engine/vehicle-positions/workers/vehicle-positions/tasks/PropagateDelayTask.ts#L447): transformace výstupních pozic z updateDelay na oběhy
+    -   [propagateDelayForGtfsTrip](../src/integration-engine/vehicle-positions/workers/vehicle-positions/tasks/PropagateDelayTask.ts#L474): přepočet zpoždění u spojů se zpožděním před tratí
+    -   VPPositionsModel `vehiclepositions_positions`
+
+#### _task: PropagateTrainDelayTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.propagateTrainDelay
+    -   TTL: 5 minut
+        -   validační schéma: [PropagateDelaySchema](../src/integration-engine/vehicle-positions/workers/vehicle-positions/schema/PropagateTrainDelaySchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   MPVNET
+-   popis
+    -   propaguje zpoždění pro následující blokové spoje
+
+#### _task: DataRetentionTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.dataRetention
+    -   TTL: 10 minut
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   MPVNET, CHAPS TCP
+-   transformace
+    -   žádné
+-   data modely
+    -   VPPositionsModel `vehiclepositions_positions`
+    -   VPPositionsHistoryModel `vehiclepositions_positions_history`
+    -   VPTripsModel `vehiclepositions_trips`
+    -   VPTripsHistoryModel `vehiclepositions_trips_history`
+    -   CisStopModel `vehiclepositions_cis_stops`
+
+#### _task: RefreshPublicTripCacheTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.refreshPublicTripCache
+    -   TTL: 10s
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   `vehicle-positions.vehiclepositions.refreshPublicTripCache` task se spouští sám sebe a cron plní doplňující funkci.
+-   popis
+    -   před samotným spuštěním se zkontroluje pomocí semaforu zdali task již někde neběží
+    -   připraví zjednodušené informace o aktuálních pozicích, které se odešlou do redisu
+    -   pomocí pub/sub se pak pošle do og informace o novém setu v redisu
+-   data modely
+    -   VPPositionsModel `vehiclepositions_positions`
+    -   VPTripsModel `vehiclepositions_trips`
+
+#### _task: RefreshPublicStopTimeCacheTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositions.refreshPublicStopTimeCache
+    -   TTL: 10s
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   `vehicle-positions.vehiclepositions.refreshPublicStopTimeCache` task se spouští sám sebe a cron plní doplňující funkci.
+-   popis
+    -   před samotným spuštěním se zkontroluje pomocí semaforu zdali task již někde neběží
+    -   připraví informace o historických a predikovaných zpožděních aktivních spojů, které se odešlou do redisu
+-   data modely
+    -   VPPositionsModel `vehiclepositions_positions`
+    -   VPTripsModel `vehiclepositions_trips`
+    -   DescriptorModel `vehiclepositions_vehicle_descriptors`
+    -   GtfsShapesModel `ropidgtfs_shapes`
+    -   PublicStopTimeModel `v_public_vehiclepositions_combined_stop_times`
+
+### _RunsWorker_
+
+Worker má na starost zpracování a transformaci TCP oběhů
+
+#### _task: SaveTramRunsToDBTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositionsruns.saveTramRunsToDB
+    -   TTL: 3 minuty
+    -   parametry: `{ M: V: $[] }`
+    -   validační schéma: [CommonRunsSchema](../src/integration-engine/vehicle-positions/workers/runs/schema/CommonRunsSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.updateRunsGTFSTripId
+-   datové zdroje
+    -   CHAPS TCP
+-   transformace
+    -   [CommonRunsMessagesTransformation](../src/integration-engine/vehicle-positions/workers/runs/transformations/CommonRunsMessagesTransformation.ts)
+-   data modely
+    -   CommonRunsModel `vehiclepositions_runs`
+    -   CommonRunsMessagesModel `vehiclepositions_runs_messages`
+
+#### _task: SaveBusRunsToDBTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositionsruns.saveBusRunsToDB
+    -   TTL: 2 minuty
+    -   parametry: `{ M: V: $[] }`
+    -   validační schéma: [CommonRunsSchema](../src/integration-engine/vehicle-positions/workers/runs/schema/CommonRunsSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.updateRunsGTFSTripId
+-   datové zdroje
+    -   CHAPS TCP
+-   transformace
+    -   [CommonRunsMessagesTransformation](../src/integration-engine/vehicle-positions/workers/runs/transformations/CommonRunsMessagesTransformation.ts)
+-   data modely
+    -   CommonRunsModel `vehiclepositions_runs`
+    -   CommonRunsMessagesModel `vehiclepositions_runs_messages`
+
+#### _task: SaveMetroRunsToDBTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositionsruns.saveMetroRunsToDB
+    -   TTL: 3 minuty
+    -   parametry: `{ m: { $, vlak } }`
+    -   validační schéma: [MetroRunsSchema](../src/integration-engine/vehicle-positions/workers/runs/schema/MetroRunsSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositionsruns.processMetroRunMessages
+-   datové zdroje
+    -   CHAPS TCP
+-   transformace
+    -   [MetroRunsMessagesTransformation](../src/integration-engine/vehicle-positions/workers/runs/transformations/MetroRunsMessagesTransformation.ts)
+-   data modely
+    -   MetroRunsMessagesModel `vehiclepositions_metro_runs_messages`
+
+#### _task: ProcessMetroRunsMessagesTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositionsruns.processMetroRunMessages
+    -   TTL: 10 minut
+    -   parametry: `{ routeName, messages }`
+    -   validační schéma: [MetroTransformedRunsSchema](../src/integration-engine/vehicle-positions/workers/runs/tasks/schema/MetroTransformedRunsSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.updateDelay
+-   datové zdroje
+    -   CHAPS TCP
+-   transformace
+    -   [MetroRunsMessageProcessingTransformation](../src/integration-engine/vehicle-positions/workers/runs/tasks/transformations/MetroRunsMessageProcessingTransformation.ts), dále se oběhy a nalezené GTFS scheduled trips transformují na trips [TripsMapper.mapMetroRunToDto](../src/integration-engine/vehicle-positions/workers/vehicle-positions/data-access/helpers/TripsMapper.ts)s) a pozice [PositionsMapper.mapMetroRunToDto](../src/integration-engine/vehicle-positions/workers/vehicle-positions/data-access/helpers/PositionsMapper.ts) pro frontu `vehiclepositions.updateDelay`
+-   data modely
+    -   MetroRailtrackGPSModel `ropidgtfs_metro_railtrack_gps`
+    -   RopidGTFSScheduledTripsModel `ropidgtfs_precomputed_trip_schedule`
+    -   VPPositionsModel `vehiclepositions_positions`
+    -   VPTripsModel `vehiclepositions_trips`
+    -   CommonRunsModel `vehiclepositions_runs`
+
+#### _task: SaveArrivaCityRunsToDB_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositionsruns.saveArrivaCityRunsToDB
+    -   TTL: 3 minuty
+    -   parametry: `{ M: V: $[] }`
+    -   validační schéma: [RegionalBusRunsSchema](../src/integration-engine/vehicle-positions/workers/runs/schema/RegionalBusRunsSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositionsruns.processRegionalBusRunMessages
+-   datové zdroje
+    -   TELMAX TCP
+-   transformace
+    -   [RegionalBusRunsMessagesTransformation](../src/integration-engine/vehicle-positions/workers/runs/transformations/RegionalBusRunsMessagesTransformation.ts)
+-   data modely
+    -   RegionalBusRunsMessagesModel `vehiclepositions_regional_bus_runs_messages`
+
+#### _task: ProcessRegionalBusRunMessagesTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositionsruns.processRegionalBusRunMessages
+    -   TTL: 5 minut
+    -   parametry: `{ messages }`
+    -   validační schéma: [RegionalBusTransformedRunsValidationSchema](../src/integration-engine/vehicle-positions/workers/runs/schema/RegionalBusTransformedRunsSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   název: vehicle-positions.vehiclepositions.processRegionalBusPositions
+-   datové zdroje
+    -   TELMAX TCP
+-   transformace
+    -   Oběhy a nalezené GTFS scheduled trips transformují na trips [TripsMapper.mapRegionalBusRunToDto](../src/integration-engine/vehicle-positions/workers/vehicle-positions/data-access/helpers/TripsMapper.ts) a pozice [PositionsMapper.mapRegionalBusRunToDto](../src/integration-engine/vehicle-positions/workers/vehicle-positions/data-access/helpers/PositionsMapper.ts) pro frontu `vehiclepositions.processRegionalBusPositions`
+-   data modely
+    -   RopidGTFSScheduledTripsModel `ropidgtfs_precomputed_trip_schedule`
+    -   RouteSubAgencyModel `ropidgtfs_route_sub_agencies`
+    -   RunNumberModel `ropidgtfs_run_numbers`
+    -   DescriptorModel `vehiclepositions_vehicle_descriptors`
+    -   VPPositionsModel `vehiclepositions_positions`
+    -   VPTripsModel `vehiclepositions_trips`
+
+### _GtfsRealTimeWorker_
+
+Worker má na starost generování souborů s realtime daty pro `gtfsrt` endpointy
+
+#### _task: GenerateFilesTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehiclepositionsgtfsrt.generateFiles
+    -   TTL: 29 sekund
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   MPVNET, CHAPS TCP + UDP, ROPID FTP, ROPID VYMI
+-   transformace
+    -   žádné
+-   data modely
+    -   RopidGTFSStopTimesModel `ropidgtfs_stop_times`
+    -   RopidVYMIEventsModel `ropidvymi_events`
+    -   VPTripsModel `vehiclepositions_trips`
+    -   VPPositionsModel `vehiclepositions_positions`
+
+**`wheelchairAccessible` ve VehicleDescriptor**
+
+Pole `wheelchairAccessible` je součástí standardního `VehicleDescriptor` ve feedech `vehicle_positions.pb` a `pid_feed.pb`:
+
+| Interní hodnota | Proto enum |
+|---|---|
+| `null` | `WHEELCHAIR_ACCESSIBLE_UNSPECIFIED = 0` |
+| `true` | `WHEELCHAIR_ACCESSIBLE = 1` |
+| `false` | `WHEELCHAIR_INACCESSIBLE = 2` |
+
+Zdrojem je pole `wheelchair_accessible` z tabulky `vehiclepositions_trips` (přenášené přes `IGtfsRtTripDto`). Vedle standardního pole zůstává zachováno rozšíření `.transit_realtime.ovapiVehicleDescriptor.wheelchairAccessible` s původní boolean/null hodnotou.
+
+**Určení zpoždění v trip_updates.pb**
+
+Predikce odjezdů probíhá podle vzorce:
+
+    departure_delay = arrival_delay - min( max(0, arrival_delay), max(0, stop_dwell_time_seconds - 60) );
+    departure_delay = if provider_source_type = http then max(0, departure_delay) else departure_delay;
+
+-   Poslední projetá zastávka
+    -   arrival_delay - zpoždění na příjezdu v poslední zastávce
+    -   departure_delay - zpoždění na odjezdu v poslední zastávce
+-   Následující zastávka
+    -   arrival_delay - aktuální zpoždění spoje
+    -   departure_delay - predikce podle vzorce výše
+-   Všechny další zastávky až po konečnou
+    -   arrival_delay - zpoždění na odjezdu z předchozí zastávky (departure_delay předchozího záznamu)
+    -   departure_delay - predikce podle vzorce výše
+
+```js
+// stopTimeUpdate[]
+[
+    { arrival: {}, departure: { delay: 60 }, stopSequence: 2, stopId: "U474Z4P" },
+    { arrival: { delay: 30 }, departure: { delay: 30 }, stopSequence: 3, stopId: "U603Z3P" }, // dwell time 0s
+    { arrival: { delay: 30 }, departure: { delay: 30 }, stopSequence: 4, stopId: "U665Z2P" }, // dwell time 0s
+    { arrival: { delay: 30 }, departure: { delay: 20 }, stopSequence: 5, stopId: "U332Z2P" }, // dwell time 70s
+    { arrival: { delay: 20 }, departure: { delay: 20 }, stopSequence: 6, stopId: "U467Z2P" }, // dwell time 0s
+    { arrival: { delay: 20 }, departure: { delay: 0 }, stopSequence: 7, stopId: "U740Z3P" }, // dwell time 100s
+    { arrival: { delay: 0 }, departure: { delay: 0 }, stopSequence: 8, stopId: "U78Z3P" }, // dwell time 0s
+    { arrival: { delay: 0 }, departure: { delay: 0 }, stopSequence: 9, stopId: "U675Z3P" }, // dwell time 0s
+];
+```
+
+**Strukturované nástupištní `stop_id` u vlaků (GTFS-RT platform fields)**
+
+Pro vlakové spoje, u nichž je v RT datech k dispozici konkrétní nástupišťě, se do feedů emitují dva strukturované GTFS-RT identifikátory. Toto chování je podmíněno typem trasy (`gtfs_route_type = 2`, vlak) a dostupností pole `assigned_stop_id`.
+
+Tok dat: pohled `v_public_vehiclepositions_combined_stop_times` (sloupec `assigned_stop_id`, snake_case) → cache `IPublicStopTimeCacheDto.assigned_stop_id` (snake_case) → `GenerateFilesTask` (camelCase v protobuf polích).
+
+Pohled `v_public_vehiclepositions_combined_stop_times` odvozuje `assigned_stop_id` self-joinem na tabulku `ropidgtfs_stops`: hledá záznam, kde `parent_station` odpovídá stanici obsluhované zastávky, `platform_code` se rovná `cis_stop_platform_code` z RT dat a `location_type = 0` (fyzická nástupištní zastávka). Pokud takový záznam neexistuje, je `assigned_stop_id` null.
+
+_TripUpdate — StopTimeUpdate_
+
+Podmínka emise: `assigned_stop_id != null` (loose porovnání pokrývá i `undefined` v případě starých Redis záznamů bez tohoto pole).
+
+Při splnění podmínky:
+- `StopTimeUpdate.stopId` je nastaven na hodnotu `assigned_stop_id` (přepis oproti výchozímu plánovanému `stop_id`)
+- `StopTimeUpdate.stopTimeProperties.assignedStopId` je nastaven na totožnou hodnotu `assigned_stop_id`
+- `StopTimeUpdate.stopSequence` zůstává beze změny
+
+Při nesplnění podmínky (unmatched zastávka, nespárované nástupiště) nebo pro jiné typy vozidel než vlak:
+- `StopTimeUpdate.stopId` zůstává původní plánované `stop_id` ze GTFS
+- `StopTimeUpdate.stopTimeProperties` se do feedu nevkládá
+- výstup je byte-for-byte identický s chováním před implementací této funkce
+
+_VehiclePosition — stopId_
+
+Podmínka emise: zastávka, jejíž `stop_sequence` odpovídá `last_stop_sequence` vozidla (`last_stop_sequence` null → nenastavuje se), je vlakového typu a má `assigned_stop_id != null`.
+
+Při splnění podmínky:
+- `VehiclePosition.stopId` je nastaven na `assigned_stop_id` konkrétní nástupištní zastávky
+
+Pro ostatní zastávky v rámci spoje nebo při nesplnění podmínky:
+- `VehiclePosition.stopId` se nenastavuje
+
+_Textová pole actualTrack / scheduledTrack_
+
+Pole `actualTrack` a `scheduledTrack` v custom rozšíření `.transit_realtime.ovapiStopTimeUpdate` zůstávají nezměněna a jsou emitována ve všech případech, kde tomu tak bylo doposud. Strukturovaná nástupištní pole jsou pouze aditivní — nepřepisují ani neruší textový výstup.
+
+### _DescriptorWorker_
+
+Worker má na starost stahování informací o vozidlech (např. dostupnost klimatizace nebo USB zásuvek) a jejich uložení do databáze
+
+#### _task: RefreshDescriptorsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.vehicledescriptors.refreshDescriptors
+    -   TTL: 10 minut
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   Seznam Autobusu API
+-   transformace
+    -   [DescriptorTransformation](../src/integration-engine/vehicle-positions/workers/vehicle-descriptors/transformations/DescriptorTransformation.ts)
+-   data modely
+    -   VehicleDescriptorModel `vehiclepositions_vehicle_descriptors`
+
+### _DataRetentionWorker_
+
+Worker má na starost retenci dat tabulek Azure Table Storage
+
+#### _task: DeleteDataTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.dataretention.deleteData
+    -   TTL: 15 minut
+    -   parametry: `{ targetHours, repoName }`
+    -   validační schéma: [DataDeletionSchema](../src/integration-engine/shared/schema/DataDeletionSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   žádné
+-   transformace
+    -   žádné
+-   data modely
+    -   podle [`RepositoryTableNameEnum`](../src/integration-engine/data-retention/workers/constants/RepositoryTableNameEnum.ts)
+
+#### _task: TableStorageRetentionTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.dataretention.deleteMonthOldStorageData
+    -   TTL: 1 hodina
+    -   parametry: `{ tableName }`
+    -   validační schéma: [TableStorageRetentionSchema](../src/integration-engine/data-retention/workers/schema/TableStorageRetentionSchema.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   CHAPS TCP, ukládane v TCP IG
+-   transformace
+    -   žádné
+-   data modely
+    -   žádné
+
+### _JISWorker_
+
+Worker má na starost stahování VYMI (JIS) událostí a infotextů, jejich transformaci a uložení do databáze
+
+#### _task: RefreshJISEventsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.jis.refreshJISEvents
+    -   TTL: 20 sekund
+    -   parametry: `{ data: IJISEvent[]; shouldTriggerWebhooks?: boolean }` ([IJISEvent[]](../src/schema-definitions/jis/datasources/interfaces/IJISEvent.ts))
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   `jis.updateEventWebhook`
+-   datové zdroje
+    -   JIS Events
+-   transformace
+    -   [JISEventsTransformation](../src/integration-engine/jis/transformations/JISEventsTransformation.ts)
+-   data modely
+    -   JISEventsModel `jis_events`
+    -   JISEventsRopidGTFSRoutesModel `jis_events_ropidgtfs_routes`
+-   poznámky k datovému modelu
+    -   pole `effects` je pole až 3 unikátních řetězců; v GTFS-RT `Alert.effect` se použije pouze `effects[0]`, zbývající hodnoty jsou dostupné pouze v custom-format exportu
+    -   pole `cause_detail` je volný text zpřesňující příčinu události; může být `null`
+    -   pole `cause` obsahuje překlady do češtiny i angličtiny; anglické hodnoty jsou zahrnuty i ve výstupu GTFS-RT alert feedu
+    -   pole `header_text`, `description_text`, `description_html` a `cause` mají navíc německou mutaci (`de`) v custom-format exportu a ve webhooku; `cause_detail`, `effect_detail`, `url` a `effects` němčinu nemají (VYMI ji tam neposílá) — viz [docs/jis/index.md](jis/index.md#německá-jazyková-mutace-de)
+    -   nové pole `attachments` (JSONB, nullable) — dokumenty a odkazy přiložené k události (`{url, name: {cs, en, de}}`); vložené obrázky se nepropagují — viz [docs/jis/index.md](jis/index.md#attachments-přílohy)
+
+#### _task: RefreshJISInfotextsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.jis.refreshJISInfotexts
+    -   TTL: 20 sekund
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   JIS Infotexts
+-   transformace
+    -   [JISInfotextsTransformation](../src/integration-engine/jis/transformations/JISInfotextsTransformation.ts)
+-   data modely
+    -   JISInfotextsModel `jis_infotexts`
+    -   JISInfotextsRopidGTFSStopsModel `jis_infotexts_ropidgtfs_stops`
+#### _task: UpdateEventWebhookTask_
+- Popis tasku
+    - Task posila POST requestem aktualizace dat o změněných událostech hned po přijetí z VYMI a uložení do VP databáze na webhooky definované v module config hodnotami `jis.webhooks.eventUpdate.targets.*`
+    - Jako fallback při výpadku webhooku se muze dotazat uzivatel na `/v1/jis/events/custom-format`
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.jis.updateEventWebhook
+    -   TTL: 1 minuta
+    -   parametry: [IJISEvent[]](../src/schema-definitions/jis/datasources/interfaces/IJISEvent.ts)
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   žádné
+-   datové zdroje
+    -   JIS Events
+-   transformace
+    -   [UpdateEventWebhookTransformation](../src/integration-engine/jis/transformations/UpdateEventWebhookTransformation.ts)
+-   data modely
+    -   RopidGTFSRoutes `ropidgtfs_routes`
+
+#### _task: FetchJISEventsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.jis.fetchJISEvents
+    -   TTL: 20 sekund
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   `jis.refreshJISEvents`
+-   datové zdroje
+    -   VYMI
+-   transformace
+    -   žádné
+-   data modely
+    -   žádné
+
+#### _task: FetchJISInfotextsTask_
+
+-   vstupní rabbitmq fronta
+    -   název: vehicle-positions.jis.fetchJISInfotexts
+    -   TTL: 20 sekund
+    -   parametry: žádné
+-   závislé fronty (do kterých jsou odesílány zprávy z metody workeru)
+    -   `jis.refreshJISInfotexts`
+-   datové zdroje
+    -   VYMI
+-   transformace
+    -   žádné
+-   data modely
+    -   žádné
+
+## Uložení dat
+
+-   typ databáze
+    -   PSQL
+-   databázové schéma
+
+    -   GTFS JŘ<br/>
+        ![pid scheduled diagram](./assets/pid_scheduled_erd.png)
+    -   GTFS předpočítatné tabulky<br/>
+        ![pid precomputed diagram](./assets/pid_precomputed_erd.png)
+    -   Preset logy a statické tabulky<br/>
+        ![pid preset logs and static diagram](./assets/pid_preset_logs_and_static_erd.png)
+    -   VYMI<br/>
+        ![pid vymi diagram](./assets/pid_vymi_erd.png)
+    -   Polohy vozů (tabulky) <br/>
+        ![pid vp diagram](./assets/pid_vp_erd.png)
+    -   Polohy vozů (views) <br/>
+        ![pid vp view diagram](./assets/pid_vp_view_erd.png)
+    -   Polohy vozů (historie spojů podle projetých zastávek) <br/>
+        ![pid vp stop time history diagram](./assets/pid_vp_st_hist_erd.png)
+    -   Popis vozidel<br/>
+        ![pid vp desc diagram](./assets/pid_vp_desc_erd.png)
+    -   Zastávky RT spojů (pouze MPV)<br/>
+        ![pid vp cis  diagram](./assets/pid_vp_cis_erd.jpg)
+    -   JIS infotexty<br/>
+        ![pid jis diagram](./assets/pid_jis_erd.png)
+
+-   retence dat
+    -   jízdní řády se generují 1-2x denně na 14 dní dopředu
+    -   polohová data si uchováváme 24 hodin (30 minut od poslední aktualizace, poté v historických tabulkách)
+    -   popis vozidel se nepromazává – přetrvávají do přepsání novými daty (fixní TTL bylo odstraněno)
+    -   preset logy si uchováváme 8 hodin
+    -   JIS události a infotexty si uchováváme neomezeně
+
+## Input API
+
+### Obecné
+
+-   OpenAPI v3 dokumentace
+    -   zdrojový soubor: [openapi-input.yaml](./openapi-input.yaml)
+    -   rabin: https://rabin.golemio.cz/pid/input-gateway/docs/openapi/
+    -   golem: https://api.golemio.cz/pid/input-gateway/docs/openapi/
+-   api je neveřejné
+-   postman kolekce
+    -   TBD
+
+### Vehicle Positions
+
+#### _/vehiclepositions_
+
+-   cílová rabbitmq fronta
+    -   vehicle-positions.vehiclepositions.saveDataToDB
+-   data nám pravidelně přichází z MPVNETu
+
+### GTFS
+
+#### _/ropidgtfs/presets_
+
+-   cílová rabbitmq fronta
+    -   vehicle-positions.ropidpresets.savePresets
+-   data nám budou zasílána z dohledového centra
+
+## Output API
+
+### Obecné
+
+-   OpenAPI v3 dokumentace
+    -   zdrojový soubor: [openapi-output.yaml](./openapi-output.yaml)
+    -   rabin: https://rabin.golemio.cz/pid/docs/openapi/
+    -   golem: https://api.golemio.cz/pid/docs/openapi/
+-   všechny endpointy jsou mountované pod prefixem `/v1/public-transport` (viz `PublicTransportRouter` v `src/output-gateway/shared/PublicTransportRouter.ts`)
+-   GTFS-RT data jsou veřejná, zbývající endpointy jsou k dispozici všem registrovaným uživatelům
+-   v rozsahu modulu public-transport jsou pouze GTFS Static, Vehicle Positions a GTFS Realtime; PID departure/transfer boards, `/public/*` a JIS endpointy jsou zakomentované v `src/output-gateway/index.ts` (sekce níže jsou ponechané pro referenci)
+-   postman kolekce
+    -   TBD
+
+### GTFS v1
+
+#### _/v1/public-transport/gtfs/services_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_calendar`
+
+#### _/v1/public-transport/gtfs/routes_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_routes`
+
+#### _/v1/public-transport/gtfs/routes/{id}_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_routes`
+
+#### _/v1/public-transport/gtfs/trips_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_trips`, `ropidgtfs_stop_times`, `ropidgtfs_calendar`
+
+#### _/v1/public-transport/gtfs/trips/{id}_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_trips`, `ropidgtfs_stop_times`, `ropidgtfs_stops`, `ropidgtfs_shapes`, `ropidgtfs_calendar`, `ropidgtfs_routes`
+
+#### _/v1/public-transport/gtfs/shapes/{id}_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_shapes`
+
+#### _/v1/public-transport/gtfs/stops_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_stops`, `ropidgtfs_cis_stops`
+-   dodatečná transformace: Feature collection
+
+#### _/v1/public-transport/gtfs/stops/{id}_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_stops`, `ropidgtfs_cis_stops`
+-   dodatečná transformace: Feature
+
+#### _/v1/public-transport/gtfs/stoptimes/{id}_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_stop_times`, `ropidgtfs_stops`, `ropidgtfs_calendar`, `ropidgtfs_trips`
+
+### Vehicle Positions v1
+
+#### _/v1/public-transport/vehiclepositions_
+
+-   zdrojové tabulky
+    -   `v_vehiclepositions_all_trips_with_last_position` (`vehiclepositions_positions`, `vehiclepositions_trips`)
+    -   `vehiclepositions_vehicle_types`
+    -   `vehiclepositions_vehicle_descriptors`
+-   dodatečná transformace: Feature collection
+-   je použit `CompressionByDefaultMiddleware` a odpovědi jsou tak na output gateway komprimovány i pokud klient explicitně nepovolí komprimaci vhodnou hodnotou hlavičky `Accept-Encoding` (lze však komprimaci explicitně zakázat hodnotou `identity`)
+-   Default limit je nastaven pro vsechny role na 100 v admin panelu
+
+#### _/v1/public-transport/vehiclepositions/{gtfsTripId}_
+
+-   zdrojové tabulky
+    -   `v_vehiclepositions_all_trips_with_last_position` (`vehiclepositions_positions`, `vehiclepositions_trips`)
+    -   `v_vehiclepositions_all_processed_positions` (`vehiclepositions_positions`)
+    -   `vehiclepositions_vehicle_types`
+    -   `vehiclepositions_vehicle_descriptors`
+-   dodatečná transformace: Feature
+-   je použit `CompressionByDefaultMiddleware` a odpovědi jsou tak na output gateway komprimovány i pokud klient explicitně nepovolí komprimaci vhodnou hodnotou hlavičky `Accept-Encoding` (lze však komprimaci explicitně zakázat hodnotou `identity`)
+
+### Vehicle Positions GTFS RT v1
+
+#### _/v1/public-transport/vehiclepositions/gtfsrt/trip_updates.pb_
+
+-   načtení souboru z Redis cache
+    -   HGET files:gtfsRt trip_updates.pb
+
+#### _/v1/public-transport/vehiclepositions/gtfsrt/vehicle_positions.pb_
+
+-   načtení souboru z Redis cache
+    -   HGET files:gtfsRt vehicle_positions.pb
+
+#### _/v1/public-transport/vehiclepositions/gtfsrt/pid_feed.pb_
+
+-   načtení souboru z Redis cache
+    -   HGET files:gtfsRt pid_feed.pb
+
+#### _/v1/public-transport/vehiclepositions/gtfsrt/alerts.pb_
+
+-   načtení souboru z Redis cache
+    -   HGET files:gtfsRt alerts.pb
+
+### PID Departure Boards v2
+
+> **Vypnuto** – endpoint není v rozsahu modulu public-transport, router je zakomentovaný v `src/output-gateway/index.ts`.
+
+#### _/v2/pid/departureboards_
+
+-   zdrojové tabulky
+    -   `ropidgtfs_precomputed_departures`, `ropidgtfs_stops`, `ropidgtfs_cis_stops`, `jis_infotexts`, `jis_infotexts_ropidgtfs_stops`, `ropid_departures_directions`, `vehiclepositions_positions`, `vehiclepositions_trips`
+-   odpověď obsahuje hlavičku `X-Golemio-Preset-Metadata: airConditionPossible=0|1`
+    -   `1` pokud byl zadán query parametr `airCondition` s pravdivou hodnotou, `0` jinak
+    -   slouží monitorovacím systémům (preset systémy monitorovacího centra ROPID) k detekci aktivního filtrování dle klimatizace
+-   kód nástupiště (`platform_code`)
+    -   **vlaky**: preferuje se CIS hodnota `cis_stop_platform_code` uložená z MPVNet zpráv (`PlatformCodeResolver`); MPVNet atribut `$.stan` je před uložením oříznut na první platný segment (viz [parsování `stan` u vlaků](../processing/input_realtime_data/http_mpvnet.md#parsování-stanoviště-stan-u-vlaků))
+    -   **ostatní typy**: používá se GTFS `platform_code` ze `stop_times.txt`
+
+### PID Departure Boards v3
+
+> **Vypnuto** – endpoint není v rozsahu modulu public-transport, router je zakomentovaný v `src/output-gateway/index.ts`.
+
+#### _/v3/pid/transferboards_
+
+-   načte odjezdy pro přestupní tabule ve vozidlech a aktivní infotexty exportované z aplikace VYMI (JIS) Infotexty
+
+### PID Departure Boards v4
+
+> **Vypnuto** – endpoint není v rozsahu modulu public-transport, router je zakomentovaný v `src/output-gateway/index.ts`.
+
+#### _/v4/pid/transferboards_
+
+-   načte odjezdy pro přestupní tabule ve vozidlech na základě aktuální polohy vozidla a aktivní infotexty exportované z aplikace VYMI (JIS) Infotexty
+-   parametry
+    -   `aswId` + `vehicleRegistrationNumber` + `routeType` – identifikace zastávky a vozidla přes ASW číselník (vzájemně se vylučuje s `cisId`+`tripNumber`)
+    -   `cisId` + `tripNumber` – identifikace zastávky a spoje přes CIS číselník (zatím neimplementováno, vrací 501)
+    -   `timeFrom` – volitelný ISO8601 čas příjezdu (pokud není zadán, použije se reálný čas příjezdu z RT dat)
+    -   `limit` – volitelný počet odjezdů (výchozí 8, max 30)
+-   cachováno na 5 sekund (stale-while-revalidate 5 sekund)
+-   zdrojové cache záznamy
+    -   `gtfsStopsCache:*` – převod ASW node ID na GTFS stop_id
+    -   `gtfsTripStopsCache:*` – předpočítaný seznam zastávek spoje (`[stop_id, stop_name][]`), používáno ve filtru směru linek (`findRelevantTripIdsFromLines`)
+    -   `gtfsDelayComputation:*` – predikovaný čas příjezdu vozidla na zastávku
+    -   `vpPublicCache:*` – aktuální poloha a zpoždění vozidla
+    -   `gtfsPublicDepartureCache:*` – statické odjezdy ze zastávek (vč. `connections`, `wheelchair_accessible` a volitelných `flags`)
+    -   `vpPublicStopTimeCache:*` – live zastávkové časy pro spoje se známou polohou (platform_code u vlaků)
+    -   `jisCache:*` – aktivní infotexty pro dané zastávky
+-   načítání odjezdů z cache (`gtfsPublicDepartureCache`)
+    -   z každé zastávky se načte `max(120, min(180, limit × 15))` položek v časovém okně `[delayedTimeFrom − 61 min, delayedTimeFrom + 30 min]`; okno je ukotveno na `delayedTimeFrom` (predikovaný čas příjezdu, včetně záporného zpoždění = předjíždění); lookback 61 minut zajišťuje, že se zachytí i navazující spoj, jehož plánovaný odjezd je v minulosti, ale díky vlastnímu zpoždění (až 60 minut) dorazí na zastávku až po příjezdu aktuálního vozidla
+    -   ihned po načtení se aplikuje pre-filter: odjezdy autobusů, tramvají a trolejbusů ze zastávek s jiným názvem než aktuální zastávka jsou zahozeny; metro/vlak/přívoz/lanovka procházejí vždy; odjezdy s neprázdným polem `connections[]` jsou zachovány bez ohledu na název zastávky (potenciální garantovaný přestup)
+-   garantované přestupy (`is_guaranteed_transfer`)
+    -   označují odjezdy, které na příjezd aktuálního spoje čekají – detekováno z pole `connections` v `gtfsPublicDepartureCache`, kde `from_trip_id` odpovídá aktuálnímu spoji a `arrivalTime < departure_datetime + max_wait_sec`
+    -   zobrazované minuty u garantovaného přestupu jsou nastaveny na čas příjezdu aktuálního spoje (ne na plánovaný odjezd navazujícího spoje)
+    -   garantované přestupy jsou vyjmuty z filtru opačného směru a filtru podskupiny linky – jsou přidány do `tripIdsToKeep` před spuštěním `findRelevantTripIdsFromLines`, takže projdou bez ohledu na zastávkovou sekvenci
+    -   typy "vždy zobrazit" (metro, vlak, přívoz, lanovka) filtr `findRelevantTripIdsFromLines` zcela přeskakují
+-   minimální přestupní čas (`TransferBoardFilter.minimalTransferTime`) — odjezdy s příliš malou rezervou mezi predikovaným příjezdem vozidla a predikovaným odjezdem navazujícího spoje jsou zahozeny; rezerva závisí na nástupišti (`minimalTransferTimeMs`, z `platform_code` aktuální zastávky a navazujícího odjezdu), platí první odpovídající pravidlo
+    -   **vlak**: 120 s vždy (bez ohledu na nástupiště)
+    -   **metro**: 60 s vždy (bez ohledu na nástupiště)
+    -   **lanovka**: 120 s vždy (bez ohledu na nástupiště)
+    -   **ostatní typy** (autobus, tramvaj, trolejbus, přívoz): 60 s při odjezdu z jiného nástupiště, 0 s ze stejného nástupiště
+    -   porovnání nástupišť (`platformDiffers`): nástupiště jsou různá, pokud je některý `platform_code` null/prázdný nebo se kódy neshodují (`!a || !b || a !== b`); chybějící nebo prázdný `platform_code` tak znamená rezervu 60 s, nikdy 0 s; vlak, metro a lanovka zůstávají na svém pevném čase i při chybějícím nástupišti; přívoz vlastní pravidlo nemá, spadá do porovnání nástupišť, prakticky vždy 60 s
+    -   garantované přestupy jsou z tohoto filtru vyjmuty; odjezdy bez predikovaného času odjezdu jsou zahozeny
+-   dostupnost pro vozíčkáře (`is_wheelchair_accessible`)
+    -   **metro**: určeno výhradně podle `wheelchair_boarding` zastávky (hodnota `1` = přístupná)
+    -   **ostatní typy dopravy**: primárně z RT dat vozidla (`detailed_info.is_wheelchair_accessible`); pokud RT data nejsou k dispozici, použije se GTFS příznak `wheelchair_accessible` z `trips.txt` (`1` = přístupné vozidlo)
+-   odfiltrování odjezdů stejné linky v opačném směru (`TransferFacade.isDifferentLine`) — odjezdy se shodným `route_short_name` + `route_type`, ale odlišným `direction_id` oproti aktuálnímu vozidlu jsou odstraněny; odjezdy s neznámým `direction_id` (null) jsou ponechány
+-   seskupování a omezení výstupu (`TransferDepartureCacheTransformation`)
+    -   **metro**: seskupuje se podle `route_short_name + route_type + direction_id`; na jeden záznam výstupu připadají až 2 hodnoty v poli `departure_timestamp.minutes[]`
+    -   **ostatní typy**: seskupuje se podle `route_short_name + route_type + direction_id`; na skupinu připadají nejvýše 2 samostatné záznamy odjezdů
+    -   `direction_id` se řeší s fallback řetězcem: `departure.direction_id` (z cache odjezdů) → `position.detailed_info.direction_id` (z RT poloh vozidel) → in-memory cache (klíč `route_short_name + trip_headsign`) → `0`
+-   konfigurace filtrování opačného směru (backtracking)
+    -   `module.pid.vehicle-positions.transferboards.isOppositeDirectionFilterStopNameStrict` (boolean, výchozí `true`) – pokud `true`, zastávka je považována za "zpětnou" pouze pokud se shoduje `stop_id` i `stop_name`; pokud `false`, stačí shoda `stop_id`
+    -   `module.pid.vehicle-positions.transferboards.countPreviousStopsToAllow` (integer, výchozí `0`) – kolik předchozích zastávek aktuálního spoje smí kandidátní spoj sdílet ve svých nadcházejících zastávkách, než je považován za zpětný směr a odfiltrován; `0` znamená žádná shoda není povolena
+
+#### _/v3/pid/infotexts_
+
+-  načte aktivní infotexty exportované z aplikace VYMI (JIS) Infotexty
+-  zdrojové tabulky
+    -   `jis_infotexts`, `jis_infotexts_ropidgtfs_stops`, `ropidgtfs_stops`
+
+### Public v2
+
+> **Vypnuto** – endpoint není v rozsahu modulu public-transport, router je zakomentovaný v `src/output-gateway/index.ts`.
+
+#### _/v2/public/gtfs/trips/{gtfsTripId}_
+
+-   načte statické informace o GTFS spoji z PSQL, případně jeho oběhové číslo pro současný den (pokud je k dispozici), shapes a zastávky
+    -   `info`: statické informace o GTFS spoji a jeho oběhové číslo pro současný den (pokud je k dispozici)
+    -   `stop_times`: seznam zastávek ve formátu geojson
+    -   `shapes`: seznam tvarů trasy podle GTFS ve formátu geojson
+    -   `vehicle_descriptor`: informace o vozidle - pouze očekáváná nízkopodlažnost vozidla načtená z GTFS trips.txt
+-   cachováno na 4 hodiny pomocí cache-control hlavičky
+-   je použit `CompressionByDefaultMiddleware` a odpovědi jsou tak na output gateway komprimovány i pokud klient explicitně nepovolí komprimaci vhodnou hodnotou hlavičky `Accept-Encoding` (lze však komprimaci explicitně zakázat hodnotou `identity`)
+
+#### _/v2/public/vehiclepositions_
+
+-   načte aktuální polohy vozidel z redisu a vrátí je ve formátu geojson
+    -   možno filtrovat dle bouding box na straně redisu
+    -   podle typu vozidla a gtfs route number na klientské straně
+-   je použit `CompressionByDefaultMiddleware` a odpovědi jsou tak na output gateway komprimovány i pokud klient explicitně nepovolí komprimaci vhodnou hodnotou hlavičky `Accept-Encoding` (lze však komprimaci explicitně zakázat hodnotou `identity`)
+
+#### _/v2/public/vehiclepositions/{vehicleId}_
+
+-   načte jednu aktuální polohu z redisu
+    -   výstup možno filtrovat podle query parametru `scopes`
+    -   `info`: detailní informace o spoji, vč. realtime dat
+    -   `stop_times`: seznam zastávek, které vozidlo projelo a projede, vč. informací o zpoždění (historických/predikovaných), ve formátu geojson
+    -   `shapes`: seznam tvarů trasy (podle GTFS; nejedná se o naše předpočítané anchor pointy, které se mimo zastávky oproti GTFS shapes mohou lišit), ve formátu geojson
+    -   `vehicle_descriptor`: informace o vozidle (dopravce, dostupnost klimatizace, USB, ...)
+-   je použit `CompressionByDefaultMiddleware` a odpovědi jsou tak na output gateway komprimovány i pokud klient explicitně nepovolí komprimaci vhodnou hodnotou hlavičky `Accept-Encoding` (lze však komprimaci explicitně zakázat hodnotou `identity`)
+
+#### _/v2/public/vehiclepositions/{vehicleId}{gtfsTripId}_
+
+-   rozšíření endpointu výše `/public/vehiclepositions/{vehicleId}` o možnost dotázat se na before track (delayed) spoje podle `gtfsTripId`
+-   je použit `CompressionByDefaultMiddleware` a odpovědi jsou tak na output gateway komprimovány i pokud klient explicitně nepovolí komprimaci vhodnou hodnotou hlavičky `Accept-Encoding` (lze však komprimaci explicitně zakázat hodnotou `identity`)
+
+#### _/v2/public/departureboards_
+
+-   načte nacacheované odjezdy z redisu
+    - možno filtrovat podle skupin zastávek `stopIds` (podle GTFS číselníku) s možností nastavení pořadí navrácených skupin s odjezdy - příklad `?stopIds[]={"0": ["U717Z5P"]}&stopIds[]={"1": ["U718Z5P", "U719Z5P"]}`
+    - podle názvů linek a jak daleko do budoucnosti se mají odjezdy navracet
+    - limitování počtu odjezdů v každé skupině
+-   EP je optimalizován pro vyšší zátěž z mobilní aplikace PID lítačka - požadavek do databáze z OG pouze v případě nutnosti obnovit cache s vehicle descriptory (klimatizace, usb nabíječky), jinak je vše z Redisu
+-   deduplikace odjezdů (pro seskupení "jeden za linka+směr") se provádí podle klíče `route_id + trip_headsign + platform_code`; toto se liší od původního přístupu deduplikace podle `stop_id` a správně pokrývá situace, kdy jeden ASW uzel odpovídá více GTFS `stop_id`
+-   dostupnost pro vozíčkáře (`is_wheelchair_accessible`) se určuje v pořadí priority:
+    1. RT descriptor vozidla (`detailed_info.is_wheelchair_accessible` z vehicle positions)
+    2. GTFS statický příznak `wheelchair_accessible` z `trips.txt` (`1` = přístupné), pokud RT data nejsou k dispozici
+-   je použit `CompressionByDefaultMiddleware` a odpovědi jsou tak na output gateway komprimovány i pokud klient explicitně nepovolí komprimaci vhodnou hodnotou hlavičky `Accept-Encoding` (lze však komprimaci explicitně zakázat hodnotou `identity`)
+
+### JIS v1
+
+> **Vypnuto** – endpoint není v rozsahu modulu public-transport, router je zakomentovaný v `src/output-gateway/index.ts`.
+
+#### _/v1/jis/events/custom-format_
+
+-   vrátí seznam publikovaných událostí ve vlastním formátu pro externí konzumenty (fallback endpoint pro webhooky)
+-   parametry
+    -   `displayPeriodStart` / `displayPeriodEnd` – filtrování podle překryvu zobrazovacího okna události s požadovaným rozsahem (ISO 8601)
+    -   `organizationNames` – filtrování podle organizace (pole řetězců)
+    -   `type` – filtrování podle typu události (`INCIDENT`, `DISRUPTION`, `SERVICE_CHANGE`)
+-   zdrojové tabulky: `jis_events`, `jis_events_ropidgtfs_routes`
+-   formát odpovědi: viz schéma `EventCustomFormat` v [openapi-output.yaml](./openapi-output.yaml)