2026-10-16 15:34:45 +02:00
779 changed files with 201230 additions and 17809 deletions
@@ -39,11 +39,21 @@ on:
        description: 'Create release'
        required: false
        default: false
+      battery_subset:
+        description: 'Validation battery: "--tier ci" (default), "--tier smoke", "--only 5reo,lyso_x06da_ref", or empty for the full battery (open + inhouse). Not run with a release.'
+        required: false
+        default: '--tier ci'
+      battery_label:
+        description: 'Validation battery run label (part of the run directory name)'
+        required: false
+        default: 'manual'

 jobs:
-  # ---- Viewer --------------------------------------------------------------------------------------
-  build-viewer-tgz:
-    name: build:viewer:linux-x86_64:${{ matrix.variant }}
+  # ---- Portable Linux artifacts: viewer, rugnux, XDS plugin -----------------------------------------
+  # One viewer-only build per variant packs three tarballs, one program each (see CPack in
+  # CMakeLists.txt): the viewer build compiles everything rugnux and the plugin need anyway.
+  build-portable-tgz:
+    name: build:portable:linux-x86_64:${{ matrix.variant }}
    # Uploads to the release, so it waits for the job that creates it.
    needs: create-release
    runs-on: jfjoch_rocky8
@@ -62,21 +72,17 @@ jobs:
      - uses: actions/checkout@v4
      - name: Clean previous build
        shell: bash
-        run: rm -rf build   # self-hosted runners reuse the workspace volume; a stale build dir
-                            # can leave the viewer linking a system libcurl instead of the vendored one
-      - name: Configure viewer build
+        run: rm -rf build   # self-hosted runners reuse the workspace volume; start from a clean build dir
+      - name: Configure
        shell: bash
        run: |
          mkdir -p build
          cd build
          cmake -G Ninja -DJFJOCH_VIEWER_ONLY=ON -DJFJOCH_USE_CUDA=${{ matrix.use_cuda }} ${{ env.LINUX_CMAKE_FLAGS }} -DCMAKE_BUILD_TYPE=Release ..
-      - name: Build viewer tgz
+      - name: Build viewer, rugnux and XDS plugin tgz
        shell: bash
        run: |
          cd build
-          # The "viewer" component is now jfjoch_viewer alone -- rugnux ships as its own artifact
-          # (build:rugnux-tgz) and the two CLI tools are no longer packaged at all. The full tree is
-          # still built because the viewer links the JFJochRugnux library for its in-process jobs.
          ninja -j16
          cpack
      - name: Verify one libjpeg in the viewer
@@ -85,13 +91,41 @@ jobs:
          set -euo pipefail
          # With the static Qt, Qt's JPEG plugin brings its own libjpeg-turbo (another ABI) and the
          # linker silently mixes it with ours (see viewer/CMakeLists.txt). Files, not pipes into
-          # `grep -q`, for the SIGPIPE reason given in build:rugnux-tgz.
+          # `grep -q`, for the SIGPIPE reason given in the rugnux check below.
          strings build/viewer/jfjoch_viewer > /tmp/jfjv.strings
          if grep -qE 'QJpegHandler|QTiffHandler' /tmp/jfjv.strings; then echo "a Qt JPEG/TIFF plugin is linked"; exit 1; fi
          grep -c 'libjpeg-turbo version' /tmp/jfjv.strings > /tmp/jfjv.njpeg || true
          if [ "$(cat /tmp/jfjv.njpeg)" != 1 ]; then echo "expected one libjpeg-turbo, found $(cat /tmp/jfjv.njpeg)"; exit 1; fi
          echo "one libjpeg-turbo, no Qt JPEG/TIFF plugin"
-      - name: Upload viewer tgz to release
+      - name: Verify rugnux is self-contained
+        shell: bash
+        run: |
+          set -euo pipefail
+          rm -rf /tmp/rgx && mkdir -p /tmp/rgx
+          tar xf build/rugnux-*.tar.gz -C /tmp/rgx
+          bin=$(find /tmp/rgx -name rugnux -type f)
+          # Each producer writes to a file and the greps read files, rather than piping into
+          # `grep -q`: grep exits at the first match, the producer then dies of SIGPIPE, and under
+          # `set -o pipefail` that becomes the pipeline's status -- which a leading `!` would turn
+          # into a pass, hiding the very thing being tested.
+          ldd "$bin" > /tmp/rgx.ldd 2>&1 || true
+          if grep -q cufft /tmp/rgx.ldd; then echo "cuFFT is linked dynamically"; exit 1; fi
+          find /tmp/rgx -name 'libcufft*' > /tmp/rgx.cufft
+          if [ -s /tmp/rgx.cufft ]; then echo "a libcufft is shipped in the tarball"; exit 1; fi
+          echo "self-contained: static cuFFT, nothing to ship beside it"
+      - name: Verify the XDS plugin exports
+        shell: bash
+        run: |
+          set -euo pipefail
+          rm -rf /tmp/xdsp && mkdir -p /tmp/xdsp
+          tar xf build/jfjoch_xds_plugin-*.tar.gz -C /tmp/xdsp
+          so=$(find /tmp/xdsp -name 'libjfjoch_xds_plugin.so.*' -type f)
+          # only the four plugin_* entry points are exported
+          nm -D --defined-only "$so" | awk '{print $3}' > /tmp/xdsp.exports
+          if grep -v '^plugin_' /tmp/xdsp.exports; then echo "the plugin exports more than plugin_*"; exit 1; fi
+          ls /tmp/xdsp/share/doc/jfjoch_xds_plugin/licenses
+          echo "exports plugin_* only"
+      - name: Upload tgz to release
        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
        shell: bash
        env:
@@ -99,11 +133,16 @@ jobs:
        run: |
          set -euo pipefail
          shopt -s nullglob
-          # CMakeLists.txt names the archive jfjoch_viewer-<version>-linux-{cuda<major>|cpu}.tar.gz;
-          # rename to .tgz (matching the Windows installer's release naming) before upload.
-          files=(build/jfjoch_viewer-*.tar.gz)
-          if [ ${#files[@]} -eq 0 ]; then
-            echo "No viewer archive found in build/"
+          # CMakeLists.txt names the archives jfjoch_viewer-<version>-linux-{cuda<major>|cpu},
+          # rugnux-<version>-linux-x86_64-{cuda<major>|cpu} and jfjoch_xds_plugin-<version>-linux-x86_64
+          # (.tar.gz); rename to .tgz before upload. The plugin does not use CUDA and comes out the
+          # same from both variants, so only one of them uploads it.
+          files=(build/jfjoch_viewer-*.tar.gz build/rugnux-*.tar.gz)
+          if [ "${{ matrix.variant }}" = "nocuda" ]; then
+            files+=(build/jfjoch_xds_plugin-*.tar.gz)
+          fi
+          if [ ${#files[@]} -lt 2 ]; then
+            echo "Archives missing in build/"
            exit 1
          fi
          for file in "${files[@]}"; do
@@ -112,8 +151,10 @@ jobs:
            python3 gitea_upload_file.py "$tgz"
          done

+  # One build packs the viewer installer and the rugnux .zip (CPackProjectConfig.cmake in
+  # CMakeLists.txt gives each generator its components).
  build-windows:
-    name: build:viewer:windows-x86_64:${{ matrix.variant }}
+    name: build:portable:windows-x86_64:${{ matrix.variant }}
    # Uploads to the release, so it waits for the job that creates it.
    needs: create-release
    runs-on: windows-11-cuda-qt
@@ -153,29 +194,42 @@ jobs:
        run: |
          cd build\tests
          jfjoch_portable_test.exe "[portable]"
-      - name: Build installer (NSIS)
+      - name: Build installer (NSIS) and rugnux zip
        shell: cmd
        run: |
          for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath`) do set "VSPATH=%%i"
          call "%VSPATH%\VC\Auxiliary\Build\vcvars64.bat"
          cd build
          cpack
-      - name: Upload installer to release
+      - name: Verify the rugnux zip
+        shell: powershell
+        run: |
+          # rugnux.exe and, in the CUDA variant, the cuFFT DLL it needs - and no viewer.
+          $zip = Get-ChildItem -Path build -Filter 'rugnux-*-win64-*.zip'
+          if ($zip.Count -ne 1) { throw 'Expected one rugnux zip in build/' }
+          Add-Type -AssemblyName System.IO.Compression.FileSystem
+          $names = [System.IO.Compression.ZipFile]::OpenRead($zip[0].FullName).Entries | ForEach-Object { $_.FullName }
+          $names
+          if (-not ($names -match 'rugnux\.exe$')) { throw 'rugnux.exe missing from the zip' }
+          if ($names -match 'jfjoch_viewer') { throw 'the viewer is in the rugnux zip' }
+          if ('${{ matrix.use_cuda }}' -eq 'ON' -and -not ($names -match 'cufft64_.*\.dll$')) { throw 'cuFFT DLL missing from the CUDA zip' }
+      - name: Upload installer and rugnux zip to release
        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
        shell: powershell
        env:
          TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
        run: |
-          # NSIS installer named jfjoch-viewer-<version>-win64-{cuda<major>|cpu}.exe (see CMakeLists.txt).
-          $files = Get-ChildItem -Path build -Filter 'jfjoch-viewer-*-win64-*.exe'
-          if ($files.Count -eq 0) { throw 'No Windows installer found in build/' }
+          # NSIS installer jfjoch-viewer-<version>-win64-{cuda<major>|cpu}.exe and
+          # rugnux-<version>-win64-{cuda<major>|cpu}.zip (see CMakeLists.txt).
+          $files = @(Get-ChildItem -Path build -Filter 'jfjoch-viewer-*-win64-*.exe') + @(Get-ChildItem -Path build -Filter 'rugnux-*-win64-*.zip')
+          if ($files.Count -ne 2) { throw 'Expected the installer and the rugnux zip in build/' }
          foreach ($file in $files) {
            python gitea_upload_file.py $file.FullName
            if ($LASTEXITCODE -ne 0) { throw "Upload failed for $($file.Name)" }
          }

-  build-macos-viewer:
-    name: build:viewer:macos-arm64:nocuda
+  build-macos:
+    name: build:portable:macos-arm64:nocuda
    # Uploads to the release, so it waits for the job that creates it.
    needs: create-release
    # A Mac mini running act_runner in host mode (no containers on macOS): the job runs as the runner's
@@ -190,19 +244,43 @@ jobs:
      - name: Clean previous build
        shell: bash
        run: rm -rf build-macos   # host runners keep the workspace between runs
-      - name: Configure viewer build
+      # The Developer ID in the runner's login keychain signs the app (hardened runtime, secure
+      # timestamp) so the .dmg can be notarized below; without it the build must not go on, as an
+      # ad-hoc signed download is refused by Gatekeeper. Passed on as the certificate's SHA-1 (see
+      # JFJOCH_MACOS_SIGNING_IDENTITY in CMakeLists.txt). The notarytool credentials sit in the same
+      # keychain under the profile jfjoch-notary (xcrun notarytool store-credentials --keychain
+      # ~/Library/Keychains/login.keychain-db: that file never locks here, the default data-protection
+      # keychain does with the screen).
+      - name: Signing identity
+        shell: bash
+        run: |
+          set -euo pipefail
+          identity=$(security find-identity -v -p codesigning | sed -n 's/^ *[0-9]*) \([0-9A-F]*\) "Developer ID Application: .*/\1/p' | head -1)
+          if [ -z "$identity" ]; then echo "no Developer ID Application identity in the runner's keychain"; exit 1; fi
+          echo "MACOS_SIGNING_IDENTITY=$identity" >> "$GITHUB_ENV"
+      - name: Configure
        shell: bash
        # JFJOCH_VIEWER_ONLY is forced on macOS. No -mcpu: the arm64 baseline is what every Apple
        # Silicon Mac runs, and NEON is part of it.
-        run: cmake -S . -B build-macos -DCMAKE_BUILD_TYPE=Release -DJFJOCH_USE_CUDA=OFF -DCMAKE_PREFIX_PATH="$QT_PREFIX"
+        run: cmake -S . -B build-macos -DCMAKE_BUILD_TYPE=Release -DJFJOCH_USE_CUDA=OFF -DCMAKE_PREFIX_PATH="$QT_PREFIX" -DJFJOCH_MACOS_SIGNING_IDENTITY="$MACOS_SIGNING_IDENTITY"
      # The quick cross-platform checks (tests/PortableTest.cpp and the [portable] cases), before
      # anything is packaged.
      - name: Portable tests
        shell: bash
        run: |
          cmake --build build-macos --target jfjoch_portable_test -j "$(sysctl -n hw.ncpu)"
-          cd build-macos/tests && ./jfjoch_portable_test "[portable]"
-      - name: Build viewer and DMG
+          cd build-macos/tests && ./jfjoch_portable_test "[portable]~[Metal]"
+      # The Metal Bragg integration engine has to give the CPU engine's result bit for bit
+      # (BraggIntegrationEngineMetal.h): every reflection's every float, on random crowded frames
+      # through every integrator, overlap and background mode. Its own step, so a mismatch is named as
+      # such; it fails rather than skips on a machine without a Metal device, as this is the only job
+      # that can check it.
+      - name: Metal integration engine is bit-identical to the CPU engine
+        shell: bash
+        run: cd build-macos/tests && ./jfjoch_portable_test "[Metal]"
+      # One build, two artifacts: the viewer .dmg and rugnux as .tar.gz (CPACK_PROJECT_CONFIG_FILE
+      # in CMakeLists.txt gives each generator its components). The XDS plugin is Linux-only.
+      - name: Build viewer DMG and rugnux tgz
        shell: bash
        run: |
          cmake --build build-macos -j "$(sysctl -n hw.ncpu)"
@@ -218,20 +296,42 @@ jobs:
          # ... and nothing in the bundle may point at this machine's Qt (or anything else under /Users)
          find "$app" -type f \( -perm +111 -o -name '*.dylib' \) -exec otool -L {} + > /tmp/jfjv.libs 2>/dev/null || true
          if grep -q "/Users/" /tmp/jfjv.libs; then grep "/Users/" /tmp/jfjv.libs; echo "absolute path into the build machine"; exit 1; fi
-          # the (ad-hoc) signature must survive everything installed into the bundle
+          # the Developer ID signature must survive everything installed into the bundle, and carry
+          # the hardened runtime that notarization demands
          codesign --verify --deep --strict "$app"
+          # rugnux is in an archive of its own, not in the app
+          find "$app" -name rugnux > /tmp/jfjv.extra
+          if [ -s /tmp/jfjv.extra ]; then cat /tmp/jfjv.extra; echo "the bundle carries another program"; exit 1; fi
+          # to a file, not piped into `grep -q` (see "Verify rugnux is self-contained" above)
+          codesign -d --verbose=2 "$app" > /tmp/jfjv.sig 2>&1
+          if ! grep -q "flags=.*runtime" /tmp/jfjv.sig; then cat /tmp/jfjv.sig; echo "no hardened runtime"; exit 1; fi
          echo "self-contained and validly signed"
-      # Notarization - needs an Apple Developer ID, which the project does not have yet. Once it
-      # does, the app has to be signed with it (hardened runtime, secure timestamp) BEFORE cpack
-      # packs it, e.g. by passing to macdeployqt, through qt_generate_deploy_app_script's
-      # DEPLOY_TOOL_OPTIONS in viewer/CMakeLists.txt:
-      #   -codesign="Developer ID Application: <NAME> (<TEAMID>)" -hardened-runtime -timestamp
-      # and the DMG then notarized and stapled here, with an app-specific password stored once on
-      # the runner (xcrun notarytool store-credentials jfjoch-notary ...):
-      #   xcrun notarytool submit build-macos/jfjoch-viewer-*.dmg --keychain-profile jfjoch-notary --wait
-      #   xcrun stapler staple build-macos/jfjoch-viewer-*.dmg
-      # Until then a downloaded DMG is blocked by Gatekeeper on first open (right-click > Open).
-      - name: Upload DMG to release
+      - name: Verify rugnux is self-contained
+        shell: bash
+        run: |
+          set -euo pipefail
+          rm -rf /tmp/rgxm && mkdir -p /tmp/rgxm
+          tar xf build-macos/rugnux-*.tar.gz -C /tmp/rgxm
+          bin=$(find /tmp/rgxm -name rugnux -type f)
+          # Only the system's own libraries may be linked dynamically; everything else is static.
+          otool -L "$bin" | tail -n +2 > /tmp/rgxm.libs
+          if grep -v -e "/usr/lib/" -e "/System/Library/" /tmp/rgxm.libs; then echo "links a non-system library"; exit 1; fi
+          # and it runs: with no arguments rugnux prints its usage
+          "$bin" > /tmp/rgxm.out 2>&1 || true
+          if ! grep -qi "usage" /tmp/rgxm.out; then cat /tmp/rgxm.out; echo "rugnux did not start"; exit 1; fi
+          # and carries the Developer ID signature with the hardened runtime that notarization demands
+          codesign --verify --strict "$bin"
+          codesign -d --verbose=2 "$bin" > /tmp/rgxm.sig 2>&1
+          if ! grep -q "flags=.*runtime" /tmp/rgxm.sig; then cat /tmp/rgxm.sig; echo "no hardened runtime"; exit 1; fi
+          echo "self-contained, runs and is validly signed"
+      # Every push, not only a release: a rejection by Apple (a library macdeployqt left unsigned, an
+      # entitlement the hardened runtime needs) should show up when the change is made, not when the
+      # release is cut. Signs the image, waits for Apple's verdict, staples the ticket to the image;
+      # the rugnux binary only gets its hash registered, a bare executable has nowhere to staple.
+      - name: Notarize
+        shell: bash
+        run: tools/notarize_macos.sh build-macos/jfjoch-viewer-*.dmg build-macos/rugnux-*.tar.gz
+      - name: Upload DMG and tgz to release
        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
        shell: bash
        env:
@@ -239,75 +339,23 @@ jobs:
        run: |
          set -euo pipefail
          shopt -s nullglob
-          # CMakeLists.txt names it jfjoch-viewer-<version>-macos-arm64.dmg
-          files=(build-macos/jfjoch-viewer-*.dmg)
-          if [ ${#files[@]} -eq 0 ]; then
-            echo "No DMG found in build-macos/"
+          # CMakeLists.txt names them jfjoch-viewer-<version>-macos-arm64.dmg and
+          # rugnux-<version>-macos-arm64-cpu.tar.gz; the archive is renamed to .tgz before upload,
+          # as the Linux ones are.
+          dmgs=(build-macos/jfjoch-viewer-*.dmg)
+          tars=(build-macos/rugnux-*.tar.gz)
+          if [ ${#dmgs[@]} -ne 1 ] || [ ${#tars[@]} -ne 1 ]; then
+            echo "Expected one DMG and one archive in build-macos/"
            exit 1
          fi
-          for file in "${files[@]}"; do
-            python3 gitea_upload_file.py "$file"
-          done
-
-  # ---- Rugnux --------------------------------------------------------------------------------------
-  build-rugnux-tgz:
-    name: build:rugnux:linux-x86_64:cuda
-    # Uploads to the release, so it waits for the job that creates it.
-    needs: create-release
-    runs-on: jfjoch_rocky8
-    container:
-      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
-    timeout-minutes: 120
-    steps:
-      - uses: actions/checkout@v4
-      - name: Clean previous build
-        shell: bash
-        run: rm -rf build-rugnux   # self-hosted runners reuse the workspace volume
-      - name: Configure rugnux build
-        shell: bash
-        run: |
-          cmake -G Ninja -S . -B build-rugnux -DJFJOCH_RUGNUX_ONLY=ON -DJFJOCH_USE_CUDA=ON \
-            ${{ env.LINUX_CMAKE_FLAGS }} -DCMAKE_BUILD_TYPE=Release
-      - name: Build rugnux tgz
-        shell: bash
-        run: cmake --build build-rugnux --target package -j16
-      - name: Verify the artifact is self-contained
-        shell: bash
-        run: |
-          set -euo pipefail
-          rm -rf /tmp/rgx && mkdir -p /tmp/rgx
-          tar xf build-rugnux/rugnux-*.tar.gz -C /tmp/rgx
-          bin=$(find /tmp/rgx -name rugnux -type f)
-          # Each producer writes to a file and the greps read files, rather than piping into
-          # `grep -q`: grep exits at the first match, the producer then dies of SIGPIPE, and under
-          # `set -o pipefail` that becomes the pipeline's status -- which a leading `!` would turn
-          # into a pass, hiding the very thing being tested.
-          ldd "$bin" > /tmp/rgx.ldd 2>&1 || true
-          if grep -q cufft /tmp/rgx.ldd; then echo "cuFFT is linked dynamically"; exit 1; fi
-          find /tmp/rgx -name 'libcufft*' > /tmp/rgx.cufft
-          if [ -s /tmp/rgx.cufft ]; then echo "a libcufft is shipped in the tarball"; exit 1; fi
-          echo "self-contained: static cuFFT, nothing to ship beside it"
-      - name: Upload rugnux tgz to release
-        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
-        shell: bash
-        env:
-          TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
-        run: |
-          set -euo pipefail
-          shopt -s nullglob
-          # CMakeLists.txt names the archive rugnux-<version>-linux-{cuda<major>|cpu}.tar.gz;
-          # rename to .tgz before upload, as the viewer archive does.
-          files=(build-rugnux/rugnux-*.tar.gz)
-          if [ ${#files[@]} -eq 0 ]; then
-            echo "No rugnux archive found in build-rugnux/"
-            exit 1
-          fi
-          for file in "${files[@]}"; do
+          python3 gitea_upload_file.py "${dmgs[0]}"
+          for file in "${tars[@]}"; do
            tgz="${file%.tar.gz}.tgz"
            mv "$file" "$tgz"
            python3 gitea_upload_file.py "$tgz"
          done

+  # ---- Rugnux --------------------------------------------------------------------------------------
  build-rugnux-arm:
    name: build:rugnux:linux-aarch64:cuda   # cross-compiled on x86_64
    # Uploads to the release, so it waits for the job that creates it.
@@ -390,123 +438,6 @@ jobs:
            python3 gitea_upload_file.py "$tgz"
          done

-  build-rugnux-windows:
-    name: build:rugnux:windows-x86_64:cuda
-    # Uploads to the release, so it waits for the job that creates it.
-    needs: create-release
-    runs-on: windows-11-cuda-qt
-    timeout-minutes: 120
-    steps:
-      - uses: actions/checkout@v4
-      # cmd, not bash: the Windows runner has no bash, and every cmake invocation needs the MSVC
-      # environment from vcvars64.bat first -- same shape as build-windows above. No Qt in
-      # CMAKE_PREFIX_PATH: JFJOCH_RUGNUX_ONLY is the portable subtree minus viewer/, and every
-      # library it needs is now fetched and built by the configure, so C:/deps is only a leftover.
-      - name: Configure rugnux build
-        shell: cmd
-        run: |
-          for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath`) do set "VSPATH=%%i"
-          call "%VSPATH%\VC\Auxiliary\Build\vcvars64.bat"
-          cmake -G Ninja -B build-rugnux -DJFJOCH_RUGNUX_ONLY=ON -DJFJOCH_USE_CUDA=ON -DCMAKE_BUILD_TYPE=Release ${{ env.MSVC_ARCH_CMAKE_FLAGS }} -DCMAKE_PREFIX_PATH="C:/deps"
-      - name: Build rugnux
-        shell: cmd
-        run: |
-          for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath`) do set "VSPATH=%%i"
-          call "%VSPATH%\VC\Auxiliary\Build\vcvars64.bat"
-          cmake --build build-rugnux
-      # The quick cross-platform checks (tests/PortableTest.cpp and the [portable] cases), before
-      # anything is packaged. CPU-only: the runner has no GPU.
-      - name: Build portable tests
-        shell: cmd
-        run: |
-          for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath`) do set "VSPATH=%%i"
-          call "%VSPATH%\VC\Auxiliary\Build\vcvars64.bat"
-          cmake --build build-rugnux --target jfjoch_portable_test
-      - name: Run portable tests
-        shell: cmd
-        run: |
-          cd build-rugnux\tests
-          jfjoch_portable_test.exe "[portable]"
-      - name: Build rugnux zip
-        shell: cmd
-        run: |
-          for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath`) do set "VSPATH=%%i"
-          call "%VSPATH%\VC\Auxiliary\Build\vcvars64.bat"
-          cd build-rugnux
-          cpack
-      - name: Upload rugnux zip to release
-        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
-        shell: powershell
-        env:
-          TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
-        run: |
-          # Zip named rugnux-<version>-win64-{cuda<major>|cpu}.zip (see CMakeLists.txt).
-          $files = Get-ChildItem -Path build-rugnux -Filter 'rugnux-*-win64-*.zip'
-          if ($files.Count -eq 0) { throw 'No rugnux zip found in build-rugnux/' }
-          foreach ($file in $files) {
-            python gitea_upload_file.py $file.FullName
-            if ($LASTEXITCODE -ne 0) { throw "Upload failed for $($file.Name)" }
-          }
-
-  build-rugnux-macos:
-    name: build:rugnux:macos-arm64:nocuda
-    # Uploads to the release, so it waits for the job that creates it.
-    needs: create-release
-    runs-on: macos-arm64   # see build-macos-viewer
-    timeout-minutes: 120
-    steps:
-      - uses: actions/checkout@v4
-      - name: Clean previous build
-        shell: bash
-        run: rm -rf build-rugnux-macos
-      - name: Configure rugnux build
-        shell: bash
-        run: cmake -S . -B build-rugnux-macos -DJFJOCH_RUGNUX_ONLY=ON -DJFJOCH_USE_CUDA=OFF -DCMAKE_BUILD_TYPE=Release
-      # The quick cross-platform checks (tests/PortableTest.cpp and the [portable] cases), before
-      # anything is packaged.
-      - name: Portable tests
-        shell: bash
-        run: |
-          cmake --build build-rugnux-macos --target jfjoch_portable_test -j "$(sysctl -n hw.ncpu)"
-          cd build-rugnux-macos/tests && ./jfjoch_portable_test "[portable]"
-      - name: Build rugnux tgz
-        shell: bash
-        run: cmake --build build-rugnux-macos --target package -j "$(sysctl -n hw.ncpu)"
-      - name: Verify the artifact is self-contained
-        shell: bash
-        run: |
-          set -euo pipefail
-          rm -rf /tmp/rgxm && mkdir -p /tmp/rgxm
-          tar xf build-rugnux-macos/rugnux-*.tar.gz -C /tmp/rgxm
-          bin=$(find /tmp/rgxm -name rugnux -type f)
-          # Only the system's own libraries may be linked dynamically; everything else is static.
-          otool -L "$bin" | tail -n +2 > /tmp/rgxm.libs
-          if grep -v -e "/usr/lib/" -e "/System/Library/" /tmp/rgxm.libs; then echo "links a non-system library"; exit 1; fi
-          # and it runs: with no arguments rugnux prints its usage
-          "$bin" > /tmp/rgxm.out 2>&1 || true
-          if ! grep -qi "usage" /tmp/rgxm.out; then cat /tmp/rgxm.out; echo "rugnux did not start"; exit 1; fi
-          echo "self-contained and runs"
-      - name: Upload rugnux tgz to release
-        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
-        shell: bash
-        env:
-          TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
-        run: |
-          set -euo pipefail
-          shopt -s nullglob
-          # CMakeLists.txt names it rugnux-<version>-macos-arm64-cpu.tar.gz; rename to .tgz before
-          # upload, as the Linux archives are.
-          files=(build-rugnux-macos/rugnux-*.tar.gz)
-          if [ ${#files[@]} -eq 0 ]; then
-            echo "No rugnux archive found in build-rugnux-macos/"
-            exit 1
-          fi
-          for file in "${files[@]}"; do
-            tgz="${file%.tar.gz}.tgz"
-            mv "$file" "$tgz"
-            python3 gitea_upload_file.py "$tgz"
-          done
-
  # ---- Jungfraujoch --------------------------------------------------------------------------------
  unit-tests:
    name: Unit tests
@@ -515,6 +446,9 @@ jobs:
    # was not already run, and a release build is the one case where the wait is pure delay.
    if: "!(github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true))"
    runs-on: jfjoch_rocky8
+    # The validation battery below runs on the same machine and GPU, and its rugnux takes the card's
+    # memory as its sets need it: a GPU test beside it finds the card full, and a GPU out-of-memory
+    # ends the run by design. The battery waits for this job (needs:), so the two take turns.
    container:
      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
      options: --gpus all
@@ -557,6 +491,153 @@ jobs:
          cd build/tools
          ./jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5

+  # ---- Validation battery ------------------------------------------------------------------------
+  # Every push runs the ci tier of tools/battery (29 sets, about 11 minutes of rugnux on an RTX 5080,
+  # plus the build); the full battery (open + inhouse arms, about 2 hours of rugnux there) runs only
+  # when started by hand (Run workflow, battery_subset empty; no release). It runs on the one machine
+  # that holds the battery data, after the unit tests of the same run (needs:), which share its GPU,
+  # under its own runner label, with the data mounted read-only and /data/battery (scratch, kept
+  # reports, PDB/COD caches, the full-run lock) read-write. No concurrency group: a group keeps one
+  # pending job and cancels it for a newer one, so a merge to main could lose its battery to a
+  # branch push. Two pushes close together can still overlap on the GPU. The site
+  # config below names only the open and inhouse arms; the private arm is never run here.
+  #
+  # A ci-tier run is followed by the wrong-model null, as a step of its own with its own pass/fail
+  # (battery.py nullmodel; tools/battery/nullmodel.json: five sets, each without --model and with five
+  # wrong models - other open-arm entries' deposited coordinates, from the PDB cache under
+  # /data/battery - 30 more rugnux runs, about 6 minutes), in a run directory and report of its own, so
+  # the ci-tier rows are those of a run without it.
+  #
+  # The battery step fails when a ci-tier set fails on lattice or space group, crashes or has no input -
+  # in any run that includes those sets, so a manual full run fails on them too. The wrong-model step
+  # fails when a pair fails (the data or a decision moved, or the wrong model was not recognised as
+  # wrong). Each step runs whatever the other did, so the job page says which of the two failed. Every
+  # other failure and every metric is reported, not judged: read the table at the end of each step and
+  # the reports. Each run's report.md, results.json and manifest.json are kept, in
+  # /data/battery/ci_reports/<run>/ and (with the log) as the job's artifact - what `battery.py keep`
+  # needs to commit a run under tools/battery/results/; the run directories themselves are scratch.
+  #
+  # Runner side (/opt/gitea/config.yaml on that machine, then restart the runner):
+  #   runner.labels:            + "jfjoch_battery:docker://gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609"
+  #   runner.timeout:           12h   (the default 3h kills a full battery)
+  #   container.valid_volumes:  ["/data/open", "/data/inhouse", "/data/battery", "/opt/xtal"]
+  #   CCP4 (SHELXL for the small-molecule check, REFMAC for --model-check) installed at /opt/xtal/ccp4-9
+  battery:
+    name: Validation Battery
+    # After the unit tests, which share the machine's GPU; whatever their outcome, so a failing unit
+    # test does not hide the battery's result. Not with a release, as the unit tests.
+    needs: unit-tests
+    if: "!cancelled() && !(github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true))"
+    runs-on: jfjoch_battery
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
+      # nvidia-smi inside the container still counts every process on the GPU (host and other
+      # containers), so the battery's gpu_others / "timing NOT a reference" marking keeps working.
+      options: --gpus all
+      volumes:
+        - /data/open:/data/open:ro
+        - /data/inhouse:/data/inhouse:ro
+        - /data/battery:/data/battery
+        - /opt/xtal:/opt/xtal:ro
+    timeout-minutes: 720
+    env:
+      # A push runs the ci tier; a manual run takes what it was given (empty = full battery).
+      SUBSET: ${{ github.event_name == 'push' && '--tier ci' || github.event.inputs.battery_subset }}
+      LABEL: ${{ github.event_name == 'push' && 'ci' || github.event.inputs.battery_label }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build rugnux
+        id: build
+        shell: bash
+        run: |
+          rm -rf build && mkdir build && cd build
+          cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.LINUX_CMAKE_FLAGS }} ..
+          ninja -j16 rugnux
+      - name: Python for the scorer
+        shell: bash
+        run: |
+          # the image's python3 is 3.6, too old for gemmi
+          dnf -y -q install python3.12 python3.12-pip
+          python3.12 -m venv /tmp/bvenv
+          /tmp/bvenv/bin/pip install -q gemmi h5py
+      - name: Site config
+        shell: bash
+        run: |
+          # The run directory (merged files, logs, results.json) is scratch, deleted after the job;
+          # only report.md is kept, in /data/battery/ci_reports and as the job's artifact.
+          cat > /tmp/site.json <<EOF
+          {
+           "runs_root": "/data/battery/scratch/${{ github.run_id }}",
+           "lock_file": "/data/battery/full_run.lock",
+           "gpulock": null,
+           "baseline": null,
+           "baseline_private": null,
+           "pdb_cache": "/data/battery/pdb_cache",
+           "cod_cache": "/data/battery/cod_cache",
+           "shelxl": "/opt/xtal/ccp4-9/bin/shelxl",
+           "arms": {
+            "open":    {"manifest": "open.json",    "reference": "deposition", "data_root": "/data/open"},
+            "inhouse": {"manifest": "inhouse.json", "reference": "xds",        "data_root": "/data/inhouse"}
+           }
+          }
+          EOF
+          cat /tmp/site.json
+      - name: Run the battery
+        shell: bash
+        run: |
+          set -o pipefail
+          # ends with one line per set (rugnux / reference, a tick or cross on the space group);
+          # exits non-zero when a ci-tier set failed. The wrong-model null is the next step.
+          JFJOCH_BATTERY_SITE=/tmp/site.json /tmp/bvenv/bin/python tools/battery/battery.py run \
+            --rugnux build/rugnux/rugnux --build-dir build --label "$LABEL" --no-nullmodel \
+            $SUBSET 2>&1 | tee battery.log
+      - name: Wrong-model null
+        if: ${{ !cancelled() && steps.build.outcome == 'success' && contains(env.SUBSET, '--tier ci') }}
+        shell: bash
+        run: |
+          set -o pipefail
+          # one line per pair; exits non-zero when a pair failed
+          JFJOCH_BATTERY_SITE=/tmp/site.json /tmp/bvenv/bin/python tools/battery/battery.py nullmodel \
+            --rugnux build/rugnux/rugnux --build-dir build --label "$LABEL-null" 2>&1 | tee nullmodel.log
+      - name: Keep the report
+        if: always()
+        shell: bash
+        run: |
+          mkdir -p battery_out /data/battery/ci_reports
+          missing=0
+          for log in battery.log nullmodel.log; do
+            [ -f "$log" ] || continue
+            run=$(sed -n 's/^run directory //p' "$log" | head -1)
+            [ -n "$run" ] && [ -f "$run/report.md" ] || { echo "no report for $log"; missing=1; continue; }
+            # report.md, results.json and manifest.json as the battery wrote them: what
+            # `battery.py keep` commits under tools/battery/results/<host>/<run>/
+            name=$(basename "$run")
+            mkdir -p "battery_out/$name" "/data/battery/ci_reports/$name"
+            for f in report.md results.json manifest.json; do
+              [ -f "$run/$f" ] && cp "$run/$f" "battery_out/$name/" && cp "$run/$f" "/data/battery/ci_reports/$name/"
+            done
+            cp "$log" "battery_out/$name/"
+            # the report's own per-arm summary and failures, or the wrong-model table, into the job log
+            awk '/^## Summary/{p=1} /^### By population/{p=0} p' "$run/report.md"
+            awk '/^### Failures/{p=1;print;next} /^### /{p=0} p' "$run/report.md"
+            awk '/^## Wrong-model null/{p=1} /^## Summary/{p=0} p' "$run/report.md"
+          done
+          exit $missing
+      - name: Upload report
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: battery-report
+          path: battery_out/
+      - name: Delete the run directory
+        if: always()
+        shell: bash
+        run: |
+          # a finished run directory is read-only; the container runs as root, which deletes it anyway
+          rm -rf "/data/battery/scratch/${{ github.run_id }}"
+          # files written by root in the container go back to the owner of the battery tree
+          chown -R "$(stat -c %u:%g /data/battery)" /data/battery/ci_reports /data/battery/pdb_cache /data/battery/cod_cache 2>/dev/null || true
+
  build-rpm:
    name: build:jfjoch:${{ matrix.platform }}:${{ matrix.variant }}
    # Uploads to the release, so it waits for the job that creates it.
@@ -652,8 +733,7 @@ jobs:
      - uses: actions/checkout@v4
      - name: Clean previous build
        shell: bash
-        run: rm -rf build   # self-hosted runners reuse the workspace volume; a stale build dir
-                            # can leave the viewer linking a system libcurl instead of the vendored one
+        run: rm -rf build   # self-hosted runners reuse the workspace volume; start from a clean build dir
      - name: Setup build (cmake)
        shell: bash
        run: |
@@ -691,11 +771,11 @@ jobs:
          
          cd ..
          
-          # The viewer is shipped to the release as a Linux-version-agnostic .tgz by the
-          # build-viewer-tgz job; only the writer (and the XDS plugin .so on rocky8) go to the
-          # release as distro packages here.
+          # The viewer, rugnux and the XDS plugin are shipped to the release as Linux-version-agnostic
+          # .tgz by the build-portable-tgz job; only the writer goes to the release as a distro
+          # package here.
          if [ "${{ matrix.distro }}" = "rocky8_nocuda" ]; then
-            for file in build/jfjoch-writer*rpm build/xds-plugin/libjfjoch_xds_plugin.so.*; do
+            for file in build/jfjoch-writer*rpm; do
                 python3 gitea_upload_file.py "$file"
            done
          elif [ "${{ matrix.distro }}" = "rocky9_nocuda" ]; then
@@ -769,30 +849,51 @@ jobs:
          # Each case clears its directory first. The runner reuses the workspace volume, so a
          # leftover .h5/.LP from an earlier run could let XDS "pass" on files this case never
          # wrote -- which is what the first case of two of these jobs used to risk.
-          xds_case() { # <dir> <jfjoch_hdf5_test flags...>
-            local dir=$1; shift
+          # Indexing must succeed, not just run: a first IDXREF refinement above 2 px is a false
+          # minimum (Durin fell into one at 6 px while XDS.INP started 7 px off the beam centre). And
+          # SPOT.XDS is kept per layout: a plugin must find the same spots in every layout, since they
+          # all hold the same pixels. Only COLSPOT's columns (x, y, frame, intensity) are compared:
+          # IDXREF writes its h,k,l back into the file, and its choice of basis is not deterministic.
+          xds_case() { # <dir> <layout> <jfjoch_hdf5_test flags...>
+            local dir=$1 layout=$2; shift 2
            cd "tests/$dir"
-            rm -f ./*.h5 ./*.LP ./*.HKL
+            rm -f ./*.h5 ./*.LP ./*.HKL ./SPOT.XDS "./SPOT.XDS.$layout"
            "$HDF5_TEST" "$DATA" "$@"
            /opt/xds/xds_par
-            test -f IDXREF.LP
+            test -f CORRECT.LP
+            sd=$(grep -m1 'STANDARD DEVIATION OF SPOT' IDXREF.LP | awk '{print $NF}')
+            echo "IDXREF spot position SD: $sd px"
+            awk -v sd="$sd" 'BEGIN { exit !(sd < 2.0) }' || { echo "IDXREF converged to a false minimum"; return 1; }
+            cp SPOT.XDS "SPOT.XDS.$layout"
          }
-          durin_legacy()  { xds_case xds_durin  -n25 -f10;    }
-          durin_vds()     { xds_case xds_durin  -n25 -f10 -V; }
-          durin_single()  { xds_case xds_durin  -n25 -S;      }
-          jfjoch_legacy() { xds_case xds        -n25 -f10;    }
-          jfjoch_vds()    { xds_case xds        -n25 -f10 -V; }
-          jfjoch_single() { xds_case xds        -n25 -S;      }
+          same_spots() { # <dir> <layouts...>: every layout gave the same SPOT.XDS
+            local dir=$1 first=$2; shift 2
+            for l in "$@"; do
+              [ "$(awk '{print $1, $2, $3, $4}' "tests/$dir/SPOT.XDS.$first" | md5sum)" = \
+                "$(awk '{print $1, $2, $3, $4}' "tests/$dir/SPOT.XDS.$l" | md5sum)" ] \
+                || { echo "$dir: SPOT.XDS of $l differs from $first"; return 1; }
+            done
+          }
+          durin_legacy()  { xds_case xds_durin  legacy -n25 -f10;    }
+          durin_vds()     { xds_case xds_durin  vds    -n25 -f10 -V; }
+          durin_single()  { xds_case xds_durin  single -n25 -S;      }
+          jfjoch_legacy() { xds_case xds        legacy -n25 -f10;    }
+          jfjoch_vds()    { xds_case xds        vds    -n25 -f10 -V; }
+          jfjoch_single() { xds_case xds        single -n25 -S;      }
          # Neggia cannot read a VDS master, so it gets the two layouts it supports.
-          neggia_legacy() { xds_case xds_neggia -n25 -f10;    }
-          neggia_single() { xds_case xds_neggia -n25 -S;      }
+          neggia_legacy() { xds_case xds_neggia legacy -n25 -f10;    }
+          neggia_single() { xds_case xds_neggia single -n25 -S;      }
+          durin_layouts()  { same_spots xds_durin  legacy vds single; }
+          jfjoch_layouts() { same_spots xds        legacy vds single; }
+          neggia_layouts() { same_spots xds_neggia legacy single; }

          fail=0
          summary=""
          for t in dials_legacy dials_vds dials_single dials_tilted \
                   durin_legacy durin_vds durin_single \
                   jfjoch_legacy jfjoch_vds jfjoch_single \
-                   neggia_legacy neggia_single; do
+                   neggia_legacy neggia_single \
+                   durin_layouts jfjoch_layouts neggia_layouts; do
            echo "::group::$t"
            # Run the subshell as a command of its own and test $? afterwards. A subshell used
            # directly as an `if` condition has its `set -e` ignored, so the case would carry on
@@ -32,6 +32,8 @@ rugnux_anomalous*/

 # Test fixtures are checked in deliberately; add them with an explicit path.
 !tests/**
+# The timing benchmark's start models: public AlphaFold DB predictions (no measured cell, no sample)
+!tools/battery/models/AF-*-model_v*.cif

 # CMake configures GitInfo.cpp.in into the BINARY dir; a copy here is only ever the residue of an
 # in-source configure, and a stale one shipped a wrong version string once already.
@@ -24,7 +24,8 @@ the build tree is what every `find_package(Eigen3)` resolves — ours, Ceres' an
 already on the machine is used instead if the configure is given `-DZLIB_ROOT=` / `-DEigen3_DIR=`.
 Do **not** turn either of these into `FetchContent ... OVERRIDE_FIND_PACKAGE` — see the Eigen note in
 `CMakeLists.txt` for the crash that rules it out.
-libjpeg-turbo is built via `ExternalProject` in `preview/`; libcurl is fetched only for viewer builds.
+libjpeg-turbo is built via `ExternalProject` in `preview/`; Mbed TLS (the viewer's HTTPS
+backend for cpp-httplib) is fetched only for viewer builds.

 ```
 mkdir build && cd build
@@ -43,8 +44,9 @@ Key CMake options:
 - `JFJOCH_VIEWER_BUILD` (default OFF) — builds the Qt6 `jfjoch_viewer` desktop app in addition to
  the server stack.
 - `JFJOCH_VIEWER_ONLY` (default OFF on Linux, **forced ON on Windows/macOS**) — builds only
-  `jfjoch_viewer`, `rugnux` and the libraries they link; skips receiver, FPGA, detector control,
-  tests and the frontend.
+  `jfjoch_viewer`, `rugnux`, the XDS plugin (Linux only) and the libraries they link; skips
+  receiver, FPGA, detector control, tests and the frontend. `cpack` then writes one archive per
+  program (Linux: three `.tar.gz`; macOS: the viewer `.dmg` plus the rugnux `.tar.gz`).
 - `SLS9` (default OFF) — build against slsDetectorPackage 9.2.0 instead of 8.0.2.
 - `JFJOCH_INSTALL_DRIVER_SOURCE` (default OFF) — install the PCIe driver source for DKMS/RPM.

@@ -253,6 +255,9 @@ hand-edit it. `CMakeLists.txt` installs `LICENSE`, `THIRD_PARTY_NOTICES.md` and
 into `share/doc/jfjoch` for every package component, so nothing further is needed to reach the built
 product.

+**The XDS plugin ships its own notices** (`xds-plugin/THIRD_PARTY_NOTICES.md` +
+`JFJOCH_XDS_PLUGIN_LICENSES` in its CMakeLists); update both when its link line changes.
+
 A **build-time dependency** (`FetchContent`/`ExternalProject`, statically linked) is handled the
 same way with one difference: there is no in-tree copy, so `COLLECT.sh` reads its licence out of the
 populated `_deps/` tree — which means that collection step needs a configured build — and the row
@@ -362,9 +367,12 @@ generated API model and internal types.
 (`beam_stop/ShadowFinder` is built and runs by default in `rugnux` — it is no longer the unbuilt
 prototype an older version of this file described). Least-squares refinement uses **Ceres** (fetched in
 `image_analysis/CMakeLists.txt`, built with miniglog, no MKL, no Ceres-CUDA, CXX_THREADS).
-The indexer is chosen with `-X` (`FFBIDX|FFT|FFTW|Auto|None`, default `Auto`, which resolves to a
+The indexer is chosen with `-X` (`Auto|FFT|cuFFT|FFTW|FFBIDX|None`, default `Auto`, which resolves to a
 GPU indexer when one is present and `fftw` otherwise): `ffbidx` wants a known cell (`-C`) and suits
-sparse serial stills; `fft`/`fftw` index de novo and suit strong rotation data.
+sparse serial stills; `fft` indexes de novo and suits strong rotation data - it is the algorithm, run
+with cuFFT on a GPU and with FFTW without one (or under `--no-gpu`), while `cufft`/`fftw` name one
+implementation each. Only rugnux's CLI spells it this way: internally (and in the broker's OpenAPI)
+`FFT` is the GPU implementation, which the CLI's `cufft` maps onto.

 **FPGA** (`fpga/`): `hls/` is the Vitis HLS source (image-analysis kernels), `hls_simulation/`
 runs that same HLS on CPU for hardware-free testing, `hdl/` is the Verilog RTL, `host_library/` is
@@ -400,7 +408,7 @@ portable; don't constrain it for portability's sake.
  intended Windows configuration.

 `JFJOCH_VIEWER_ONLY` is forced ON on Windows and macOS, so a plain configure there already builds
-just the portable subset. libtiff, libjpeg-turbo (via `ExternalProject` in `preview/`) and libcurl
+just the portable subset. libtiff, libjpeg-turbo (via `ExternalProject` in `preview/`) and Mbed TLS
 (viewer builds only) are now brought in by the build itself, so they need nothing from the host.
 **ZLIB** and **Eigen** (header-only; needed by Ceres, by the analysis libs directly, and by `ffbidx`
 under CUDA) are brought in by the build too, so on Windows only Qt still has to be installed first.
@@ -408,7 +416,7 @@ Both are still reached through an ordinary `find_package`, and that is the point
 through `FetchContent` with `OVERRIDE_FIND_PACKAGE` remains specifically ruled out** — it segfaults
 the CMake bundled with Visual Studio, ~1 in 3 fresh configures and 100% with Ceres CUDA on, in
 CMake's own FetchContent variable-stack cleanup (see the long note in `CMakeLists.txt`). The same
-ban applies to ZLIB, whose consumers (HDF5, libtiff, libcurl) call `find_package(ZLIB)` from inside
+ban applies to ZLIB, whose consumers (HDF5, libtiff, cpp-httplib) call `find_package(ZLIB)` from inside
 their own `FetchContent_MakeAvailable` — the exact faulting pattern. Instead each is made findable
 the ordinary way before anything looks for it: zlib-ng is configured, built and installed into a
 build-tree prefix during the configure and found through `ZLIB_ROOT`, and a generated
@@ -21,6 +21,14 @@ INCLUDE(GNUInstallDirs)
 SET(CMAKE_CXX_STANDARD 20)
 SET(CMAKE_CXX_STANDARD_REQUIRED True)

+# The Metal Bragg integration engine (image_analysis/bragg_integration) is Objective-C++. Enabled here,
+# above every target that links it, as enable_language asks.
+IF (APPLE)
+    ENABLE_LANGUAGE(OBJCXX)
+    SET(CMAKE_OBJCXX_STANDARD 20)
+    SET(CMAKE_OBJCXX_STANDARD_REQUIRED True)
+ENDIF()
+
 # MSVC gets C++ exception handling only from /EHsc, and CMake puts that flag in the DEFAULT value of
 # CMAKE_CXX_FLAGS ("/DWIN32 /D_WINDOWS /GR /EHsc"), which is used only when the configure does not
 # set CMAKE_CXX_FLAGS itself. CI does (-DCMAKE_CXX_FLAGS="/arch:AVX"), and that drops /EHsc: MSVC then
@@ -47,29 +55,48 @@ ENDIF()
 # came out differently from the same source and data. Off, every x86-64 level computes the same bits
 # (measured: identical p.mtz on nine battery sets, no measurable time cost), and aarch64, where FMA is
 # always there and GCC contracts by default, follows the same arithmetic. MSVC does not contract under
-# its default /fp:precise. Host code of .cu sources gets it through nvcc; device code is not affected.
+# its default /fp:precise. Host code of .cu sources gets it through nvcc, and the Metal kernels say so in
+# their source (BraggIntegrationEngineMetal.mm).
 IF (NOT MSVC)
-    ADD_COMPILE_OPTIONS($<$<COMPILE_LANGUAGE:C,CXX>:-ffp-contract=off>)
+    ADD_COMPILE_OPTIONS($<$<COMPILE_LANGUAGE:C,CXX,OBJCXX>:-ffp-contract=off>)
    ADD_COMPILE_OPTIONS($<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-ffp-contract=off>)
 ENDIF()
+# The same for device code. nvcc contracts by default and does it separately for every architecture
+# it compiles for, so a T4 (sm_75) and an RTX 5080 (sm_120) ran the same kernels to different bits
+# and a run that hit a knife edge came out differently on the two machines. Off, the architectures
+# compute the same bits (measured: identical p.hkl from sm_75 and sm_120 builds, no measurable time cost).
+ADD_COMPILE_OPTIONS($<$<COMPILE_LANGUAGE:CUDA>:--fmad=false>)

 SET(JFJOCH_WRITER_ONLY           OFF CACHE BOOL "Compile HDF5 writer only")
 SET(JFJOCH_INSTALL_DRIVER_SOURCE OFF CACHE BOOL "Install kernel driver source (ignored if building writer only; necessary for RPM building)")
 SET(JFJOCH_USE_CUDA              ON CACHE BOOL "Compile Jungfraujoch with CUDA")
 SET(JFJOCH_VIEWER_BUILD          OFF CACHE BOOL "Compile Jungfraujoch viewer")

-# The two shippable products are built separately, one per configure, and each produces exactly one
-# artifact holding exactly one program:
+# The portable products come out of two build modes; every artifact holds exactly one program:
 #
 #   JFJOCH_VIEWER_ONLY   jfjoch_viewer   .tar.gz (Linux) / installer (Windows) / .dmg (macOS)
+#                        and also rugnux (.tar.gz; .zip on Windows) and, on Linux only, the
+#                        XDS plugin (.tar.gz)
 #   JFJOCH_RUGNUX_ONLY   rugnux          .tar.gz (Linux, incl. cross-built aarch64) / .zip (Windows)
 #
+# The viewer build compiles everything rugnux needs anyway, so one build packs all three; the
+# rugnux-only mode remains for where there is no Qt (the aarch64 cross build).
+#
 # They used to be one package: the viewer tarball also carried rugnux and two CLI tools, which made
 # the download confusing (a GUI package containing a batch processor) and meant a rugnux user had to
 # take Qt with it. Splitting them is possible because cuFFT is now linked statically, so neither
 # artifact has to ship a runtime library beside its executable.
 SET(JFJOCH_RUGNUX_ONLY OFF CACHE BOOL "Compile only rugnux, the offline analysis CLI (no Qt)")

+# macOS only: the Developer ID Application certificate to sign the shipped program with at install
+# time - hardened runtime and a secure timestamp, which is what Apple's notarization demands. Given
+# as the certificate's SHA-1 hash, the 40 hex digits `security find-identity -v -p codesigning`
+# prints in front of the name: the name itself ("Developer ID Application: <name> (<team>)") has
+# spaces, and Qt's generated deploy script would split it into separate macdeployqt arguments. Empty
+# (the default) keeps the ad-hoc signature, which runs locally but is refused by Gatekeeper after a
+# download. Notarizing the packed artefact is a separate step after cpack: tools/notarize_macos.sh.
+SET(JFJOCH_MACOS_SIGNING_IDENTITY "" CACHE STRING "macOS: SHA-1 of the Developer ID Application certificate to codesign with (empty: ad-hoc)")
+
 # Only the viewer (and its portable dependency tree) is supported on Windows and macOS -- the
 # broker/receiver/FPGA/writer server stack is Linux-only. Force viewer-only on those platforms so a
 # plain configure builds the right subset; on Linux it remains a user-togglable option. A rugnux-only
@@ -205,16 +232,17 @@ include(FetchContent)
 #
 # It is built HERE, during the configure, into a small install prefix in the build tree, and
 # ZLIB_ROOT then points every find_package(ZLIB) at it -- ours and those of HDF5, libtiff,
-# cpp-httplib and libcurl. Two alternatives were rejected:
+# cpp-httplib. Two alternatives were rejected:
 #
 #  * FetchContent OVERRIDE_FIND_PACKAGE is the mechanism banned by the Eigen note further down
 #    (it segfaults the CMake bundled with Visual Studio), and a subproject's find_package(ZLIB)
 #    resolving an override through a nested FetchContent_MakeAvailable is exactly the faulting
 #    pattern.
 #  * Adding zlib-ng with add_subdirectory and aliasing its target to ZLIB::ZLIB looks simpler, but
-#    ZLIB::ZLIB is then an alias of a target built in this project, and libcurl puts ZLIB::ZLIB in
-#    CMAKE_REQUIRED_LIBRARIES for its OpenSSL feature checks. try_compile only accepts IMPORTED
-#    targets, so that is a hard configure error, not a degraded check (verified).
+#    ZLIB::ZLIB is then an alias of a target built in this project, and a consumer that puts
+#    ZLIB::ZLIB in CMAKE_REQUIRED_LIBRARIES for its feature checks (libcurl did, when the viewer used
+#    it) breaks: try_compile only accepts IMPORTED targets, so that is a hard configure error, not a
+#    degraded check (verified).
 #
 # Building it first and finding it as an ordinary installed library avoids both: every consumer
 # runs the stock FindZLIB module against a real libz.a and gets a genuine imported target.
@@ -522,47 +550,25 @@ IF (WIN32)
    TARGET_INCLUDE_DIRECTORIES(wingetopt PUBLIC tools/wingetopt)
 ENDIF()

-# libcurl: the jfjoch_viewer HTTP client (viewer/JFJochHttpReader). Fetched and STATICALLY linked
-# ONLY for viewer builds, so the broker/writer never pull in a TLS stack. Windows gets its OS-native
-# backends, Schannel (TLS) + SSPI (Negotiate/Kerberos), because they cost nothing there. Linux gets
-# OpenSSL and no Kerberos; macOS gets neither. Trimmed to HTTP(S) only, mirroring the libtiff codec
-# pruning above.
+# Mbed TLS: the TLS backend of cpp-httplib in the jfjoch_viewer HTTP client (viewer/JFJochHttpReader).
+# Fetched and STATICALLY linked ONLY for viewer builds, so the broker/writer never pull in a TLS
+# stack. One backend on every platform: it builds with MSVC and needs nothing from the host, unlike
+# OpenSSL, which the macOS SDK does not have. cpp-httplib loads the trusted roots from the OS store
+# (Windows certificate store, macOS Keychain, the CA bundle on Linux). The release tarball, not
+# the GitHub archive: only it carries the tf-psa-crypto and framework submodules.
 IF (JFJOCH_VIEWER_BUILD OR JFJOCH_VIEWER_ONLY)
-    SET(BUILD_CURL_EXE       OFF CACHE BOOL "" FORCE)
-    SET(BUILD_SHARED_LIBS    OFF CACHE BOOL "" FORCE)   # static libcurl only, never a shared lib
-    SET(BUILD_STATIC_LIBS    ON  CACHE BOOL "" FORCE)
-    SET(BUILD_TESTING        OFF CACHE BOOL "" FORCE)
-    SET(CURL_DISABLE_INSTALL ON  CACHE BOOL "" FORCE)
-    SET(HTTP_ONLY            ON  CACHE BOOL "" FORCE)   # HTTP/HTTPS only; drop FTP/LDAP/SMTP/...
-    SET(CURL_USE_LIBPSL      OFF CACHE BOOL "" FORCE)   # avoid the libpsl dependency
-    SET(CURL_USE_LIBSSH2     OFF CACHE BOOL "" FORCE)
-    SET(CURL_ZLIB            ON  CACHE BOOL "" FORCE)   # reuse the project's ZLIB
-    IF (WIN32)
-        SET(CURL_USE_SCHANNEL ON CACHE BOOL "" FORCE)  # native Windows TLS (no OpenSSL)
-        SET(CURL_USE_SSPI     ON CACHE BOOL "" FORCE)  # native Negotiate/Kerberos (no krb5)
-    ELSEIF (APPLE)
-        # Plain HTTP only: curl dropped Secure Transport in 8.15, so TLS would mean OpenSSL, which
-        # the macOS SDK does not have - it would be the one library a Mac build takes from Homebrew.
-        SET(CURL_ENABLE_SSL   OFF CACHE BOOL "" FORCE)
-    ELSE()
-        SET(CURL_USE_OPENSSL  ON  CACHE BOOL "" FORCE)
-        # The viewer never asks for Negotiate. Set explicitly so that a build tree configured when
-        # this was ON does not keep the cached value.
-        SET(CURL_USE_GSSAPI   OFF CACHE BOOL "" FORCE)
-    ENDIF()
-    FetchContent_Declare(curl
-            URL https://github.com/curl/curl/archive/refs/tags/curl-8_22_0.tar.gz
-            URL_HASH SHA256=222c6b5c1f368ac63aed59bce2774eb5def9e8e67e46e800be182e684d2845a3
+    SET(ENABLE_PROGRAMS                OFF CACHE BOOL "" FORCE)
+    SET(ENABLE_TESTING                 OFF CACHE BOOL "" FORCE)
+    SET(MBEDTLS_FATAL_WARNINGS         OFF CACHE BOOL "" FORCE)
+    SET(TF_PSA_CRYPTO_FATAL_WARNINGS   OFF CACHE BOOL "" FORCE)
+    SET(USE_STATIC_MBEDTLS_LIBRARY     ON  CACHE BOOL "" FORCE)
+    SET(USE_SHARED_MBEDTLS_LIBRARY     OFF CACHE BOOL "" FORCE)
+    SET(USE_SHARED_TF_PSA_CRYPTO_LIBRARY OFF CACHE BOOL "" FORCE)
+    FetchContent_Declare(mbedtls
+            URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-4.2.0/mbedtls-4.2.0.tar.bz2
+            URL_HASH SHA256=2bed9d713b4668f76553b097e72b8aa30bc8f112a940d7ae228d524bbde6ffea
            EXCLUDE_FROM_ALL)
-    FetchContent_MakeAvailable(curl)
-    # The viewer links libcurl_static (curl's concrete static-lib target) directly rather than the
-    # CURL::libcurl alias: the alias can be shadowed by a system libcurl (find_package / dependency
-    # provider / a distro CURL config), silently linking the OS curl with the wrong TLS/Kerberos
-    # backend. libcurl_static is unambiguous; guard that FetchContent actually produced it.
-    IF (NOT TARGET libcurl_static)
-        MESSAGE(FATAL_ERROR "libcurl_static missing after FetchContent_MakeAvailable(curl) -- "
-                            "the vendored static libcurl was not built.")
-    ENDIF()
+    FetchContent_MakeAvailable(mbedtls)
 ENDIF()

 # The notices every package ships (installed at the end of this file). Set before the subdirectories
@@ -605,6 +611,9 @@ ELSEIF (JFJOCH_VIEWER_ONLY)
    ADD_SUBDIRECTORY(viewer)
    ADD_SUBDIRECTORY(tools)   # builds only the portable analysis tools (rugnux/extract_hkl)
    ADD_SUBDIRECTORY(tests)   # jfjoch_portable_test only
+    IF (NOT WIN32 AND NOT APPLE)   # no native XDS for Windows; the macOS plugin is not tested
+        ADD_SUBDIRECTORY(xds-plugin)
+    ENDIF()
 ELSE()
    ADD_SUBDIRECTORY(jungfrau)
    ADD_SUBDIRECTORY(compression)
@@ -677,9 +686,8 @@ IF (WIN32 AND JFJOCH_CUDA_AVAILABLE AND JFJOCH_PORTABLE_ONLY AND NOT TARGET CUDA
    IF (NOT _cufft_dll)
        MESSAGE(FATAL_ERROR "cuFFT runtime DLL not found under ${CUDAToolkit_BIN_DIR}")
    ENDIF()
-    IF (JFJOCH_RUGNUX_ONLY)
-        INSTALL(FILES ${_cufft_dll} DESTINATION bin COMPONENT rugnux)
-    ELSE()
+    INSTALL(FILES ${_cufft_dll} DESTINATION bin COMPONENT rugnux)
+    IF (JFJOCH_VIEWER_ONLY)
        INSTALL(FILES ${_cufft_dll} DESTINATION bin COMPONENT viewer)
    ENDIF()
 ENDIF()
@@ -694,8 +702,10 @@ SET(CPACK_PACKAGE_NAME "jfjoch")
 # Select the components to package based on build mode
 if (JFJOCH_RUGNUX_ONLY)
    set(CPACK_COMPONENTS_ALL rugnux)
+elseif (JFJOCH_VIEWER_ONLY AND (WIN32 OR APPLE))
+    set(CPACK_COMPONENTS_ALL viewer rugnux)   # the XDS plugin is built on Linux only
 elseif (JFJOCH_VIEWER_ONLY)
-    set(CPACK_COMPONENTS_ALL viewer)
+    set(CPACK_COMPONENTS_ALL viewer rugnux xds_plugin)
 else()
    # rugnux is packaged separately from everything else, as "rugnux" rather than "jfjoch-rugnux"
    # (see the DEB/RPM branches below). It is the offline analysis CLI: it links none of the
@@ -716,17 +726,57 @@ set(CPACK_PACKAGE_CONTACT "Filip Leonarski <filip.leonarski@psi.ch>")
 set(CPACK_PACKAGE_VENDOR "Paul Scherrer Institut")
 set(CPACK_PACKAGE_VERSION ${JFJOCH_VERSION})

+# Names of the portable .tar.gz archives (CI renames them to .tgz). rugnux and the plugin always
+# carry their architecture, because rugnux is built for more than one: x86_64 natively and aarch64
+# through the cross toolchain. CMAKE_SYSTEM_PROCESSOR is the TARGET architecture (the toolchain file
+# declares it), never the build host's. The Linux viewer is x86_64-only and keeps its existing name.
+# The plugin has no -cuda/-cpu tag: it does not use CUDA, so both variants build the same library.
+if (APPLE)
+    set(_jfjoch_tgz_os "macos")
+else()
+    set(_jfjoch_tgz_os "linux")
+endif()
+if (JFJOCH_CUDA_AVAILABLE)
+    set(_jfjoch_tgz_variant "cuda${CUDAToolkit_VERSION_MAJOR}")
+else()
+    set(_jfjoch_tgz_variant "cpu")
+endif()
+set(CPACK_ARCHIVE_VIEWER_FILE_NAME "jfjoch_viewer-${JFJOCH_VERSION}-${_jfjoch_tgz_os}-${_jfjoch_tgz_variant}")
+if (WIN32)
+    set(CPACK_ARCHIVE_RUGNUX_FILE_NAME "rugnux-${JFJOCH_VERSION}-win64-${_jfjoch_tgz_variant}")
+else()
+    set(CPACK_ARCHIVE_RUGNUX_FILE_NAME "rugnux-${JFJOCH_VERSION}-${_jfjoch_tgz_os}-${CMAKE_SYSTEM_PROCESSOR}-${_jfjoch_tgz_variant}")
+endif()
+set(CPACK_ARCHIVE_XDS_PLUGIN_FILE_NAME "jfjoch_xds_plugin-${JFJOCH_VERSION}-linux-${CMAKE_SYSTEM_PROCESSOR}")
+
+# macOS and Windows pack the viewer as a .dmg / NSIS installer and the other programs of the same
+# build (rugnux) as an archive. CPack reads
+# CPACK_PROJECT_CONFIG_FILE once per generator, which is where each generator gets its components.
+file(WRITE ${CMAKE_BINARY_DIR}/CPackProjectConfig.cmake [=[
+if (CPACK_GENERATOR STREQUAL "TGZ" OR CPACK_GENERATOR STREQUAL "ZIP")
+    list(REMOVE_ITEM CPACK_COMPONENTS_ALL viewer)
+    set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+    set(CPACK_COMPONENTS_GROUPING IGNORE)
+else()
+    set(CPACK_COMPONENTS_ALL viewer)
+endif()
+]=])
+
 # OS-aware packaging: DragNDrop (.dmg) on macOS, NSIS installer on Windows, DEB on Debian/Ubuntu,
 # RPM on RHEL/Rocky. macOS/Windows are checked first because the /etc/* probes below are Linux-only.
 if (APPLE AND NOT JFJOCH_RUGNUX_ONLY)
    # .dmg containing jfjoch_viewer.app (Qt runtime already deployed into the bundle). Named like the
    # Windows and Linux artifacts; CMAKE_SYSTEM_PROCESSOR is arm64 on Apple Silicon.
-    set(CPACK_GENERATOR "DragNDrop")
+    # plus rugnux as .tar.gz, see CPackProjectConfig.cmake above
+    set(CPACK_GENERATOR "DragNDrop;TGZ")
+    set(CPACK_PROJECT_CONFIG_FILE ${CMAKE_BINARY_DIR}/CPackProjectConfig.cmake)
    set(CPACK_PACKAGE_FILE_NAME "jfjoch-viewer-${JFJOCH_VERSION}-macos-${CMAKE_SYSTEM_PROCESSOR}")
    set(CPACK_DMG_VOLUME_NAME "Jungfraujoch Viewer ${JFJOCH_VERSION}")
 elseif (WIN32 AND NOT JFJOCH_RUGNUX_ONLY)
-    # NSIS installer .exe (Qt runtime deployed next to the binary by windeployqt).
-    set(CPACK_GENERATOR "NSIS")
+    # NSIS installer .exe (Qt runtime deployed next to the binary by windeployqt), plus rugnux as
+    # a .zip, see CPackProjectConfig.cmake above.
+    set(CPACK_GENERATOR "NSIS;ZIP")
+    set(CPACK_PROJECT_CONFIG_FILE ${CMAKE_BINARY_DIR}/CPackProjectConfig.cmake)

    # GPLv3 text shown as the click-through license page of the installer.
    set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
@@ -767,49 +817,26 @@ elseif (WIN32)
    set(CPACK_GENERATOR "ZIP")
    set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
    set(CPACK_COMPONENTS_GROUPING ALL_COMPONENTS_IN_ONE)
-    if (JFJOCH_CUDA_AVAILABLE)
-        set(CPACK_PACKAGE_FILE_NAME "rugnux-${JFJOCH_VERSION}-win64-cuda${CUDAToolkit_VERSION_MAJOR}")
-    else()
-        set(CPACK_PACKAGE_FILE_NAME "rugnux-${JFJOCH_VERSION}-win64-cpu")
-    endif()
+    set(CPACK_PACKAGE_FILE_NAME ${CPACK_ARCHIVE_RUGNUX_FILE_NAME})
 elseif (JFJOCH_VIEWER_ONLY OR JFJOCH_RUGNUX_ONLY)
-    # Linux portable viewer: a single self-contained .tar.gz of jfjoch_viewer (Qt is linked
-    # statically here, so there is nothing external to ship alongside the binary). Built on the
-    # oldest supported distro (RHEL 8) for a low glibc floor, so the archive runs on any newer
-    # Linux -- unlike the per-distro .rpm/.deb this is meant to replace in the release. Named to
-    # mirror the Windows/macOS artifacts, with the same -cuda<major>/-cpu tag so the (larger) GPU
-    # build is self-identifying. CI renames the .tar.gz to .tgz before upload.
+    # Linux portable products: self-contained .tar.gz archives (Qt is linked statically, so there is
+    # nothing external to ship alongside a binary). Built on the oldest supported distro (RHEL 8) for
+    # a low glibc floor, so an archive runs on any newer Linux -- unlike the per-distro .rpm/.deb
+    # these replace in the release.
    set(CPACK_GENERATOR "TGZ")
-    # Package only the components in CPACK_COMPONENTS_ALL (here: viewer). Without this the archive
-    # generator falls back to a monolithic install and walks every install() rule in the tree --
-    # including the fetched HDF5 command-line tools, abseil's EXCLUDE_FROM_ALL sub-libraries and the
-    # non-viewer components -- none of which the viewer-only build produces, so cpack aborts with
-    # "cannot find <artifact>". ALL_COMPONENTS_IN_ONE keeps the output a single tarball named
-    # CPACK_PACKAGE_FILE_NAME (no per-component suffix), matching the CI upload glob. This mirrors
+    # Package only the components in CPACK_COMPONENTS_ALL. Without this the archive generator falls
+    # back to a monolithic install and walks every install() rule in the tree -- including the
+    # fetched HDF5 command-line tools and abseil's EXCLUDE_FROM_ALL sub-libraries -- which the
+    # portable build does not produce, so cpack aborts with "cannot find <artifact>". This mirrors
    # CPACK_DEB_COMPONENT_INSTALL / CPACK_RPM_COMPONENT_INSTALL in the DEB/RPM branches below.
    set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
-    set(CPACK_COMPONENTS_GROUPING ALL_COMPONENTS_IN_ONE)
-    # The rugnux archive always carries its architecture, because it is built for more than one:
-    # x86_64 natively and aarch64 through the cross toolchain. CMAKE_SYSTEM_PROCESSOR is the TARGET
-    # architecture (the toolchain file declares it), never the build host's, so a cross-built tarball
-    # cannot be mistaken for a native one. The viewer is x86_64-only and keeps its existing name.
    if (JFJOCH_RUGNUX_ONLY)
-        set(_jfjoch_tgz_name "rugnux")
-        set(_jfjoch_tgz_arch "-${CMAKE_SYSTEM_PROCESSOR}")
+        # A single tarball named CPACK_PACKAGE_FILE_NAME (no per-component suffix).
+        set(CPACK_COMPONENTS_GROUPING ALL_COMPONENTS_IN_ONE)
+        set(CPACK_PACKAGE_FILE_NAME ${CPACK_ARCHIVE_RUGNUX_FILE_NAME})
    else()
-        set(_jfjoch_tgz_name "jfjoch_viewer")
-        set(_jfjoch_tgz_arch "")
-    endif()
-    # A rugnux-only build is the one portable product that also packs as .tgz on macOS.
-    if (APPLE)
-        set(_jfjoch_tgz_os "macos")
-    else()
-        set(_jfjoch_tgz_os "linux")
-    endif()
-    if (JFJOCH_CUDA_AVAILABLE)
-        set(CPACK_PACKAGE_FILE_NAME "${_jfjoch_tgz_name}-${JFJOCH_VERSION}-${_jfjoch_tgz_os}${_jfjoch_tgz_arch}-cuda${CUDAToolkit_VERSION_MAJOR}")
-    else()
-        set(CPACK_PACKAGE_FILE_NAME "${_jfjoch_tgz_name}-${JFJOCH_VERSION}-${_jfjoch_tgz_os}${_jfjoch_tgz_arch}-cpu")
+        # One tarball per program -- viewer, rugnux, XDS plugin -- named by CPACK_ARCHIVE_<C>_FILE_NAME.
+        set(CPACK_COMPONENTS_GROUPING IGNORE)
    endif()
 elseif (EXISTS "/etc/debian_version")
    set(CPACK_PACKAGE_LICENSE "GPL-3.0-only")
@@ -932,6 +959,9 @@ FOREACH(_component IN LISTS CPACK_COMPONENTS_ALL)
    IF (APPLE AND _component STREQUAL "viewer")
        CONTINUE()   # inside the .app bundle instead, see viewer/CMakeLists.txt
    ENDIF()
+    IF (_component STREQUAL "xds_plugin")
+        CONTINUE()   # its own, shorter set, see xds-plugin/CMakeLists.txt
+    ENDIF()
    IF (_component STREQUAL "jfjoch")
        SET(_suffix broker)
    ELSE()
@@ -679,10 +679,19 @@ Public License instead of this License.  But first, please read

 ================

-As a special exception, we specifically permit linking Jungfraujoch code with Nvidia CUDA libraries and Intel MKL.
+Additional permissions under section 7 of the GNU GPL version 3

-We also permit to link Jungfraujoch software (GPLv3) with Jungfraujoch high-level synthesis code (CERN OHL 2.0) for the purpose
-of simulating FPGA design on CPU.
+The copyright holders of Jungfraujoch grant the following additional permissions. They apply only
+to code whose copyright the Jungfraujoch copyright holders own; they do not and cannot change the
+license of third-party code.

-If OpenAPI definition file (jfjoch_api.yaml) is solely used to generate client code or to interact with the Jungfraujoch
-API it may be distributed under terms of your choosing without being subject to GPL requirements.
+1. NVIDIA CUDA. The NVIDIA CUDA Toolkit libraries (the CUDA runtime, cuFFT and the other libraries
+   distributed with the CUDA Toolkit) are treated as System Libraries for the purposes of this
+   License, so a work linked with them may be conveyed without their Corresponding Source.
+
+2. FPGA simulation. Jungfraujoch software (GPL-3.0) may be linked with Jungfraujoch high-level
+   synthesis code (CERN-OHL-S-2.0) to simulate the FPGA design on a CPU.
+
+3. OpenAPI definition. Client code generated from the OpenAPI definition file (jfjoch_api.yaml), or
+   code that uses that file solely to interact with the Jungfraujoch API, may be distributed under
+   terms of your choosing, without being subject to the requirements of the GNU GPL.
@@ -30,21 +30,20 @@ linked into the Jungfraujoch executables.
 | [Abseil](https://github.com/abseil/abseil-cpp) | 20250127 (required by Ceres) | Google Inc. | Apache-2.0 | [abseil.txt](licenses/abseil.txt) |
 | [fast-feedback-indexer](https://github.com/paulscherrerinstitute/fast-feedback-indexer) | (pinned) | PSI | BSD-3-Clause | [fast-feedback-indexer.txt](licenses/fast-feedback-indexer.txt) |
 | [libjpeg-turbo](https://github.com/libjpeg-turbo/libjpeg-turbo) | 3.2.0 | D. R. Commander and others; IJG | IJG + BSD-3-Clause + Zlib | [libjpeg-turbo.txt](licenses/libjpeg-turbo.txt) |
-| [curl](https://github.com/curl/curl) | 8.22.0 | Daniel Stenberg and contributors | curl (MIT-like) | [curl.txt](licenses/curl.txt) |
+| [Mbed TLS](https://github.com/Mbed-TLS/mbedtls) (with TF-PSA-Crypto) | 4.2.0 | The Mbed TLS Contributors | Apache-2.0 OR GPL-2.0-or-later (used under Apache-2.0) | [mbedtls.txt](licenses/mbedtls.txt), [tf-psa-crypto.txt](licenses/tf-psa-crypto.txt) |
 | [Catch2](https://github.com/catchorg/Catch2) | 3.16.0 | Catch2 Authors | BSL-1.0 | [catch2.txt](licenses/catch2.txt) |
 | [zlib-ng](https://github.com/zlib-ng/zlib-ng) | 2.3.3 | Jean-loup Gailly and Mark Adler; the zlib-ng contributors | Zlib | [zlib.txt](licenses/zlib.txt) |
 | [Eigen](https://gitlab.com/libeigen/eigen) | 3.4.1 | Benoit Jacob, Gael Guennebaud and contributors | MPL-2.0 (+ BSD parts) | [eigen.txt](licenses/eigen.txt), [README](licenses/eigen-README.txt) |

-libcurl is fetched and statically linked only for viewer builds (`JFJOCH_VIEWER_BUILD` /
-`JFJOCH_VIEWER_ONLY`), where it is `jfjoch_viewer`'s HTTP client; the broker and writer never link
-it. Its TLS and Kerberos backends are the OS-native ones (Schannel/SSPI on Windows, OpenSSL and
-system krb5 on Linux), so no TLS stack is vendored with it.
+Mbed TLS is fetched and statically linked only for viewer builds (`JFJOCH_VIEWER_BUILD` /
+`JFJOCH_VIEWER_ONLY`), where it is the TLS backend of `jfjoch_viewer`'s cpp-httplib client; the
+broker and writer never link it.

 Catch2 is used only to build the test binary (`jfjoch_test`) and is not part of any shipped
 artifact; it is listed here for completeness.

 zlib is supplied by zlib-ng built in its zlib-compatible mode (same `zlib.h`, same API and symbol
-names), so it is the zlib that HDF5, libtiff, cpp-httplib, libcurl and GEMMI all link. It is
+names), so it is the zlib that HDF5, libtiff, cpp-httplib and GEMMI all link. It is
 built during the configure rather than added as a subproject; the licence is the zlib licence
 either way. Eigen is header-only: only its headers reach the binaries, and no Eigen CMake runs.

@@ -73,6 +72,18 @@ These live in the source tree (see the path) rather than being fetched; traccc a
 | [xbflash.qspi](https://github.com/Xilinx/XRT) | `tools/xbflash.qspi/` | Xilinx / AMD | Apache-2.0 | [xbflash-qspi.txt](licenses/xbflash-qspi.txt) |
 | [wingetopt](https://github.com/alex85k/wingetopt) | `tools/wingetopt/` | Todd C. Miller; The NetBSD Foundation | ISC AND BSD-2-Clause | [wingetopt.txt](licenses/wingetopt.txt) |

+## Data files in the repository
+
+Not code and not linked into any binary: input files of the battery's timing benchmark
+(`tools/battery/timing.json`), kept verbatim as downloaded.
+
+| Component | Path | Copyright | License (SPDX) | License text |
+|---|---|---|---|---|
+| [AlphaFold Protein Structure Database](https://alphafold.ebi.ac.uk/) predictions AF-P68082-F1 and AF-P62894-F1 (v6), with their predicted aligned error | `tools/battery/models/` | DeepMind Technologies Limited; EMBL-EBI | CC-BY-4.0 | [alphafold-db.txt](licenses/alphafold-db.txt) |
+
+The benchmark's third start model is made at run time from the deposited coordinates of PDB entry
+4NWV, downloaded from the RCSB PDB (PDB data are CC0 1.0); nothing of it is committed.
+
 ## Runtime libraries and SDKs (shipped in binaries, not in the source tree)

 | Component | Used by | License | Notice |
@@ -1 +1 @@
-1.0.0-rc.174
+1.0.0-rc.175
@@ -15,6 +15,8 @@
 #include "../common/GitInfo.h"
 #include "../preview/JFJochTIFF.h"
 #include "OpenAPIConvert.h"
+#include "../image_pusher/LiveCollection.h"
+#include <base64/Base64.h>
 #include "gen/model/Error_message.h"

 using namespace org::openapitools::server::model;
@@ -149,7 +151,8 @@ static const std::set<std::string> PROTECTED_PATHS{
        "/image_buffer/image.jpeg",
        "/image_buffer/image.tiff",
        "/preview/plot",
-        "/preview/plot.bin"
+        "/preview/plot.bin",
+        "/live/events"
 };

 std::optional<std::string> JFJochBrokerHttp::AuthorizationHeader(const httplib::Request &req) {
@@ -328,6 +331,7 @@ void JFJochBrokerHttp::register_routes(httplib::Server &server) {
    });

    server.Get("/image_buffer/start.cbor", bind_noarg(&JFJochBrokerHttp::image_buffer_start_cbor_get));
+    server.Get("/live/events", bind_noarg(&JFJochBrokerHttp::live_events_get));
    server.Get("/image_buffer/status", bind_noarg(&JFJochBrokerHttp::image_buffer_status_get));
    server.Get("/image_pusher/status", bind_noarg(&JFJochBrokerHttp::image_pusher_status_get));
    server.Post("/initialize", bind_noarg(&JFJochBrokerHttp::initialize_post));
@@ -789,6 +793,88 @@ void JFJochBrokerHttp::image_buffer_start_cbor_get(httplib::Response &response)
        response.status = 404;
 }

+namespace {
+    std::string ServerSentEvent(const std::string &event, const nlohmann::json &data) {
+        return "event: " + event + "\ndata: " + data.dump() + "\n\n";
+    }
+}
+
+void JFJochBrokerHttp::live_events_get(httplib::Response &response) {
+    LiveCollection *live = services.GetLiveCollection();
+    if (live == nullptr) {
+        response.status = 409;
+        response.set_content("Following a collection needs the TCP or the HDF5 image pusher", "text/plain");
+        return;
+    }
+    const uint64_t generation = live->Get().generation;
+    if (generation == 0) {
+        response.status = 404;
+        response.set_content("No collection has started", "text/plain");
+        return;
+    }
+    if (!live->AcquireFollower()) {
+        response.status = 409;
+        response.set_content("Another reader is following the current collection", "text/plain");
+        return;
+    }
+
+    // The whole history of the collection first, then every change, until the collection ends or a new
+    // one begins. A comment every 10 s when nothing happens, so a reader can tell a quiet collection
+    // from a dead connection.
+    struct Cursor {
+        bool collection_sent = false;
+        size_t files_sent = 0;
+        bool done = false;
+    };
+    auto cursor = std::make_shared<Cursor>();
+    response.set_header("Cache-Control", "no-cache");
+    response.set_header("X-Accel-Buffering", "no");
+    response.set_chunked_content_provider(
+            "text/event-stream",
+            [live, generation, cursor](size_t, httplib::DataSink &sink) {
+                if (cursor->done) {
+                    sink.done();
+                    return true;
+                }
+                const auto s = live->Wait(generation, cursor->collection_sent, cursor->files_sent,
+                                          std::chrono::seconds(10));
+                std::string out;
+                // The start message first, once it is known: a collection is announced at /start, and a
+                // DECTRIS detector sends its start message only afterwards.
+                if (!cursor->collection_sent && s.started && s.generation == generation) {
+                    const auto cbor = live->StartCBOR().value_or(std::vector<uint8_t>{});
+                    out += ServerSentEvent("start", {
+                            {"run_number", s.run_number}, {"run_name", s.run_name},
+                            {"file_prefix", s.file_prefix}, {"number_of_images", s.number_of_images},
+                            {"images_per_file", s.images_per_file},
+                            {"cbor", macaron::Encode(std::string(cbor.begin(), cbor.end()))}});
+                    cursor->collection_sent = true;
+                }
+                if (s.generation != generation) {
+                    out += ServerSentEvent("superseded", {{"run_number", s.run_number}});
+                    cursor->done = true;
+                } else {
+                    for (; cursor->files_sent < s.files.size(); cursor->files_sent++) {
+                        const auto &f = s.files[cursor->files_sent];
+                        out += ServerSentEvent("file", {
+                                {"file_number", f.file_number}, {"file", f.file},
+                                {"first_image", f.first_image}, {"image_count", f.image_count}});
+                    }
+                    if (s.ended) {
+                        nlohmann::json end = {{"images", s.end_images}};
+                        if (!s.end_error.empty())
+                            end["error"] = s.end_error;
+                        out += ServerSentEvent("end", end);
+                        cursor->done = true;
+                    }
+                }
+                if (out.empty())
+                    out = ": keepalive\n\n";
+                return sink.write(out.data(), out.size());
+            },
+            [live](bool) { live->ReleaseFollower(); });
+}
+
 void JFJochBrokerHttp::image_buffer_status_get(httplib::Response &response) {
    ProcessOutput(Convert(state_machine.GetImageBufferStatus()), response);
 }
@@ -85,6 +85,11 @@ class JFJochBrokerHttp {

    void register_routes(httplib::Server &server);

+    // A reader following the current collection while it is written: an event stream of its start
+    // message and of the data files as they are closed (docs/JFJOCH_BROKER.md, "Following a
+    // collection").
+    void live_events_get(httplib::Response &response);
+
    void cancel_post(httplib::Response &response);
    void deactivate_post(httplib::Response &response);
    void initialize_post(httplib::Response &response);
@@ -140,15 +140,17 @@ JFJochServicesOutput JFJochServices::Stop() {
                    DetectorState state = detector->GetState();
                    while ((!cannot_stop_detector)
                           && ((state == DetectorState::WAITING) || (state == DetectorState::BUSY))) {
-                        // check detector state every 5 ms
-                        std::this_thread::sleep_for(std::chrono::milliseconds(5));
+                        // check detector state every 100 ms - every check is an HTTP request for DECTRIS
+                        std::this_thread::sleep_for(std::chrono::milliseconds(100));
                        state = detector->GetState();
                    }
                    if (state == DetectorState::IDLE) {
                        logger.Info("   ... detector idle");
                        receiver->Cancel(true); // cancel silently
                    } else {
-                        logger.Error("   ... detector in error state");
+                        logger.Error("   ... detector not idle: state {}{}; {}", to_string(state),
+                                     cannot_stop_detector ? " (stop command failed)" : "",
+                                     detector->GetErrorDescription());
                        receiver->Cancel(false);
                        detector_error = true;
                    }
@@ -207,6 +209,9 @@ void JFJochServices::Cancel() {
        // Best effort - if detector cannot be stopped, this is OK, important to still stop receiver
        try {
            detector->Stop();
+        } catch (const std::exception &e) {
+            logger.Error("Cannot stop detector: {}", e.what());
+            cannot_stop_detector = true;
        } catch (...) {
            cannot_stop_detector = true;
        }
@@ -365,6 +370,10 @@ void JFJochServices::SetupIndexing(const IndexingSettings &input) {
        receiver->Indexing(input);
 }

+LiveCollection *JFJochServices::GetLiveCollection() {
+    return receiver ? receiver->GetLiveCollection() : nullptr;
+}
+
 ImagePusherStatus JFJochServices::GetImagePusherStatus() const {
    if (receiver)
        return receiver->GetImagePusherStatus();
@@ -77,5 +77,6 @@ public:
    void SetupIndexing(const IndexingSettings& input);

    ImagePusherStatus GetImagePusherStatus() const;
+    LiveCollection *GetLiveCollection();
 };

@@ -4,6 +4,7 @@
 #include <thread>

 #include "JFJochStateMachine.h"
+#include "../image_pusher/LiveCollection.h"
 #include "../preview/JFJochTIFF.h"
 #include "../common/CUDAWrapper.h"
 #include "../common/GitInfo.h"
@@ -426,6 +427,10 @@ void JFJochStateMachine::Start(const DatasetSettings &settings, bool async, std:
    experiment.IncrementRunNumber();

    SetState(JFJochState::Busy, "Preparing measurement", BrokerStatus::MessageSeverity::Info);
+    // From here on a reader can follow the collection (/live/*), even before the image pusher has
+    // its start message.
+    if (auto *live = services.GetLiveCollection())
+        live->Expect();
    measurement = std::async(std::launch::async, &JFJochStateMachine::MeasurementThread, this);
    if (!async) {
        c.wait(ul, [&]() { return state != JFJochState::Busy; });
@@ -465,6 +470,16 @@ PixelMaskStatistics JFJochStateMachine::GetPixelMaskStatistics() const {
 }

 void JFJochStateMachine::MeasurementThread() {
+    // However the measurement ends, a reader following it (/live/events) learns that it did - also
+    // when it ended before the image pusher started or ended it.
+    struct LiveEnd {
+        LiveCollection *live;
+        ~LiveEnd() {
+            if (live)
+                live->EndIfOpen("the measurement ended without the writers finishing the collection");
+        }
+    } live_end{services.GetLiveCollection()};
+
    try {
        // Before anything is started: ask the writer whether it could write this run. A run that
        // would be refused for a file already there, or a directory that cannot be made, is
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.174
+* The version of the OpenAPI document: 1.0.0-rc.175
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).