From 56ea689de608eb02dc1f2684993638b0f1e8d2c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Benjamin=20Yule=20B=C3=A4dorf?= Date: Sun, 25 Feb 2024 17:41:25 +0100 Subject: [PATCH] feat: add nix config to this repository This used to live in the old pub-solar/os repository in the `momo/main` branch. This commit changes that so this repository has all code from terraform to nix. --- .envrc | 13 + .forgejo/workflows/check.yml | 50 + .gitignore | 15 +- flake.lock | 342 + flake.nix | 100 + hosts/default.nix | 19 + hosts/pioneer-momo-koeln/caddy.nix | 18 + hosts/pioneer-momo-koeln/configuration.nix | 34 + hosts/pioneer-momo-koeln/default.nix | 6 + hosts/pioneer-momo-koeln/erpnext.nix | 38 + .../hardware-configuration.nix | 54 + hosts/pioneer-momo-koeln/keycloak.nix | 25 + lib/add-local-hostname.nix | 4 + lib/compat/default.nix | 21 + lib/compat/nixos/default.nix | 9 + lib/default.nix | 21 + lib/deploy.nix | 64 + modules/adb/default.nix | 15 + modules/arduino/default.nix | 17 + modules/audio/.config/vimpc/vimpcrc | 53 + modules/audio/default.nix | 39 + modules/audio/easyeffects.service.nix | 7 + modules/bluetooth/default.nix | 35 + modules/core/boot.nix | 35 + modules/core/default.nix | 38 + modules/core/hibernation.nix | 36 + modules/core/i18n.nix | 20 + modules/core/networking.nix | 39 + modules/core/packages.nix | 28 + modules/crypto/default.nix | 33 + ...kit-gnome-authentication-agent.service.nix | 15 + modules/ddclient/default.nix | 269 + modules/default.nix | 42 + modules/desktop-extended/default.nix | 49 + modules/docker/default.nix | 20 + modules/email/default.nix | 54 + modules/email/offlineimap.py | 9 + modules/gaming/default.nix | 21 + modules/graphical/.Xdefaults | 62 + .../graphical/.config/libinput-gestures.conf | 198 + modules/graphical/.config/mako/config | 22 + modules/graphical/.config/swaync/config.json | 12 + modules/graphical/.config/swaync/style.css | 149 + modules/graphical/.config/user-dirs.dirs | 15 + modules/graphical/.config/user-dirs.locale | 1 + .../graphical/.config/waybar/colorscheme.css | 23 + modules/graphical/.config/waybar/config | 148 + modules/graphical/.config/waybar/style.css | 80 + modules/graphical/.config/xmodmap | 8 + .../.config/xsettingsd/xsettingsd.conf | 18 + modules/graphical/.xinitrc | 75 + modules/graphical/alacritty.nix | 271 + modules/graphical/assets/pub-solar.jpg | Bin 0 -> 525702 bytes modules/graphical/assets/wallpaper.jpg | Bin 0 -> 171929 bytes modules/graphical/default.nix | 166 + .../network-manager-applet.service.nix | 15 + .../sway/config/config.d/applications.conf | 78 + .../sway/config/config.d/colorscheme.conf | 19 + .../config/config.d/custom-keybindings.conf | 47 + .../graphical/sway/config/config.d/gaps.conf | 53 + .../sway/config/config.d/mode_system.conf.nix | 41 + .../sway/config/config.d/systemd.conf | 8 + .../graphical/sway/config/config.d/theme.conf | 16 + modules/graphical/sway/config/config.nix | 217 + .../graphical/sway/config/wayvnc/config.nix | 11 + modules/graphical/sway/default.nix | 101 + modules/graphical/sway/gammastep.service.nix | 17 + .../sway/libinput-gestures.service.nix | 18 + modules/graphical/sway/mako.service.nix | 18 + .../graphical/sway/sway-session.target.nix | 9 + modules/graphical/sway/sway.service.nix | 17 + modules/graphical/sway/swayidle.service.nix | 26 + .../sway/swaynotificationcenter.service.nix | 21 + modules/graphical/sway/waybar.service.nix | 21 + modules/graphical/sway/xsettingsd.service.nix | 18 + modules/graphical/sway/ydotool.service.nix | 18 + modules/hm-system-defaults.nix | 11 + modules/invoiceplane/default.nix | 377 + modules/nextcloud/default.nix | 13 + modules/nextcloud/nextcloud.service.nix | 20 + modules/nix/default.nix | 65 + modules/office/default.nix | 20 + modules/printing/default.nix | 40 + modules/terminal-life/.config/git/config.nix | 47 + .../terminal-life/.config/git/gitmessage.nix | 32 + .../.config/git/global_gitignore.nix | 6 + .../share/nvim/json-schemas/caddy_schema.json | 8087 +++++++++++++++++ .../.local/share/scripts/base16.sh | 126 + modules/terminal-life/bash/default.nix | 114 + modules/terminal-life/default.nix | 113 + modules/terminal-life/direnv/default.nix | 6 + modules/terminal-life/fzf/default.nix | 17 + modules/terminal-life/git/default.nix | 40 + ...1-feat-use-wasd-keybindings-for-jkli.patch | 38 + modules/terminal-life/nvim/clipboard.vim | 20 + modules/terminal-life/nvim/default.nix | 199 + modules/terminal-life/nvim/init.vim | 108 + modules/terminal-life/nvim/lsp.vim | 258 + modules/terminal-life/nvim/plugins.vim | 87 + modules/terminal-life/nvim/preview-file.nix | 36 + .../terminal-life/nvim/quickfixopenall.vim | 20 + modules/terminal-life/nvim/ui.vim | 32 + modules/terminal-life/starship.toml.nix | 169 + modules/user/.config/dircolors | 243 + modules/user/.config/mimeapps.list | 0 modules/user/default.nix | 101 + modules/user/home.nix | 50 + modules/user/mimeapps.nix | 27 + modules/user/session-variables.nix | 119 + modules/virtualisation/default.nix | 55 + modules/wireguard-client/default.nix | 54 + overlays/blesh.nix | 32 + overlays/default.nix | 35 + overlays/neovim-plugins.nix | 24 + overlays/nix-index.nix | 24 + pkgs/_sources/generated.nix | 114 + pkgs/default.nix | 24 + pkgs/drone-docker-runner.nix | 33 + pkgs/import-gtk-settings.nix | 12 + pkgs/lgcl.nix | 8 + pkgs/mailto-mutt.nix | 11 + pkgs/mopidy-jellyfin.nix | 29 + pkgs/mu.nix | 4 + pkgs/prison-break-url.patch | 15 + pkgs/prison-break.nix | 49 + pkgs/psos-docs.nix | 27 + pkgs/psos.nix | 34 + pkgs/record-screen.nix | 11 + pkgs/s.nix | 40 + pkgs/sources.toml | 38 + pkgs/sway-launcher.nix | 65 + pkgs/sway-service.nix | 7 + pkgs/swaylock-bg.nix | 20 + pkgs/toggle-kbd-layout.nix | 16 + pkgs/uhk-agent.nix | 44 + pkgs/wcwd.nix | 6 + secrets/erpnext-admin-password.age | 29 + secrets/erpnext-db-root-password.age | 31 + secrets/erpnext-db-user-password.age | 29 + secrets/keycloak-database-password.age | Bin 0 -> 1617 bytes secrets/secrets.nix | 24 + users/barkeeper/default.nix | 41 + users/default.nix | 9 + users/modules/.flake-keep | 0 users/nixos/default.nix | 36 + users/root/default.nix | 3 + 146 files changed, 15416 insertions(+), 2 deletions(-) create mode 100644 .envrc create mode 100644 .forgejo/workflows/check.yml create mode 100644 flake.lock create mode 100644 flake.nix create mode 100644 hosts/default.nix create mode 100644 hosts/pioneer-momo-koeln/caddy.nix create mode 100644 hosts/pioneer-momo-koeln/configuration.nix create mode 100644 hosts/pioneer-momo-koeln/default.nix create mode 100644 hosts/pioneer-momo-koeln/erpnext.nix create mode 100644 hosts/pioneer-momo-koeln/hardware-configuration.nix create mode 100644 hosts/pioneer-momo-koeln/keycloak.nix create mode 100644 lib/add-local-hostname.nix create mode 100644 lib/compat/default.nix create mode 100644 lib/compat/nixos/default.nix create mode 100644 lib/default.nix create mode 100644 lib/deploy.nix create mode 100644 modules/adb/default.nix create mode 100644 modules/arduino/default.nix create mode 100644 modules/audio/.config/vimpc/vimpcrc create mode 100644 modules/audio/default.nix create mode 100644 modules/audio/easyeffects.service.nix create mode 100644 modules/bluetooth/default.nix create mode 100644 modules/core/boot.nix create mode 100644 modules/core/default.nix create mode 100644 modules/core/hibernation.nix create mode 100644 modules/core/i18n.nix create mode 100644 modules/core/networking.nix create mode 100644 modules/core/packages.nix create mode 100644 modules/crypto/default.nix create mode 100644 modules/crypto/polkit-gnome-authentication-agent.service.nix create mode 100644 modules/ddclient/default.nix create mode 100644 modules/default.nix create mode 100644 modules/desktop-extended/default.nix create mode 100644 modules/docker/default.nix create mode 100644 modules/email/default.nix create mode 100644 modules/email/offlineimap.py create mode 100644 modules/gaming/default.nix create mode 100644 modules/graphical/.Xdefaults create mode 100644 modules/graphical/.config/libinput-gestures.conf create mode 100644 modules/graphical/.config/mako/config create mode 100644 modules/graphical/.config/swaync/config.json create mode 100644 modules/graphical/.config/swaync/style.css create mode 100644 modules/graphical/.config/user-dirs.dirs create mode 100644 modules/graphical/.config/user-dirs.locale create mode 100644 modules/graphical/.config/waybar/colorscheme.css create mode 100644 modules/graphical/.config/waybar/config create mode 100644 modules/graphical/.config/waybar/style.css create mode 100644 modules/graphical/.config/xmodmap create mode 100644 modules/graphical/.config/xsettingsd/xsettingsd.conf create mode 100644 modules/graphical/.xinitrc create mode 100644 modules/graphical/alacritty.nix create mode 100644 modules/graphical/assets/pub-solar.jpg create mode 100644 modules/graphical/assets/wallpaper.jpg create mode 100644 modules/graphical/default.nix create mode 100644 modules/graphical/network-manager-applet.service.nix create mode 100644 modules/graphical/sway/config/config.d/applications.conf create mode 100644 modules/graphical/sway/config/config.d/colorscheme.conf create mode 100644 modules/graphical/sway/config/config.d/custom-keybindings.conf create mode 100644 modules/graphical/sway/config/config.d/gaps.conf create mode 100644 modules/graphical/sway/config/config.d/mode_system.conf.nix create mode 100644 modules/graphical/sway/config/config.d/systemd.conf create mode 100644 modules/graphical/sway/config/config.d/theme.conf create mode 100644 modules/graphical/sway/config/config.nix create mode 100644 modules/graphical/sway/config/wayvnc/config.nix create mode 100644 modules/graphical/sway/default.nix create mode 100644 modules/graphical/sway/gammastep.service.nix create mode 100644 modules/graphical/sway/libinput-gestures.service.nix create mode 100644 modules/graphical/sway/mako.service.nix create mode 100644 modules/graphical/sway/sway-session.target.nix create mode 100644 modules/graphical/sway/sway.service.nix create mode 100644 modules/graphical/sway/swayidle.service.nix create mode 100644 modules/graphical/sway/swaynotificationcenter.service.nix create mode 100644 modules/graphical/sway/waybar.service.nix create mode 100644 modules/graphical/sway/xsettingsd.service.nix create mode 100644 modules/graphical/sway/ydotool.service.nix create mode 100644 modules/hm-system-defaults.nix create mode 100644 modules/invoiceplane/default.nix create mode 100644 modules/nextcloud/default.nix create mode 100644 modules/nextcloud/nextcloud.service.nix create mode 100644 modules/nix/default.nix create mode 100644 modules/office/default.nix create mode 100644 modules/printing/default.nix create mode 100644 modules/terminal-life/.config/git/config.nix create mode 100644 modules/terminal-life/.config/git/gitmessage.nix create mode 100644 modules/terminal-life/.config/git/global_gitignore.nix create mode 100644 modules/terminal-life/.local/share/nvim/json-schemas/caddy_schema.json create mode 100644 modules/terminal-life/.local/share/scripts/base16.sh create mode 100644 modules/terminal-life/bash/default.nix create mode 100644 modules/terminal-life/default.nix create mode 100644 modules/terminal-life/direnv/default.nix create mode 100644 modules/terminal-life/fzf/default.nix create mode 100644 modules/terminal-life/git/default.nix create mode 100644 modules/terminal-life/nnn/0001-feat-use-wasd-keybindings-for-jkli.patch create mode 100644 modules/terminal-life/nvim/clipboard.vim create mode 100644 modules/terminal-life/nvim/default.nix create mode 100644 modules/terminal-life/nvim/init.vim create mode 100644 modules/terminal-life/nvim/lsp.vim create mode 100644 modules/terminal-life/nvim/plugins.vim create mode 100644 modules/terminal-life/nvim/preview-file.nix create mode 100644 modules/terminal-life/nvim/quickfixopenall.vim create mode 100644 modules/terminal-life/nvim/ui.vim create mode 100644 modules/terminal-life/starship.toml.nix create mode 100644 modules/user/.config/dircolors create mode 100644 modules/user/.config/mimeapps.list create mode 100644 modules/user/default.nix create mode 100644 modules/user/home.nix create mode 100644 modules/user/mimeapps.nix create mode 100644 modules/user/session-variables.nix create mode 100644 modules/virtualisation/default.nix create mode 100644 modules/wireguard-client/default.nix create mode 100644 overlays/blesh.nix create mode 100644 overlays/default.nix create mode 100644 overlays/neovim-plugins.nix create mode 100644 overlays/nix-index.nix create mode 100644 pkgs/_sources/generated.nix create mode 100644 pkgs/default.nix create mode 100644 pkgs/drone-docker-runner.nix create mode 100644 pkgs/import-gtk-settings.nix create mode 100644 pkgs/lgcl.nix create mode 100644 pkgs/mailto-mutt.nix create mode 100644 pkgs/mopidy-jellyfin.nix create mode 100644 pkgs/mu.nix create mode 100644 pkgs/prison-break-url.patch create mode 100644 pkgs/prison-break.nix create mode 100644 pkgs/psos-docs.nix create mode 100644 pkgs/psos.nix create mode 100644 pkgs/record-screen.nix create mode 100644 pkgs/s.nix create mode 100644 pkgs/sources.toml create mode 100644 pkgs/sway-launcher.nix create mode 100644 pkgs/sway-service.nix create mode 100644 pkgs/swaylock-bg.nix create mode 100644 pkgs/toggle-kbd-layout.nix create mode 100644 pkgs/uhk-agent.nix create mode 100644 pkgs/wcwd.nix create mode 100644 secrets/erpnext-admin-password.age create mode 100644 secrets/erpnext-db-root-password.age create mode 100644 secrets/erpnext-db-user-password.age create mode 100644 secrets/keycloak-database-password.age create mode 100644 secrets/secrets.nix create mode 100644 users/barkeeper/default.nix create mode 100644 users/default.nix create mode 100644 users/modules/.flake-keep create mode 100644 users/nixos/default.nix create mode 100644 users/root/default.nix diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..e32c27d --- /dev/null +++ b/.envrc @@ -0,0 +1,13 @@ +# reload when these files change +watch_file shell/* flake.nix +use flake || use nix + +#watch_file flake.nix +#watch_file shell.nix +# +#{ +# # shell gc root dir +# mkdir -p "$(direnv_layout_dir)" +# +# eval "$(nix print-dev-env --profile $(direnv_layout_dir)/flake-profile)" +#} || use nix diff --git a/.forgejo/workflows/check.yml b/.forgejo/workflows/check.yml new file mode 100644 index 0000000..e474c17 --- /dev/null +++ b/.forgejo/workflows/check.yml @@ -0,0 +1,50 @@ +name: Flake checks +on: [pull_request] +env: + USER: ci + +jobs: + Check: + runs-on: ubuntu-latest + steps: + - name: Check out repository code + uses: https://code.forgejo.org/actions/checkout@v4 + + - uses: https://github.com/nixbuild/nix-quick-install-action@v26 + with: + load_nixConfig: false + nix_conf: | + substituters = https://cache.nixos.org/ https://nix-community.cachix.org + trusted-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs= + keep-outputs = true + + - name: Calculate flake.lock hash + id: flake-lock-hash + run: | + echo "hash=$(md5sum flake.lock | awk '{print $1}')" >> $GITHUB_OUTPUT + + - name: Restore and cache Nix store + uses: https://github.com/nix-community/cache-nix-action@v4 + id: nix-store-cache + with: + key: cache-${{ runner.os }}-nix-store-${{ steps.flake-lock-hash.outputs.hash }} + restore-keys: | + cache-${{ runner.os }}-nix-store- + + gc-linux: true + gc-max-store-size-linux: 10000000000 + + purge-caches: true + purge-keys: cache-${{ runner.os }}-nix-store- + purge-created: true + purge-created-max-age: 42 + + # - name: Prepare cachix + # uses: https://github.com/cachix/cachix-action@v12 + # with: + # name: pub-solar + # authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}' + + - name: Run flake checks + run: | + nix --print-build-logs --verbose --accept-flake-config --access-tokens '' flake check diff --git a/.gitignore b/.gitignore index 092cd25..37acdb0 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,13 @@ -.terraform -*.plan +result +.direnv +doc/index.html + +# Result of bud commands +vm +iso +doi + +pkgs/_sources/.shake* + +tags +/owners diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..99dd0cd --- /dev/null +++ b/flake.lock @@ -0,0 +1,342 @@ +{ + "nodes": { + "agenix": { + "inputs": { + "darwin": [ + "nix-darwin" + ], + "home-manager": [ + "home-manager" + ], + "nixpkgs": [ + "nixpkgs" + ], + "systems": "systems" + }, + "locked": { + "lastModified": 1703433843, + "narHash": "sha256-nmtA4KqFboWxxoOAA6Y1okHbZh+HsXaMPFkYHsoDRDw=", + "owner": "ryantm", + "repo": "agenix", + "rev": "417caa847f9383e111d1397039c9d4337d024bf0", + "type": "github" + }, + "original": { + "owner": "ryantm", + "repo": "agenix", + "type": "github" + } + }, + "deploy-rs": { + "inputs": { + "flake-compat": [ + "flake-compat" + ], + "nixpkgs": [ + "nixpkgs" + ], + "utils": "utils" + }, + "locked": { + "lastModified": 1703087360, + "narHash": "sha256-0VUbWBW8VyiDRuimMuLsEO4elGuUw/nc2WDeuO1eN1M=", + "owner": "serokell", + "repo": "deploy-rs", + "rev": "b709d63debafce9f5645a5ba550c9e0983b3d1f7", + "type": "github" + }, + "original": { + "owner": "serokell", + "repo": "deploy-rs", + "type": "github" + } + }, + "devshell": { + "inputs": { + "nixpkgs": [ + "erpnext", + "nixpkgs" + ], + "systems": [ + "erpnext", + "systems" + ] + }, + "locked": { + "lastModified": 1701787589, + "narHash": "sha256-ce+oQR4Zq9VOsLoh9bZT8Ip9PaMLcjjBUHVPzW5d7Cw=", + "owner": "numtide", + "repo": "devshell", + "rev": "44ddedcbcfc2d52a76b64fb6122f209881bd3e1e", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "devshell", + "type": "github" + } + }, + "erpnext": { + "inputs": { + "agenix": [ + "agenix" + ], + "devshell": "devshell", + "nixpkgs": [ + "nixpkgs" + ], + "systems": "systems_3" + }, + "locked": { + "lastModified": 1704557841, + "narHash": "sha256-KpAkdJnY1NV21zRRd8Tncw6nBerSv50qmz6pSpjsxLg=", + "ref": "main", + "rev": "7fc327263630e2f5ce693e8569a1072bd0cea67b", + "revCount": 49, + "type": "git", + "url": "https://git.pub.solar/axeman/erpnext-nix" + }, + "original": { + "ref": "main", + "type": "git", + "url": "https://git.pub.solar/axeman/erpnext-nix" + } + }, + "flake-compat": { + "flake": false, + "locked": { + "lastModified": 1696426674, + "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=", + "owner": "edolstra", + "repo": "flake-compat", + "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33", + "type": "github" + }, + "original": { + "owner": "edolstra", + "repo": "flake-compat", + "type": "github" + } + }, + "flake-parts": { + "inputs": { + "nixpkgs-lib": "nixpkgs-lib" + }, + "locked": { + "lastModified": 1704152458, + "narHash": "sha256-DS+dGw7SKygIWf9w4eNBUZsK+4Ug27NwEWmn2tnbycg=", + "owner": "hercules-ci", + "repo": "flake-parts", + "rev": "88a2cd8166694ba0b6cb374700799cec53aef527", + "type": "github" + }, + "original": { + "owner": "hercules-ci", + "repo": "flake-parts", + "type": "github" + } + }, + "home-manager": { + "inputs": { + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1704099619, + "narHash": "sha256-QRVMkdxLmv+aKGjcgeEg31xtJEIsYq4i1Kbyw5EPS6g=", + "owner": "nix-community", + "repo": "home-manager", + "rev": "7e398b3d76bc1503171b1364c9d4a07ac06f3851", + "type": "github" + }, + "original": { + "owner": "nix-community", + "ref": "release-23.11", + "repo": "home-manager", + "type": "github" + } + }, + "nix-darwin": { + "inputs": { + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1704277720, + "narHash": "sha256-meAKNgmh3goankLGWqqpw73pm9IvXjEENJloF0coskE=", + "owner": "lnl7", + "repo": "nix-darwin", + "rev": "0dd382b70c351f528561f71a0a7df82c9d2be9a4", + "type": "github" + }, + "original": { + "owner": "lnl7", + "ref": "master", + "repo": "nix-darwin", + "type": "github" + } + }, + "nixos-flake": { + "locked": { + "lastModified": 1702145288, + "narHash": "sha256-apVeRT0kOnDejwwBwbwNccm+qq1l6+qUOiRKE0vK5qk=", + "owner": "srid", + "repo": "nixos-flake", + "rev": "4e422edf6b511f8e214b392cf1a0d4707a0399a4", + "type": "github" + }, + "original": { + "owner": "srid", + "repo": "nixos-flake", + "type": "github" + } + }, + "nixos-hardware": { + "locked": { + "lastModified": 1704458188, + "narHash": "sha256-f6BYEuIqnbrs6J/9m1/1VdkJ6d63hO9kUC09kTPuOqE=", + "owner": "nixos", + "repo": "nixos-hardware", + "rev": "172385318068519900a7d71c1024242fa6af75f0", + "type": "github" + }, + "original": { + "owner": "nixos", + "repo": "nixos-hardware", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1704420045, + "narHash": "sha256-C36QmoJd5tdQ5R9MC1jM7fBkZW9zBUqbUCsgwS6j4QU=", + "owner": "nixos", + "repo": "nixpkgs", + "rev": "c1be43e8e837b8dbee2b3665a007e761680f0c3d", + "type": "github" + }, + "original": { + "owner": "nixos", + "ref": "nixos-23.11", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-lib": { + "locked": { + "dir": "lib", + "lastModified": 1703961334, + "narHash": "sha256-M1mV/Cq+pgjk0rt6VxoyyD+O8cOUiai8t9Q6Yyq4noY=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "b0d36bd0a420ecee3bc916c91886caca87c894e9", + "type": "github" + }, + "original": { + "dir": "lib", + "owner": "NixOS", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "agenix": "agenix", + "deploy-rs": "deploy-rs", + "erpnext": "erpnext", + "flake-compat": "flake-compat", + "flake-parts": "flake-parts", + "home-manager": "home-manager", + "nix-darwin": "nix-darwin", + "nixos-flake": "nixos-flake", + "nixos-hardware": "nixos-hardware", + "nixpkgs": "nixpkgs", + "unstable": "unstable" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + }, + "systems_2": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + }, + "systems_3": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + }, + "unstable": { + "locked": { + "lastModified": 1704194953, + "narHash": "sha256-RtDKd8Mynhe5CFnVT8s0/0yqtWFMM9LmCzXv/YKxnq4=", + "owner": "nixos", + "repo": "nixpkgs", + "rev": "bd645e8668ec6612439a9ee7e71f7eac4099d4f6", + "type": "github" + }, + "original": { + "owner": "nixos", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "utils": { + "inputs": { + "systems": "systems_2" + }, + "locked": { + "lastModified": 1701680307, + "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "4022d587cbbfd70fe950c1e2083a02621806a725", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..f013635 --- /dev/null +++ b/flake.nix @@ -0,0 +1,100 @@ +{ + description = "Momo infra in nix"; + + nixConfig.extra-experimental-features = "nix-command flakes"; + + inputs = { + # Track channels with commits tested and built by hydra + nixpkgs.url = "github:nixos/nixpkgs/nixos-23.11"; + unstable.url = "github:nixos/nixpkgs/nixos-unstable"; + + flake-compat.url = "github:edolstra/flake-compat"; + flake-compat.flake = false; + + nix-darwin.url = "github:lnl7/nix-darwin/master"; + nix-darwin.inputs.nixpkgs.follows = "nixpkgs"; + + home-manager.url = "github:nix-community/home-manager/release-23.11"; + home-manager.inputs.nixpkgs.follows = "nixpkgs"; + + flake-parts.url = "github:hercules-ci/flake-parts"; + nixos-flake.url = "github:srid/nixos-flake"; + + deploy-rs.url = "github:serokell/deploy-rs"; + deploy-rs.inputs.nixpkgs.follows = "nixpkgs"; + deploy-rs.inputs.flake-compat.follows = "flake-compat"; + + agenix.url = "github:ryantm/agenix"; + agenix.inputs.nixpkgs.follows = "nixpkgs"; + agenix.inputs.darwin.follows = "nix-darwin"; + agenix.inputs.home-manager.follows = "home-manager"; + + nixos-hardware.url = "github:nixos/nixos-hardware"; + + erpnext.url = "git+https://git.pub.solar/axeman/erpnext-nix?ref=main"; + erpnext.inputs.nixpkgs.follows = "nixpkgs"; + erpnext.inputs.agenix.follows = "agenix"; + }; + + outputs = inputs @ {self, ...}: + inputs.flake-parts.lib.mkFlake {inherit inputs;} { + debug = true; + systems = [ + "x86_64-linux" + ]; + + imports = [ + inputs.nixos-flake.flakeModule + ./lib + ./modules + ./hosts + ./users + ./overlays + ]; + + perSystem = args @ { + system, + pkgs, + config, + ... + }: { + _module.args = { + inherit inputs; + pkgs = import inputs.nixpkgs { + inherit system; + overlays = [ + inputs.agenix.overlays.default + ]; + }; + unstable = import inputs.unstable {inherit system;}; + }; + + devShells.default = pkgs.mkShell { + buildInputs = with pkgs; [ + deploy-rs + drone-cli + nixpkgs-fmt + agenix + cachix + editorconfig-checker + nodePackages.prettier + nvfetcher + shellcheck + shfmt + alejandra + treefmt + nixos-generators + ]; + }; + }; + + flake = { + deploy.nodes = self.lib.deploy.mkDeployNodes self.nixosConfigurations { + pioneer-momo-koeln = { + hostname = "80.244.242.4"; + sshUser = "barkeeper"; + }; + }; + }; + }; +} diff --git a/hosts/default.nix b/hosts/default.nix new file mode 100644 index 0000000..16415fc --- /dev/null +++ b/hosts/default.nix @@ -0,0 +1,19 @@ +{ + self, + inputs, + ... +}: { + flake = { + nixosConfigurations = { + pioneer-momo-koeln = self.nixos-flake.lib.mkLinuxSystem { + nixpkgs.hostPlatform = "x86_64-linux"; + imports = [ + self.nixosModules.base + ./pioneer-momo-koeln + self.nixosModules.barkeeper + inputs.erpnext.nixosModules.erpnext + ]; + }; + }; + }; +} diff --git a/hosts/pioneer-momo-koeln/caddy.nix b/hosts/pioneer-momo-koeln/caddy.nix new file mode 100644 index 0000000..b0c77d2 --- /dev/null +++ b/hosts/pioneer-momo-koeln/caddy.nix @@ -0,0 +1,18 @@ +{config, ...}: { + services.caddy = { + enable = true; + email = "wg-tooling@list.momo.koeln"; + virtualHosts = { + "auth.momo.koeln" = { + logFormat = '' + output discard + ''; + extraConfig = '' + reverse_proxy :8080 + ''; + }; + }; + }; + + networking.firewall.allowedTCPPorts = [80 443]; +} diff --git a/hosts/pioneer-momo-koeln/configuration.nix b/hosts/pioneer-momo-koeln/configuration.nix new file mode 100644 index 0000000..b52f7b4 --- /dev/null +++ b/hosts/pioneer-momo-koeln/configuration.nix @@ -0,0 +1,34 @@ +{ + config, + latestModulesPath, + lib, + pkgs, + ... +}: { + imports = [ + ./caddy.nix + ./keycloak.nix + ./erpnext.nix + ]; + + time.timeZone = "Europe/Berlin"; + + networking = { + useDHCP = false; + + interfaces.enp1s0.ipv4.addresses = [ + { + address = "80.244.242.4"; + prefixLength = 29; + } + ]; + + defaultGateway = "80.244.242.1"; + nameservers = ["95.129.51.51" "80.244.244.244"]; + }; + + # Enable the OpenSSH daemon. + services.openssh.enable = true; + + system.stateVersion = "22.05"; +} diff --git a/hosts/pioneer-momo-koeln/default.nix b/hosts/pioneer-momo-koeln/default.nix new file mode 100644 index 0000000..187a110 --- /dev/null +++ b/hosts/pioneer-momo-koeln/default.nix @@ -0,0 +1,6 @@ +{...}: { + imports = [ + ./configuration.nix + ./hardware-configuration.nix + ]; +} diff --git a/hosts/pioneer-momo-koeln/erpnext.nix b/hosts/pioneer-momo-koeln/erpnext.nix new file mode 100644 index 0000000..6deb759 --- /dev/null +++ b/hosts/pioneer-momo-koeln/erpnext.nix @@ -0,0 +1,38 @@ +{ + config, + lib, + inputs, + pkgs, + flake, + ... +}: { + age.secrets.erpnext-admin-password = { + file = "${flake.self}/secrets/erpnext-admin-password.age"; + mode = "700"; + owner = "erpnext"; + }; + age.secrets.erpnext-db-root-password = { + file = "${flake.self}/secrets/erpnext-db-root-password.age"; + mode = "700"; + owner = "erpnext"; + }; + age.secrets.erpnext-db-user-password = { + file = "${flake.self}/secrets/erpnext-db-user-password.age"; + mode = "700"; + owner = "erpnext"; + }; + + # erpnext + services.erpnext = { + enable = true; + domain = "erp.momo.koeln"; + + # Secrets + adminPasswordFile = config.age.secrets.erpnext-admin-password.path; + database.rootPasswordFile = config.age.secrets.erpnext-db-root-password.path; + database.userPasswordFile = config.age.secrets.erpnext-db-user-password.path; + + # Required to enable caddy + caddy = {}; + }; +} diff --git a/hosts/pioneer-momo-koeln/hardware-configuration.nix b/hosts/pioneer-momo-koeln/hardware-configuration.nix new file mode 100644 index 0000000..a1a65bf --- /dev/null +++ b/hosts/pioneer-momo-koeln/hardware-configuration.nix @@ -0,0 +1,54 @@ +{ + config, + pkgs, + lib, + ... +}: { + boot.loader.systemd-boot.enable = false; + boot.loader.grub = { + enable = true; + devices = ["/dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive-scsi0-0-0-1"]; + }; + + boot.initrd.availableKernelModules = ["ahci" "xhci_pci" "virtio_pci" "virtio_scsi" "sd_mod" "sr_mod"]; + boot.kernelModules = ["kvm-intel"]; + boot.extraModulePackages = []; + + boot.initrd.luks.devices."cryptroot" = { + device = "/dev/disk/by-uuid/bf890962-9f43-4c44-a0df-64cabd303662"; + }; + + fileSystems."/" = { + device = "/dev/disk/by-uuid/7eb8989a-6ec4-405f-8810-06486f7621c1"; + fsType = "ext4"; + }; + + fileSystems."/boot" = { + device = "/dev/disk/by-uuid/1fd053f8-725b-418d-aed1-aee71dac2b62"; + fsType = "ext4"; + }; + + swapDevices = [ + {device = "/dev/disk/by-uuid/2f114633-5b71-46ab-88be-997b27927269";} + ]; + + networking = { + defaultGateway = { + address = "80.244.242.1"; + interface = "enp1s0"; + }; + nameservers = ["95.129.51.51" "80.244.244.244"]; + interfaces.enp1s0 = { + useDHCP = false; + ipv4.addresses = [ + { + address = "80.244.242.4"; + prefixLength = 29; + } + ]; + }; + }; + + nixpkgs.hostPlatform = lib.mkDefault "x86_64-linux"; + hardware.cpu.intel.updateMicrocode = lib.mkDefault config.hardware.enableRedistributableFirmware; +} diff --git a/hosts/pioneer-momo-koeln/keycloak.nix b/hosts/pioneer-momo-koeln/keycloak.nix new file mode 100644 index 0000000..1c3cc18 --- /dev/null +++ b/hosts/pioneer-momo-koeln/keycloak.nix @@ -0,0 +1,25 @@ +{ + config, + lib, + inputs, + pkgs, + flake, + ... +}: { + age.secrets.keycloak-database-password = { + file = "${flake.self}/secrets/keycloak-database-password.age"; + mode = "700"; + }; + + # keycloak + services.keycloak = { + enable = true; + database.passwordFile = config.age.secrets.keycloak-database-password.path; + settings = { + hostname = "auth.momo.koeln"; + http-host = "127.0.0.1"; + http-port = 8080; + proxy = "edge"; + }; + }; +} diff --git a/lib/add-local-hostname.nix b/lib/add-local-hostname.nix new file mode 100644 index 0000000..2e15ff5 --- /dev/null +++ b/lib/add-local-hostname.nix @@ -0,0 +1,4 @@ +{lib}: hostnames: { + "127.0.0.1" = hostnames; + "::1" = hostnames; +} diff --git a/lib/compat/default.nix b/lib/compat/default.nix new file mode 100644 index 0000000..fc1bc0c --- /dev/null +++ b/lib/compat/default.nix @@ -0,0 +1,21 @@ +let + lock = builtins.fromJSON (builtins.readFile builtins.path { + path = ../../flake.lock; + name = "lockPath"; + }); + flake = + import + ( + fetchTarball { + url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz"; + sha256 = lock.nodes.flake-compat.locked.narHash; + } + ) + { + src = builtins.path { + path = ../../.; + name = "projectRoot"; + }; + }; +in + flake diff --git a/lib/compat/nixos/default.nix b/lib/compat/nixos/default.nix new file mode 100644 index 0000000..617c6a9 --- /dev/null +++ b/lib/compat/nixos/default.nix @@ -0,0 +1,9 @@ +{...}: let + inherit (default.inputs.nixos) lib; + + host = configs.${hostname} or configs.PubSolarOS; + configs = default.nixosConfigurations; + default = (import ../.).defaultNix; + hostname = lib.fileContents /etc/hostname; +in + host diff --git a/lib/default.nix b/lib/default.nix new file mode 100644 index 0000000..90a7f3f --- /dev/null +++ b/lib/default.nix @@ -0,0 +1,21 @@ +{ + lib, + inputs, + ... +}: { + # Configuration common to all Linux systems + flake = { + lib = let + callLibs = file: import file {inherit lib;}; + in rec { + ## Define your own library functions here! + #id = x: x; + ## Or in files, containing functions that take {lib} + #foo = callLibs ./foo.nix; + ## In configs, they can be used under "lib.our" + + deploy = import ./deploy.nix {inherit inputs lib;}; + addLocalHostname = callLibs ./add-local-hostname.nix; + }; + }; +} diff --git a/lib/deploy.nix b/lib/deploy.nix new file mode 100644 index 0000000..65fd5a5 --- /dev/null +++ b/lib/deploy.nix @@ -0,0 +1,64 @@ +/* +* The contents of this file are adapted from digga +* https://github.com/divnix/digga +* +* Licensed under the MIT license +*/ +{ + lib, + inputs, +}: let + getFqdn = c: let + net = c.config.networking; + fqdn = + if (net ? domain) && (net.domain != null) + then "${net.hostName}.${net.domain}" + else net.hostName; + in + fqdn; +in { + mkDeployNodes = systemConfigurations: extraConfig: + /* + * + Synopsis: mkNodes _systemConfigurations_ _extraConfig_ + + Generate the `nodes` attribute expected by deploy-rs + where _systemConfigurations_ are `nodes`. + + _systemConfigurations_ should take the form of a flake's + _nixosConfigurations_. Note that deploy-rs does not currently support + deploying to darwin hosts. + + _extraConfig_, if specified, will be merged into each of the + nodes' configurations. + + Example _systemConfigurations_ input: + + ``` + { + hostname-1 = { + fastConnection = true; + sshOpts = [ "-p" "25" ]; + }; + hostname-2 = { + sshOpts = [ "-p" "19999" ]; + sshUser = "root"; + }; + } + ``` + * + */ + lib.recursiveUpdate + (lib.mapAttrs + ( + _: c: { + hostname = getFqdn c; + profiles.system = { + user = "root"; + path = inputs.deploy-rs.lib.${c.pkgs.stdenv.hostPlatform.system}.activate.nixos c; + }; + } + ) + systemConfigurations) + extraConfig; +} diff --git a/modules/adb/default.nix b/modules/adb/default.nix new file mode 100644 index 0000000..7a0a83d --- /dev/null +++ b/modules/adb/default.nix @@ -0,0 +1,15 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + programs.adb.enable = true; + + users.users."${psCfg.user.name}" = { + extraGroups = ["adbusers"]; + }; +} diff --git a/modules/arduino/default.nix b/modules/arduino/default.nix new file mode 100644 index 0000000..8b0e51d --- /dev/null +++ b/modules/arduino/default.nix @@ -0,0 +1,17 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + users.users."${psCfg.user.name}" = { + extraGroups = ["dialout"]; + packages = with pkgs; [ + arduino + arduino-cli + ]; + }; +} diff --git a/modules/audio/.config/vimpc/vimpcrc b/modules/audio/.config/vimpc/vimpcrc new file mode 100644 index 0000000..c4b5fcc --- /dev/null +++ b/modules/audio/.config/vimpc/vimpcrc @@ -0,0 +1,53 @@ +echo Parsing config file + +" Set the default tab +set window playlist + +" Set the windows to show at startup +set windows playlist,library,browse,help + +" Stop playing music when we quit +"set stoponquit + +" A silly example of an alias +"alias smiths deleteall; findartist! The Smiths; play 1 + +" Example maps +" map the F key to change to the browse window, go to the first line and enter search mode +"map F :browsegg/ +" map @ to switch to add next, add a song, then change back +"map @ :set add nexta:set add end + +map i +map j +map k + +map h i + +map q ZQ +map Q ZQ + +map l :tabnext +map j :tabprevious + +" Turn consume on when we connect +"consume on + +" Ensure that the database is up to date each connect +update + +" A more complex example, When we start vimpc +" - clear the playlist +" - add all songs +" - shuffle +" - start playling +"deleteall +"addall +"shuffle +"play 1 + +" Color the statusline and tabs +" highlight status blackbg +" highlight tab blackbg + +echo Config File Complete diff --git a/modules/audio/default.nix b/modules/audio/default.nix new file mode 100644 index 0000000..f3ce232 --- /dev/null +++ b/modules/audio/default.nix @@ -0,0 +1,39 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; + xdg = config.home-manager.users."${psCfg.user.name}".xdg; +in { + users.users."${psCfg.user.name}" = { + extraGroups = ["audio"]; + packages = with pkgs; [ + # easyeffects, e.g. for microphone noise filtering + easyeffects + mu + pavucontrol + pa_applet + playerctl + # Needed for pactl cmd, until pw-cli is more mature (vol up/down hotkeys?) + pulseaudio + vimpc + ]; + }; + + home-manager.users."${psCfg.user.name}" = { + xdg.configFile."vimpc/vimpcrc".source = ./.config/vimpc/vimpcrc; + systemd.user.services.easyeffects = import ./easyeffects.service.nix pkgs; + }; + + # rtkit is optional but recommended + security.rtkit.enable = true; + services.pipewire = { + enable = true; + alsa.enable = true; + alsa.support32Bit = true; + pulse.enable = true; + }; +} diff --git a/modules/audio/easyeffects.service.nix b/modules/audio/easyeffects.service.nix new file mode 100644 index 0000000..c172e2b --- /dev/null +++ b/modules/audio/easyeffects.service.nix @@ -0,0 +1,7 @@ +pkgs: { + Service = { + Type = "dbus"; + BusName = "com.github.wwmm.easyeffects"; + ExecStart = "${pkgs.easyeffects}/bin/easyeffects --gapplication-service"; + }; +} diff --git a/modules/bluetooth/default.nix b/modules/bluetooth/default.nix new file mode 100644 index 0000000..4ce05b1 --- /dev/null +++ b/modules/bluetooth/default.nix @@ -0,0 +1,35 @@ +{ + lib, + config, + pkgs, + ... +}: { + hardware.bluetooth = { + enable = true; + # Disable bluetooth on startup to save battery + powerOnBoot = false; + # Disable useless SIM Access Profile plugin + disabledPlugins = [ + "sap" + ]; + settings = { + General = { + # Enables experimental features and interfaces. + # Makes BlueZ Battery Provider available + Experimental = true; + }; + }; + }; + + services.blueman.enable = true; + environment.etc."wireplumber/bluetooth.lua.d/51-bluez-config.lua" = { + text = '' + bluez_monitor.properties = { + ["bluez5.enable-sbc-xq"] = true, + ["bluez5.enable-msbc"] = true, + ["bluez5.enable-hw-volume"] = true, + ["bluez5.headset-roles"] = "[ hsp_hs hsp_ag hfp_hf hfp_ag ]" + } + ''; + }; +} diff --git a/modules/core/boot.nix b/modules/core/boot.nix new file mode 100644 index 0000000..ab45fe4 --- /dev/null +++ b/modules/core/boot.nix @@ -0,0 +1,35 @@ +{ + config, + pkgs, + lib, + ... +}: +with lib; let + cfg = config.pub-solar.core; +in { + options.pub-solar.core.disk-encryption-active = mkOption { + type = types.bool; + default = true; + description = "Whether it should be assumed that there is a cryptroot device"; + }; + + config = { + boot = { + # Mount / luks device in initrd + # Allow fstrim to work on it. + initrd = mkIf cfg.disk-encryption-active { + luks.devices."cryptroot" = { + allowDiscards = true; + }; + }; + + loader.systemd-boot.enable = lib.mkDefault true; + + # Use latest LTS linux kernel by default + kernelPackages = lib.mkDefault pkgs.linuxPackages_6_6; + + # Support ntfs drives + supportedFilesystems = ["ntfs"]; + }; + }; +} diff --git a/modules/core/default.nix b/modules/core/default.nix new file mode 100644 index 0000000..3e388c7 --- /dev/null +++ b/modules/core/default.nix @@ -0,0 +1,38 @@ +{ + config, + lib, + ... +}: +with lib; let + cfg = config.pub-solar.core; + psCfg = config.pub-solar; +in { + imports = [ + ./boot.nix + ./hibernation.nix + ./i18n.nix + ./networking.nix + ./packages.nix + ]; + + # Service that makes Out of Memory Killer more effective + services.earlyoom.enable = true; + + services.logind.lidSwitch = "hibernate"; + + services.tor.settings = { + UseBridges = true; + }; + + # The options below are directly taken from or inspired by + # https://xeiaso.net/blog/paranoid-nixos-2021-07-18 + + # Limit the use of sudo to the group wheel + security.sudo.execWheelOnly = true; + + # Remove the complete default environment of packages like + # nano, perl and rsync + environment.defaultPackages = lib.mkForce []; + + # fileSystems."/".options = [ "noexec" ]; +} diff --git a/modules/core/hibernation.nix b/modules/core/hibernation.nix new file mode 100644 index 0000000..74befd7 --- /dev/null +++ b/modules/core/hibernation.nix @@ -0,0 +1,36 @@ +{ + config, + pkgs, + lib, + ... +}: +with lib; let + cfg = config.pub-solar.core.hibernation; +in { + options.pub-solar.core.hibernation = { + enable = mkOption { + type = types.bool; + default = false; + description = "Whether the device can hibernate. This creates a swapfile at /swapfile."; + }; + + resumeDevice = mkOption { + type = types.nullOr types.str; + default = null; + description = "The location of the hibernation resume swap file."; + }; + + resumeOffset = mkOption { + type = types.nullOr types.int; + default = null; + description = "The swap file offset. Can be found by running `filefrag -v $swap_file_location`. See https://wiki.archlinux.org/title/Power_management/Suspend_and_hibernate#Hibernation_into_swap_file"; + }; + }; + + config = { + boot = mkIf cfg.enable { + resumeDevice = mkIf (cfg.resumeDevice != null) cfg.resumeDevice; + kernelParams = mkIf (cfg.resumeOffset != null) ["resume_offset=${builtins.toString cfg.resumeOffset}"]; + }; + }; +} diff --git a/modules/core/i18n.nix b/modules/core/i18n.nix new file mode 100644 index 0000000..1b52428 --- /dev/null +++ b/modules/core/i18n.nix @@ -0,0 +1,20 @@ +{ + config, + pkgs, + lib, + ... +}: +with lib; { + config = { + # Set your time zone. + time.timeZone = "Europe/Berlin"; + + # Select internationalisation properties. + console = { + font = "Lat2-Terminus16"; + }; + i18n = { + defaultLocale = "en_US.UTF-8"; + }; + }; +} diff --git a/modules/core/networking.nix b/modules/core/networking.nix new file mode 100644 index 0000000..4539c16 --- /dev/null +++ b/modules/core/networking.nix @@ -0,0 +1,39 @@ +{ + flake, + config, + pkgs, + lib, + ... +}: { + # disable NetworkManager and systemd-networkd -wait-online by default + systemd.services.NetworkManager-wait-online.enable = lib.mkDefault false; + systemd.services.systemd-networkd-wait-online.enable = lib.mkDefault false; + + networking.networkmanager = { + # Enable networkmanager. REMEMBER to add yourself to group in order to use nm related stuff. + enable = lib.mkDefault true; + # not as stable as wpa_supplicant yet, also more trouble with 5 GHz networks + #wifi.backend = "iwd"; + }; + + networking.firewall.enable = true; + + # For rage encryption, all hosts need a ssh key pair + services.openssh = { + enable = true; + allowSFTP = lib.mkDefault false; + + openFirewall = lib.mkDefault false; + + settings.PasswordAuthentication = lib.mkDefault false; + settings.KbdInteractiveAuthentication = false; + + extraConfig = '' + AllowTcpForwarding yes + X11Forwarding no + AllowAgentForwarding no + AllowStreamLocalForwarding no + AuthenticationMethods publickey + ''; + }; +} diff --git a/modules/core/packages.nix b/modules/core/packages.nix new file mode 100644 index 0000000..3dcf7d0 --- /dev/null +++ b/modules/core/packages.nix @@ -0,0 +1,28 @@ +{ + config, + pkgs, + lib, + ... +}: +with lib; let + psCfg = config.pub-solar; + cfg = config.pub-solar.core; +in { + environment.systemPackages = with pkgs; [ + # Core unix utility packages + coreutils-full + dnsutils + inetutils + progress + pciutils + usbutils + diffutils + findutils + exfat + + gitMinimal + + btop + mtr + ]; +} diff --git a/modules/crypto/default.nix b/modules/crypto/default.nix new file mode 100644 index 0000000..e959010 --- /dev/null +++ b/modules/crypto/default.nix @@ -0,0 +1,33 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + services.udev.packages = [pkgs.yubikey-personalization]; + services.dbus.packages = [pkgs.gcr]; + services.pcscd.enable = true; + + services.gnome.gnome-keyring.enable = true; + + users.users."${psCfg.user.name}".packages = with pkgs; [ + libsecret + ]; + + home-manager.users."${psCfg.user.name}" = { + systemd.user.services.polkit-gnome-authentication-agent = import ./polkit-gnome-authentication-agent.service.nix pkgs; + + services.gpg-agent = { + enable = true; + pinentryFlavor = "gnome3"; + verbose = true; + }; + + programs.gpg = { + enable = true; + }; + }; +} diff --git a/modules/crypto/polkit-gnome-authentication-agent.service.nix b/modules/crypto/polkit-gnome-authentication-agent.service.nix new file mode 100644 index 0000000..ffa5b78 --- /dev/null +++ b/modules/crypto/polkit-gnome-authentication-agent.service.nix @@ -0,0 +1,15 @@ +pkgs: { + Unit = { + Description = "Legacy polkit authentication agent for GNOME"; + Documentation = ["https://gitlab.freedesktop.org/polkit/polkit/"]; + BindsTo = ["sway-session.target"]; + After = ["sway-session.target"]; + }; + Service = { + Type = "simple"; + ExecStart = "${pkgs.polkit_gnome}/libexec/polkit-gnome-authentication-agent-1"; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/ddclient/default.nix b/modules/ddclient/default.nix new file mode 100644 index 0000000..efcc9bc --- /dev/null +++ b/modules/ddclient/default.nix @@ -0,0 +1,269 @@ +{ + config, + pkgs, + lib, + ... +}: let + cfg = config.services.ddclient; + boolToStr = bool: + if bool + then "yes" + else "no"; + dataDir = "/var/lib/ddclient"; + StateDirectory = builtins.baseNameOf dataDir; + RuntimeDirectory = StateDirectory; + + usev4 = + if cfg.usev4 != "" + then "usev4=${cfg.usev4}" + else ""; + usev6 = + if cfg.usev6 != "" + then "usev6=${cfg.usev6}" + else ""; + + configFile' = pkgs.writeText "ddclient.conf" '' + # This file can be used as a template for configFile or is automatically generated by Nix options. + use=no + ${usev4} + ${usev6} + cache=${dataDir}/ddclient.cache + foreground=yes + login=${cfg.username} + password=${ + if cfg.protocol == "nsupdate" + then "/run/${RuntimeDirectory}/ddclient.key" + else "@password_placeholder@" + } + protocol=${cfg.protocol} + ${lib.optionalString (cfg.script != "") "script=${cfg.script}"} + ${lib.optionalString (cfg.server != "") "server=${cfg.server}"} + ${lib.optionalString (cfg.zone != "") "zone=${cfg.zone}"} + ssl=${boolToStr cfg.ssl} + wildcard=yes + quiet=${boolToStr cfg.quiet} + verbose=${boolToStr cfg.verbose} + ${cfg.extraConfig} + ${lib.concatStringsSep "," cfg.domains} + ''; + configFile = + if (cfg.configFile != null) + then cfg.configFile + else configFile'; + + preStart = '' + install --mode=600 --owner=$USER ${configFile} /run/${RuntimeDirectory}/ddclient.conf + ${lib.optionalString (cfg.configFile == null) ( + if (cfg.protocol == "nsupdate") + then '' + install --mode=600 --owner=$USER ${cfg.passwordFile} /run/${RuntimeDirectory}/ddclient.key + '' + else if (cfg.passwordFile != null) + then '' + "${pkgs.replace-secret}/bin/replace-secret" "@password_placeholder@" "${cfg.passwordFile}" "/run/${RuntimeDirectory}/ddclient.conf" + '' + else '' + sed -i '/^password=@password_placeholder@$/d' /run/${RuntimeDirectory}/ddclient.conf + '' + )} + ''; +in + with lib; { + disabledModules = [ + "services/networking/ddclient.nix" + ]; + + imports = [ + (mkChangedOptionModule ["services" "ddclient" "domain"] ["services" "ddclient" "domains"] + (config: let + value = getAttrFromPath ["services" "ddclient" "domain"] config; + in + if value != "" + then [value] + else [])) + (mkRemovedOptionModule ["services" "ddclient" "homeDir"] "") + (mkRemovedOptionModule ["services" "ddclient" "password"] "Use services.ddclient.passwordFile instead.") + ]; + + ###### interface + + options = { + services.ddclient = with lib.types; { + enable = mkOption { + default = false; + type = bool; + description = lib.mdDoc '' + Whether to synchronise your machine's IP address with a dynamic DNS provider (e.g. dyndns.org). + ''; + }; + + package = mkOption { + type = package; + default = pkgs.ddclient; + defaultText = lib.literalExpression "pkgs.ddclient"; + description = lib.mdDoc '' + The ddclient executable package run by the service. + ''; + }; + + domains = mkOption { + default = [""]; + type = listOf str; + description = lib.mdDoc '' + Domain name(s) to synchronize. + ''; + }; + + username = mkOption { + # For `nsupdate` username contains the path to the nsupdate executable + default = lib.optionalString (config.services.ddclient.protocol == "nsupdate") "${pkgs.bind.dnsutils}/bin/nsupdate"; + defaultText = ""; + type = str; + description = lib.mdDoc '' + User name. + ''; + }; + + passwordFile = mkOption { + default = null; + type = nullOr str; + description = lib.mdDoc '' + A file containing the password or a TSIG key in named format when using the nsupdate protocol. + ''; + }; + + interval = mkOption { + default = "10min"; + type = str; + description = lib.mdDoc '' + The interval at which to run the check and update. + See {command}`man 7 systemd.time` for the format. + ''; + }; + + configFile = mkOption { + default = null; + type = nullOr path; + description = lib.mdDoc '' + Path to configuration file. + When set this overrides the generated configuration from module options. + ''; + example = "/root/nixos/secrets/ddclient.conf"; + }; + + protocol = mkOption { + default = "dyndns2"; + type = str; + description = lib.mdDoc '' + Protocol to use with dynamic DNS provider (see https://sourceforge.net/p/ddclient/wiki/protocols). + ''; + }; + + server = mkOption { + default = ""; + type = str; + description = lib.mdDoc '' + Server address. + ''; + }; + + ssl = mkOption { + default = true; + type = bool; + description = lib.mdDoc '' + Whether to use SSL/TLS to connect to dynamic DNS provider. + ''; + }; + + quiet = mkOption { + default = false; + type = bool; + description = lib.mdDoc '' + Print no messages for unnecessary updates. + ''; + }; + + script = mkOption { + default = ""; + type = str; + description = lib.mdDoc '' + script as required by some providers. + ''; + }; + + usev4 = mkOption { + default = "webv4, webv4=checkip.dyndns.com/, webv4-skip='Current IP Address: '"; + type = str; + description = lib.mdDoc '' + Method to determine the IP address to send to the dynamic DNS provider. + ''; + }; + + usev6 = mkOption { + default = ""; + type = str; + description = lib.mdDoc '' + Method to determine the IP address to send to the dynamic DNS provider. + ''; + }; + + verbose = mkOption { + default = false; + type = bool; + description = lib.mdDoc '' + Print verbose information. + ''; + }; + + zone = mkOption { + default = ""; + type = str; + description = lib.mdDoc '' + zone as required by some providers. + ''; + }; + + extraConfig = mkOption { + default = ""; + type = lines; + description = lib.mdDoc '' + Extra configuration. Contents will be added verbatim to the configuration file. + + ::: {.note} + `daemon` should not be added here because it does not work great with the systemd-timer approach the service uses. + ::: + ''; + }; + }; + }; + + ###### implementation + + config = mkIf config.services.ddclient.enable { + systemd.services.ddclient = { + description = "Dynamic DNS Client"; + wantedBy = ["multi-user.target"]; + after = ["network.target"]; + restartTriggers = optional (cfg.configFile != null) cfg.configFile; + + serviceConfig = { + DynamicUser = true; + RuntimeDirectoryMode = "0700"; + inherit RuntimeDirectory; + inherit StateDirectory; + Type = "oneshot"; + ExecStartPre = "!${pkgs.writeShellScript "ddclient-prestart" preStart}"; + ExecStart = "${lib.getBin cfg.package}/bin/ddclient -file /run/${RuntimeDirectory}/ddclient.conf"; + }; + }; + + systemd.timers.ddclient = { + description = "Run ddclient"; + wantedBy = ["timers.target"]; + timerConfig = { + OnBootSec = cfg.interval; + OnUnitInactiveSec = cfg.interval; + }; + }; + }; + } diff --git a/modules/default.nix b/modules/default.nix new file mode 100644 index 0000000..58ed2c0 --- /dev/null +++ b/modules/default.nix @@ -0,0 +1,42 @@ +{ + self, + inputs, + ... +}: { + flake = { + nixosModules = rec { + audio = import ./audio; + bluetooth = import ./bluetooth; + core = import ./core; + crypto = import ./crypto; + desktop-extended = import ./desktop-extended; + docker = import ./docker; + #email = import ./email; + #gaming = import ./gaming; + graphical = import ./graphical; + #invoiceplane = import ./invoiceplane; + nix = import ./nix; + nextcloud = import ./nextcloud; + office = import ./office; + printing = import ./printing; + terminal-life = import ./terminal-life; + user = import ./user; + virtualisation = import ./virtualisation; + #wireguard-client = import ./wireguard-client; + + base.imports = [ + self.nixosModules.home-manager + inputs.agenix.nixosModules.default + + self.nixosModules.overlays + self.nixosModules.core + self.nixosModules.crypto + self.nixosModules.nix + self.nixosModules.terminal-life + + self.nixosModules.root + self.nixosModules.user + ]; + }; + }; +} diff --git a/modules/desktop-extended/default.nix b/modules/desktop-extended/default.nix new file mode 100644 index 0000000..d0db042 --- /dev/null +++ b/modules/desktop-extended/default.nix @@ -0,0 +1,49 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + users.users."${psCfg.user.name}".packages = with pkgs; [ + ungoogled-chromium + wine + + gimp + inkscape + tigervnc + nodejs + + signal-desktop + tdesktop + element-desktop + + # Nix specific utilities + alejandra + manix + nix-output-monitor + nix-tree + nvd + nixpkgs-review + nix-search-cli + ]; + + fonts = { + packages = with pkgs; [ + dejavu_fonts + fira-code + fira-code-symbols + #google-fonts + lato + montserrat + nerdfonts + noto-fonts + noto-fonts-cjk + open-sans + powerline-fonts + source-sans-pro + ]; + }; +} diff --git a/modules/docker/default.nix b/modules/docker/default.nix new file mode 100644 index 0000000..b7aa344 --- /dev/null +++ b/modules/docker/default.nix @@ -0,0 +1,20 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + virtualisation.docker.enable = true; + virtualisation.docker.package = pkgs.docker_24; + + users.users."${psCfg.user.name}" = { + extraGroups = ["docker"]; + }; + + environment.systemPackages = with pkgs; [ + docker-compose + ]; +} diff --git a/modules/email/default.nix b/modules/email/default.nix new file mode 100644 index 0000000..d9530d8 --- /dev/null +++ b/modules/email/default.nix @@ -0,0 +1,54 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + users.users."${psCfg.user.name}".packages = with pkgs; [ + w3m + urlscan + neomutt + offlineimap + msmtp + mailto-mutt + ]; + + home-manager.users."${psCfg.user.name}" = { + programs.offlineimap = { + enable = true; + pythonFile = builtins.readFile ./offlineimap.py; + }; + + xdg.configFile."mutt/muttrc".source = ./.config/mutt/muttrc; + xdg.configFile."mutt/base16.muttrc".source = ./.config/mutt/base16.muttrc; + xdg.configFile."mutt/mailcap".source = ./.config/mutt/mailcap; + xdg.configFile."offlineimap/functions.py".source = ./.config/offlineimap/functions.py; + + xdg.configFile."mutt/accounts.muttrc".text = '' + source ./hello@benjaminbaedorf.eu.muttrc + + macro index 'source $XDG_CONFIG_HOME/mutt/hello@benjaminbaedorf.eu.muttrc!' + macro index 'source $XDG_CONFIG_HOME/mutt/benjamin.baedorf@rwth-aachen.de.muttrc!' + macro index 'source $XDG_CONFIG_HOME/mutt/byb@miom.space.muttrc!' + macro index 'source $XDG_CONFIG_HOME/mutt/mail@b12f.io.muttrc!' + macro index 'source $XDG_CONFIG_HOME/mutt/admins@pub.solar.muttrc!' + macro index 'source $XDG_CONFIG_HOME/mutt/crew@pub.solar.muttrc!' + ''; + xdg.configFile."mutt/hello@benjaminbaedorf.eu.muttrc".source = ./.config/mutt + "/hello@benjaminbaedorf.eu.muttrc"; + xdg.configFile."mutt/benjamin.baedorf@rwth-aachen.de.muttrc".source = ./.config/mutt + "/benjamin.baedorf@rwth-aachen.de.muttrc"; + xdg.configFile."mutt/hello@benjaminbaedorf.eu.signature".source = ./.config/mutt + "/hello@benjaminbaedorf.eu.signature"; + xdg.configFile."mutt/byb@miom.space.muttrc".source = ./.config/mutt + "/byb@miom.space.muttrc"; + xdg.configFile."mutt/byb@miom.space.signature".source = ./.config/mutt + "/byb@miom.space.signature"; + xdg.configFile."mutt/mail@b12f.io.muttrc".source = ./.config/mutt + "/mail@b12f.io.muttrc"; + xdg.configFile."mutt/mail@b12f.io.signature".source = ./.config/mutt + "/mail@b12f.io.signature"; + xdg.configFile."mutt/admins@pub.solar.muttrc".source = ./.config/mutt + "/admins@pub.solar.muttrc"; + xdg.configFile."mutt/admins@pub.solar.signature".source = ./.config/mutt + "/admins@pub.solar.signature"; + xdg.configFile."mutt/crew@pub.solar.muttrc".source = ./.config/mutt + "/crew@pub.solar.muttrc"; + xdg.configFile."mutt/crew@pub.solar.signature".source = ./.config/mutt + "/crew@pub.solar.signature"; + xdg.configFile."offlineimap/config".source = ./.config/offlineimap/config; + xdg.configFile."msmtp/config".source = ./.config/msmtp/config; + }; +} diff --git a/modules/email/offlineimap.py b/modules/email/offlineimap.py new file mode 100644 index 0000000..110b9e4 --- /dev/null +++ b/modules/email/offlineimap.py @@ -0,0 +1,9 @@ +#! /usr/bin/env python2 +import os +import subprocess + +def get_env(key): + return os.getenv(key) + +def get_secret(*attributes): + return subprocess.check_output(["secret-tool", "lookup"] + list(attributes)) diff --git a/modules/gaming/default.nix b/modules/gaming/default.nix new file mode 100644 index 0000000..ba654d1 --- /dev/null +++ b/modules/gaming/default.nix @@ -0,0 +1,21 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + programs.steam.enable = true; + nixpkgs.config.packageOverrides = pkgs: { + steam = pkgs.steam.override {}; + }; + + users.users."${psCfg.user.name}".packages = with pkgs; [ + playonlinux + godot + obs-studio + obs-studio-plugins.wlrobs + ]; +} diff --git a/modules/graphical/.Xdefaults b/modules/graphical/.Xdefaults new file mode 100644 index 0000000..fcfcb22 --- /dev/null +++ b/modules/graphical/.Xdefaults @@ -0,0 +1,62 @@ +Xft.dpi: 96 +Xft.antialias: true +Xft.hinting: true +Xft.rgba: rgb +Xft.autohint: false +Xft.hintstyle: hintslight +Xft.lcdfilter: lcddefault + +! Base16 Burn +! Scheme: Benjamin Bädorf + +#define base00 #1a181a +#define base01 #2d2a2e +#define base02 #303030 +#define base03 #949494 +#define base04 #d3d1d4 +#define base05 #e3e1e4 +#define base06 #303030 +#define base07 #ff5f5f +#define base08 #f85e84 +#define base09 #df5923 +#define base0A #e5c463 +#define base0B #9ecd6f +#define base0C #ef9062 +#define base0D #7accd7 +#define base0E #ab9df2 +#define base0F #d70000 + +*foreground: base05 +#ifdef background_opacity +*background: [background_opacity]base00 +#else +*background: base00 +#endif +*cursorColor: base05 + +*color0: base00 +*color1: base08 +*color2: base0B +*color3: base0A +*color4: base0D +*color5: base0E +*color6: base0C +*color7: base05 + +*color8: base03 +*color9: base08 +*color10: base0B +*color11: base0A +*color12: base0D +*color13: base0E +*color14: base0C +*color15: base07 + +! Note: colors beyond 15 might not be loaded (e.g., xterm, urxvt), +! use 'shell' template to set these if necessary +*color16: base09 +*color17: base0F +*color18: base01 +*color19: base02 +*color20: base04 +*color21: base06 diff --git a/modules/graphical/.config/libinput-gestures.conf b/modules/graphical/.config/libinput-gestures.conf new file mode 100644 index 0000000..17b8777 --- /dev/null +++ b/modules/graphical/.config/libinput-gestures.conf @@ -0,0 +1,198 @@ +# Configuration file for libinput-gestures. +# Mark Blakeney, Sep 2015 +# +# The default configuration file exists at /etc/libinput-gestures.conf +# but a user can create a personal custom configuration file at +# ~/.config/libinput-gestures.conf. +# +# Lines starting with '#' and blank lines are ignored. Currently +# "gesture" and "device" configuration keywords are supported as +# described below. The keyword can optionally be appended with a ":" (to +# maintain compatibility with original format configuration files). +# +# Each gesture line has 3 [or 4] arguments separated by whitespace: +# +# action motion [finger_count] command +# +# where action and motion is either: +# swipe up +# swipe down +# swipe left +# swipe right +# swipe left_up +# swipe left_down +# swipe right_up +# swipe right_down +# pinch in +# pinch out +# pinch clockwise +# pinch anticlockwise +# +# command is the remainder of the line and is any valid shell command + +# arguments. +# +# finger_count is a single numeric digit and is optional (and is +# typically 3 or 4). If specified then the command is executed when +# exactly that number of fingers is used in the gesture. If not +# specified then the command is executed when that gesture is executed +# with any number of fingers. Gesture lines specified with finger_count +# have priority over the same gesture specified without any +# finger_count. +# +# Typically command will be xdotool, or wmctrl. See "man xdotool" for +# the many things you can action with that tool. Note that unfortunately +# xdotool does not work with native Wayland clients. + +############################################################################### +# SWIPE GESTURES: +############################################################################### + +# Note the default is an "internal" command that uses wmctrl to switch +# workspaces and, unlike xdotool, works on both Xorg and Wayland (via +# XWayland). It also can be configured for vertical and horizontal +# switching over tabular workspaces, as per the example below. You can +# also add "-w" to the internal command to allow wrapping workspaces. + +# Move to next workspace (works for GNOME/KDE/etc on Wayland and Xorg) +#gesture swipe up _internal ws_up + +# NOTE ABOUT FINGER COUNT: +# The above command will configure this command for all fingers (i.e. 3 +# for 4) but to configure it for 3 fingers only, change it to: +# gesture swipe up 3 _internal ws_up +# Then you can configure something else for 4 fingers or leave 4 fingers +# unconfigured. You can configure an explicit finger count like this for +# all example commands in this configuration file. +# +gesture swipe up 3 ydotool key Super_L+Down +gesture swipe up 4 ydotool key Super_L+Ctrl+Right + +# Move to prev workspace (works for GNOME/KDE/etc on Wayland and Xorg) +#gesture swipe down _internal ws_down +gesture swipe down 3 ydotool key Super_L+Up +gesture swipe down 4 ydotool key Super_L+Ctrl+Left + +# Browser go forward (works only for Xorg, and Xwayland clients) +gesture swipe left 3 ydotool key ctrl+] + +# Browser go back (works only for Xorg, and Xwayland clients) +gesture swipe right 3 ydotool key ctrl+[ + +# NOTE: If you don't use "natural" scrolling direction for your touchpad +# then you may want to swap the above default left/right and up/down +# configurations. + +# Optional extended swipe gestures, e.g. for browser tab navigation: +# +# Jump to next open browser tab +#gesture swipe right_up xdotool key control+Tab +#gesture swipe right_up xdotool key control+Next +gesture swipe right_up ydotool key ctrl+PageDown +# +# Jump to previous open browser tab +#gesture swipe left_up xdotool key control+shift+Tab +gesture swipe left_up ydotool key ctrl+PageUp +# +# Close current browser tab +# gesture swipe left_down xdotool key control+w +# +# Reopen and jump to last closed browser tab +# gesture swipe right_down xdotool key control+shift+t + +# Example of 8 static workspaces, e.g. using KDE virtual-desktops, +# arranged in 2 rows of 4 columns across using swipe up/down/left/right +# to navigate in fixed planes. You can also add the "-w/--wrap" option +# to allow wrapping in any direction. You must configure your virtual +# desktops with the same column dimension. +# gesture swipe up _internal --cols 4 ws_up +# gesture swipe down _internal --cols 4 ws_down +# gesture swipe left _internal --cols 4 ws_left +# gesture swipe right _internal --cols 4 ws_right +# +# Example of 16 static workspaces, e.g. using KDE virtual-desktops, +# arranged in 4 rows of 4 columns across using swipe up/down/left/right +# to navigate in fixed planes, and also using swipe +# left_up/left_down/right_up/right_down to navigate diagonally. You can +# also add the "-w/--wrap" option to allow wrapping in any direction +# and/or diagonally. You must configure your virtual desktops with the +# same column dimension. +# gesture swipe up _internal --cols 4 ws_up +# gesture swipe down _internal --cols 4 ws_down +# gesture swipe left _internal --cols 4 ws_left +# gesture swipe right _internal --cols 4 ws_right +# gesture swipe left_up _internal --cols 4 ws_left_up +# gesture swipe left_down _internal --cols 4 ws_left_down +# gesture swipe right_up _internal --cols 4 ws_right_up +# gesture swipe right_down _internal --cols 4 ws_right_down + +# Example virtual desktop switching for Ubuntu Unity/Compiz. The +# _internal command does not work for Compiz but you can explicitly +# configure the swipe commands to work for a Compiz virtual 2 +# dimensional desktop as follows: +# gesture swipe up xdotool key ctrl+alt+Up +# gesture swipe down xdotool key ctrl+alt+Down +# gesture swipe left xdotool key ctrl+alt+Left +# gesture swipe right xdotool key ctrl+alt+Right + +# Example to change audio volume: +# Note this only works on an Xorg desktop (not Wayland). +# gesture swipe up xdotool key XF86AudioRaiseVolume +# gesture swipe down xdotool key XF86AudioLowerVolume + +############################################################################### +# PINCH GESTURES: +############################################################################### + +# GNOME SHELL open/close overview (works for GNOME on Xorg only) +gesture pinch in ydotool key ctrl+- +gesture pinch out ydotool key ctrl+shift+= + +# KDE Plasma open/close overview +# gesture pinch in xdotool key ctrl+F9 +# gesture pinch out xdotool key ctrl+F9 + +# GNOME SHELL open/close overview (works for GNOME on Wayland and Xorg) +# Note since GNOME 3.24 on Wayland this is implemented natively so no +# real point configuring for Wayland. +# gesture pinch in dbus-send --session --type=method_call --dest=org.gnome.Shell /org/gnome/Shell org.gnome.Shell.Eval string:'Main.overview.toggle();' +# gesture pinch out dbus-send --session --type=method_call --dest=org.gnome.Shell /org/gnome/Shell org.gnome.Shell.Eval string:'Main.overview.toggle();' + +# Optional extended pinch gestures: +# gesture pinch clockwise +# gesture pinch anticlockwise + +############################################################################### +# This application normally determines your touchpad device +# automatically. Some users may have multiple touchpads but by default +# we use only the first one found. However, you can choose to specify +# the explicit device name to use. Run "libinput list-devices" to work +# out the name of your device (from the "Device:" field). Then add a +# device line specifying that name, e.g: +# +# device DLL0665:01 06CB:76AD Touchpad +# +# If the device name starts with a '/' then it is instead considered as +# the explicit device path although since device paths can change +# through reboots this is best to be a symlink. E.g. instead of specifying +# /dev/input/event12, use the corresponding full path link under +# /dev/input/by-path/ or /dev/input/by-id/. +# +# You can choose to use ALL touchpad devices by setting the device name +# to "all". E.g. Do this if you have multiple touchpads which you want +# to use in parallel. This reduces performance slightly so only set this +# if you have to. +# +# device all + +############################################################################### +# You can set a minimum travel distance threshold before swipe gestures +# are actioned using the swipe_threshold configuration command. +# Specify this value in dots. The default is 0. +# E.g. set it to 100 dots with "swipe_threshold 100". +# swipe_threshold 0 + +############################################################################### +# You can set a timeout on gestures from start to end. The default is +# the value commented below. It can be any value in float secs >= 0. +# 0 = no timeout. E.g. set it to 2 secs with "timeout 2". +# timeout 1.5 diff --git a/modules/graphical/.config/mako/config b/modules/graphical/.config/mako/config new file mode 100644 index 0000000..73a16fa --- /dev/null +++ b/modules/graphical/.config/mako/config @@ -0,0 +1,22 @@ +padding=10 +margin=5,5,0 +default-timeout=5000 + +## Base16 Burn +# Author: Benjamin Bädorf +# +# You can use these variables anywhere in the mako configuration file. + +background-color=#1a181a +text-color=#e3e1e4 +border-color=#ff5f5f + +[urgency=low] +background-color=#1a181a +text-color=#e3e1e4 +border-color=#ff5f5f + +[urgency=high] +background-color=#ff5f5f +text-color=#1a181a +border-color=#1a181a diff --git a/modules/graphical/.config/swaync/config.json b/modules/graphical/.config/swaync/config.json new file mode 100644 index 0000000..06f7d02 --- /dev/null +++ b/modules/graphical/.config/swaync/config.json @@ -0,0 +1,12 @@ +{ + "positionX": "right", + "positionY": "top", + "timeout": 10, + "timeout-low": 5, + "timeout-critical": 0, + "notification-window-width": 500, + "keyboard-shortcuts": true, + "image-visibility": "always", + "transition-time": 200, + "hide-on-clear": false +} diff --git a/modules/graphical/.config/swaync/style.css b/modules/graphical/.config/swaync/style.css new file mode 100644 index 0000000..2e33e7e --- /dev/null +++ b/modules/graphical/.config/swaync/style.css @@ -0,0 +1,149 @@ +/* + * vim: ft=less + */ + +@define-color border-color rgb(7, 7, 7); +@define-color bg rgb(58, 58, 58); +@define-color bg-hover rgb(68, 68, 68); +@define-color bg-focus rgba(68, 68, 68, 0.6); +@define-color bg-selected rgb(0, 128, 255); + +.notification-row { + outline: none; +} +.notification-row:focus, +.notification-row:hover { + background: @bg-focus; +} + +.notification { + border-radius: 10px; + margin: 6px 12px; + box-shadow: 0px 2px 4px 2px rgba(0, 0, 0, 0.3); + padding: 0; +} + +.notification-content { + background: transparent; + padding: 6px; + border-radius: 10px; +} + +.close-button { + background: black; + color: white; + text-shadow: none; + padding: 0 2px; + box-shadow: 0px 2px 4px 2px rgba(0, 0, 0, 0.3); + border-radius: 100%; +} +.close-button:hover { + background: rgb(30, 30, 30); + transition: all 0.15s ease-in-out; +} + +.notification-default-action, +.notification-action { + padding: 4px; + margin: 0; + box-shadow: none; + background: @bg; + border: 1px solid @border-color; +} + +.notification-default-action:hover, +.notification-action:hover { + background: @bg-hover; +} + +.notification-default-action { + border-radius: 10px; +} + +/* When alternative actions are visible */ +.notification-default-action:not(:only-child) { + border-bottom-left-radius: 0px; + border-bottom-right-radius: 0px; +} + +.notification-action { + border-radius: 0px; + border-top: none; + border-right: none; +} + +/* add bottom border radius to eliminate clipping */ +.notification-action:first-child { + border-bottom-left-radius: 10px; +} +.notification-action:last-child { + border-bottom-right-radius: 10px; + border-right: 1px solid @border-color; +} + +.image { +} + +.body-image { + margin-top: 6px; + background-color: white; + border-radius: 10px; +} + +.summary { + color: white; + text-shadow: none; +} + +.time { + color: white; + text-shadow: none; +} + +.body { + background: transparent; + color: white; + text-shadow: none; +} + +.top-action-title { + color: white; + text-shadow: none; +} + +.control-center-clear-all { + color: white; + text-shadow: none; + background: @bg; + border: 1px solid @border-color; + box-shadow: none; + border-radius: 10px; +} +.control-center-clear-all:hover { + background: @bg-hover; +} + +.control-center-dnd { + border-radius: 10px; + background: @bg; + border: 1px solid @border-color; + box-shadow: none; +} + +.control-center-dnd:checked { + background: @bg-selected; +} +.control-center-dnd slider { + background: @bg-hover; +} + +.control-center { + background: rgba(0, 0, 0, 0.7); +} +.control-center-list { + background: transparent; +} + +.floating-notifications { + background: transparent; +} diff --git a/modules/graphical/.config/user-dirs.dirs b/modules/graphical/.config/user-dirs.dirs new file mode 100644 index 0000000..a1bf8b4 --- /dev/null +++ b/modules/graphical/.config/user-dirs.dirs @@ -0,0 +1,15 @@ +# This file is written by xdg-user-dirs-update +# If you want to change or add directories, just edit the line you're +# interested in. All local changes will be retained on the next run. +# Format is XDG_xxx_DIR="$HOME/yyy", where yyy is a shell-escaped +# homedir-relative path, or XDG_xxx_DIR="/yyy", where /yyy is an +# absolute path. No other format is supported. + +XDG_DESKTOP_DIR="$HOME/" +XDG_DOWNLOAD_DIR="$HOME/Downloads" +XDG_TEMPLATES_DIR="$HOME/Templates" +XDG_PUBLICSHARE_DIR="$HOME/Public" +XDG_DOCUMENTS_DIR="$HOME/" +XDG_MUSIC_DIR="$HOME/" +XDG_PICTURES_DIR="$HOME/" +XDG_VIDEOS_DIR="$HOME/" diff --git a/modules/graphical/.config/user-dirs.locale b/modules/graphical/.config/user-dirs.locale new file mode 100644 index 0000000..7741b83 --- /dev/null +++ b/modules/graphical/.config/user-dirs.locale @@ -0,0 +1 @@ +en_US diff --git a/modules/graphical/.config/waybar/colorscheme.css b/modules/graphical/.config/waybar/colorscheme.css new file mode 100644 index 0000000..9cb06b3 --- /dev/null +++ b/modules/graphical/.config/waybar/colorscheme.css @@ -0,0 +1,23 @@ +/* +* +* Base16 Burn +* Author: Benjamin Bädorf +* +*/ + +@define-color base00 #1a181a; +@define-color base01 #2d2a2e; +@define-color base02 #303030; +@define-color base03 #949494; +@define-color base04 #d3d1d4; +@define-color base05 #e3e1e4; +@define-color base06 #303030; +@define-color base07 #ff5f5f; +@define-color base08 #f85e84; +@define-color base09 #df5923; +@define-color base0A #e5c463; +@define-color base0B #9ecd6f; +@define-color base0C #ef9062; +@define-color base0D #7accd7; +@define-color base0E #ab9df2; +@define-color base0F #d70000; diff --git a/modules/graphical/.config/waybar/config b/modules/graphical/.config/waybar/config new file mode 100644 index 0000000..7eac8d9 --- /dev/null +++ b/modules/graphical/.config/waybar/config @@ -0,0 +1,148 @@ +{ + "layer": "top", // Waybar at top layer + // "position": "bottom", // Waybar position (top|bottom|left|right) + + "height": 26, // Waybar height + "modules-left": ["sway/workspaces", "sway/mode"], + "modules-center": ["network"], + "modules-right": [ + "sway/language", + "backlight", + "custom/notification", + "pulseaudio", + "idle_inhibitor", + "battery", + "clock", + "tray" + ], + "sway/workspaces": { + "disable-scroll": true + }, + "sway/mode": { + "tooltip": false, + "format": "{}" + }, + "sway/window": { + "tooltip": false, + "max-length": 96 + }, + "sway/language": { + "format": "{}", + "max-length": 50 + }, + "tray": { + "icon-size": 21, + "spacing": 10 + }, + "clock": { + "tooltip-format": "{calendar}", + "format": "{:%H:%M} ", + "format-alt": "{:%a %d. %h %H:%M} ", + //"on-scroll": { + // "calendar": 1 + //} + "smooth-scrolling-threshold": 1.0, + "calendar": { + "mode-mon-col" : 3, + "on-scroll": -1, + "on-click-right": "mode", + "format": { + "months": "{}", + "days": "{}", + "weekdays": "{}", + "today": "{}" + }, + }, + "actions": { + "on-click-right": "mode", + "on-click-forward": "tz_up", + "on-click-backward": "tz_down", + "on-scroll-up": "shift_up", + "on-scroll-down": "shift_down" + } + }, + "backlight": { + "device": "acpi_video0", + "format": " {percent}% {icon}", + "format-icons": ["", ""] + }, + "cpu": { + "format": "{}% " + }, + "memory": { + "format": "{}% " + }, + "idle_inhibitor": { + "format": "{icon} ", + "format-icons": { + "activated": "", + "deactivated": "" + } + }, + "battery": { + "tooltip": false, + "states": { + "critical": 25 + }, + //"full-at": 84, + "format": "{icon} {capacity}%", + "format-full": "{icon}", + "format-icons": ["", "", "", "", ""], + }, + "network": { + "interval": 3, + "tooltip": true, + //"interface": "wlp4s0", // (Optional) To force the use of this interface   \uF2E7, + "format-wifi": " \uf062 {bandwidthUpBits} | \uf063 {bandwidthDownBits}", + "format-ethernet": " \uf062 {bandwidthUpBits} | \uf063 {bandwidthDownBits}", + "format-disconnected": "", + "tooltip-format-wifi": "{essid} ({signalStrength}%)  {ipaddr}", + "tooltip-format-ethernet": "{ifname}  {ipaddr}" + }, + //\ue04f{volume}% + "pulseaudio": { + "tooltip": false, + "format": "{volume}% {icon}", + "format-bluetooth": "{volume}% {icon}", + "format-muted": "", + "on-click": "pavucontrol", + "format-alt": "{volume}% {icon}", + "format-icons": { + "headphones": "", + "handsfree": "", + "headset": "", + "phone": "", + "portable": "", + "car": "", + "default": ["","", ""] + } + }, + "mpd": { + "format": "{artist} - {title} [{elapsedTime:%M:%S} / {totalTime:%M:%S}]", + "format-disconnected": "", + "format-stopped": "", + "interval": 1, + "state-icons": { + "paused": "", + "playing": "" + }, + "tooltip-format": "MPD (connected)", + "tooltip-format-disconnected": "MPD (disconnected)" + }, + "custom/notification": { + "tooltip": false, + "format": " {icon}", + "format-icons": { + "notification": "", + "none": "", + "dnd-notification": "", + "dnd-none": "" + }, + "return-type": "json", + "exec-if": "which swaync-client", + "exec": "swaync-client -swb", + "on-click": "swaync-client -t -sw", + "on-click-right": "swaync-client -d -sw", + "escape": true + }, +} diff --git a/modules/graphical/.config/waybar/style.css b/modules/graphical/.config/waybar/style.css new file mode 100644 index 0000000..238417e --- /dev/null +++ b/modules/graphical/.config/waybar/style.css @@ -0,0 +1,80 @@ +@import "./colorscheme.css"; + +window#waybar { + font-family: Hack, FontAwesome; + font-weight: 500; + font-size: 14px; + /*background: rgba(11, 12, 13, 0.90);*/ + background-color: rgba(0, 0, 0, 0); + border-bottom: 1px solid rgba(0, 0, 2, 0.53); + color: @base04; +} + +window#waybar.hidden { + opacity: 0.2; +} + +#workspaces button { + font-size: 14px; + box-shadow: none; + text-shadow: none; + padding: 0px 3px 0px 3px; + color: @base04; +} + +#workspaces button.focused { + color: #f85e84; + color: @base07; + /* margin: 2px 0px 2px 0px; */ +} + +#workspaces button:hover { + background: rgba(255, 255, 255, 0.00); + /* margin: 2px 0px 2px 0px; */ +} + +#clock, #backlight, #battery, #cpu, #memory, #network, #pulseaudio, #custom-spotify, #tray, #mode { + font-size: 14px; + margin: 0px 10px 0px 5px; +} + +#pulseaudio { + /* border-top: 1px solid transparent; */ + font-size: 12px; + margin-left: 15px; +} + +#battery { + font-size: 12px; +} + +#battery.critical { + color: @base07; +} + +#battery.charging { + color: @base0B; +} + +#battery.full { + margin: 0px 0px 0px 0px; +} + +#network { + border-top: 1px solid transparent; + color: rgba(255,255,255,0.3); +} + +#network.disconnected { + margin: 0px 0px 0px 0px; + color: rgba(75, 81, 98, 0); +} + +#pulseaudio.muted { + margin: 0px 0px 0px 0px; + color: rgba(75, 81, 98, 0); +} + +#custom-notification { + font-family: "NotoSansMono Nerd Font"; +} diff --git a/modules/graphical/.config/xmodmap b/modules/graphical/.config/xmodmap new file mode 100644 index 0000000..3eb325a --- /dev/null +++ b/modules/graphical/.config/xmodmap @@ -0,0 +1,8 @@ +! Swap Caps_Lock and Control_L +! +remove Lock = Caps_Lock +remove Control = Control_L +!keysym Control_L = Caps_Lock +keysym Caps_Lock = Control_L +add Lock = Caps_Lock +add Control = Control_L diff --git a/modules/graphical/.config/xsettingsd/xsettingsd.conf b/modules/graphical/.config/xsettingsd/xsettingsd.conf new file mode 100644 index 0000000..8ea990f --- /dev/null +++ b/modules/graphical/.config/xsettingsd/xsettingsd.conf @@ -0,0 +1,18 @@ +Gtk/ButtonImages 1 +Gtk/CanChangeAccels 1 +Gtk/CursorThemeName "default" +Gtk/CursorThemeSize 0 +Gtk/EnableEventSounds 0 +Gtk/EnableInputFeedbackSounds 0 +Gtk/FontName "Lato" +Gtk/ThemeName "Matcha-dark-aliz" +Gtk/IconThemeName "Papirus-Adapta-Nokto-Maia" +Gtk/MenuBarAccel "F10" +Gtk/MenuImages 1 +Gtk/ToolbarIconSize 3 +Gtk/ToolbarStyle "icons" +Xft/Antialias 1 +Xft/DPI 102400 +Xft/Hinting 1 +Xft/HintStyle "hintslight" +Xft/RGBA "rgb" diff --git a/modules/graphical/.xinitrc b/modules/graphical/.xinitrc new file mode 100644 index 0000000..d961f66 --- /dev/null +++ b/modules/graphical/.xinitrc @@ -0,0 +1,75 @@ +#!/bin/sh +# +# ~/.xinitrc +# +# Executed by startx (run your window manager from here) + +userresources=$HOME/.Xresources +usermodmap=$HOME/.config/xmodmap +sysresources=/etc/X11/xinit/.Xresources +sysmodmap=/etc/X11/xinit/.Xmodmap + +DEFAULT_SESSION='i3 --shmlog-size 0' + +xset -b + +if [ -d $HOME/.fonts ]; then + xset +fp $HOME/.fonts + xset fp rehash +fi + +# merge in defaults and keymaps + +if [ -f $sysresources ]; then + xrdb -merge $sysresources +fi + +if [ -f $sysmodmap ]; then + xmodmap $sysmodmap +fi + +if [ -f "$userresources" ]; then + xrdb -merge "$userresources" +fi + +if [ -f "$usermodmap" ]; then + xmodmap "$usermodmap" +fi + +# start some nice programs + +if [ -d /etc/X11/xinit/xinitrc.d ] ; then + for f in /etc/X11/xinit/xinitrc.d/?*.sh ; do + [ -x "$f" ] && . "$f" + done + unset f +fi + +get_session(){ + local dbus_args=(--sh-syntax --exit-with-session) + case $1 in + awesome) dbus_args+=(awesome) ;; + bspwm) dbus_args+=(bspwm-session) ;; + budgie) dbus_args+=(budgie-desktop) ;; + cinnamon) dbus_args+=(cinnamon-session) ;; + deepin) dbus_args+=(startdde) ;; + enlightenment) dbus_args+=(enlightenment_start) ;; + fluxbox) dbus_args+=(startfluxbox) ;; + gnome) dbus_args+=(gnome-session) ;; + i3|i3wm) dbus_args+=(i3 --shmlog-size 0) ;; + jwm) dbus_args+=(jwm) ;; + kde) dbus_args+=(startkde) ;; + lxde) dbus_args+=(startlxde) ;; + lxqt) dbus_args+=(lxqt-session) ;; + mate) dbus_args+=(mate-session) ;; + xfce) dbus_args+=(xfce4-session) ;; + openbox) dbus_args+=(openbox-session) ;; + *) dbus_args+=($DEFAULT_SESSION) ;; + esac + + echo "dbus-launch ${dbus_args[*]}" +} + +exec $(get_session) +xset r rate 660 25 + diff --git a/modules/graphical/alacritty.nix b/modules/graphical/alacritty.nix new file mode 100644 index 0000000..fe5dd81 --- /dev/null +++ b/modules/graphical/alacritty.nix @@ -0,0 +1,271 @@ +{ + env = { + TERM = "xterm-256color"; + }; + + window = { + # Window dimensions in character columns and lines + # Falls back to size specified by window manager if set to 0x0. + # (changes require restart) + dimensions = { + columns = 80; + lines = 24; + }; + + padding = { + x = 0; + y = 0; + }; + + decorations = "full"; + }; + + scrolling = { + # How many lines of scrollback to keep, + # "0" will disable scrolling. + history = 100000; + + # Number of lines the viewport will move for every line + # scrolled when scrollback is enabled (history > 0). + multiplier = 3; + }; + + # When true, bold text is drawn using the bright variant of colors. + draw_bold_text_with_bright_colors = true; + + font = { + # The normal (roman) font face to use. + normal = { + family = "Hack"; # should be "Menlo" or something on macOS. + # Style can be specified to pick a specific face. + style = "Regular"; + }; + + # The bold font face + bold = { + family = "Hack"; # should be "Menlo" or something on macOS. + # Style can be specified to pick a specific face. + style = "Bold"; + }; + + # The italic font face + italic = { + family = "Hack"; # should be "Menlo" or something on macOS. + # Style can be specified to pick a specific face. + style = "Italic"; + }; + + size = 12.0; + + offset = { + x = 0; + y = 0; + }; + + glyph_offset = { + x = 0; + y = 0; + }; + }; + + key_bindings = [ + { + key = "V"; + mods = "Control|Super"; + action = "Paste"; + } + { + key = "C"; + mods = "Control|Super"; + action = "Copy"; + } + { + key = "V"; + mods = "Control|Alt"; + action = "Paste"; + } + { + key = "C"; + mods = "Control|Alt"; + action = "Copy"; + } + { + key = "Paste"; + action = "Paste"; + } + { + key = "Copy"; + action = "Copy"; + } + { + key = "Q"; + mods = "Command"; + action = "Quit"; + } + { + key = "W"; + mods = "Command"; + action = "Quit"; + } + { + key = "Insert"; + mods = "Shift"; + action = "PasteSelection"; + } + { + key = "Key0"; + mods = "Control"; + action = "ResetFontSize"; + } + { + key = "Equals"; + mods = "Control"; + action = "IncreaseFontSize"; + } + { + key = "PageUp"; + mods = "Shift"; + action = "ScrollPageUp"; + } + { + key = "PageDown"; + mods = "Shift"; + action = "ScrollPageDown"; + } + { + key = "Minus"; + mods = "Control"; + action = "DecreaseFontSize"; + } + { + key = "H"; + mode = "Vi|~Search"; + action = "ScrollToBottom"; + } + { + key = "H"; + mode = "Vi|~Search"; + action = "ToggleViMode"; + } + { + key = "I"; + mode = "Vi|~Search"; + action = "Up"; + } + { + key = "K"; + mode = "Vi|~Search"; + action = "Down"; + } + { + key = "J"; + mode = "Vi|~Search"; + action = "Left"; + } + { + key = "L"; + mode = "Vi|~Search"; + action = "Right"; + } + ]; + + # Base16 Burn 256 - alacritty color config + # Benjamin Bädorf + colors = { + # Default colors + primary = { + background = "0x1a181a"; + foreground = "0xe3e1e4"; + }; + + # Cursor colors + # + # Colors which should be used to draw the terminal cursor. + # + # Allowed values are CellForeground/CellBackground, which reference the + # affected cell, or hexadecimal colors like #ff00ff. + cursor = { + text = "CellBackground"; + cursor = "CellForeground"; + }; + + # Colors used for the search bar and match highlighting. + search = { + # Allowed values are CellForeground/CellBackground, which reference the + # affected cell, or hexadecimal colors like #ff00ff. + matches = { + foreground = "0xe5c463"; + background = "0x1a181a"; + }; + focused_match = { + foreground = "CellBackground"; + background = "CellForeground"; + }; + #bar = + # background = "#c5c8c6"; + # foreground = "#1d1f21"; + }; + + # Selection colors + # + # Colors which should be used to draw the selection area. + # + # Allowed values are CellForeground/CellBackground, which reference the + # affected cell, or hexadecimal colors like #ff00ff. + selection = { + text = "0x1a181a"; + background = "0xf85e84"; + }; + + # Normal colors + normal = { + black = "0x1a181a"; + red = "0xf85e84"; + green = "0x9ecd6f"; + yellow = "0xe5c463"; + blue = "0x7accd7"; + magenta = "0xab9df2"; + cyan = "0xef9062"; + white = "0xe3e1e4"; + }; + + # Bright colors + bright = { + black = "0x949494"; + red = "0xf85e84"; + green = "0x9ecd6f"; + yellow = "0xe5c463"; + blue = "0x7accd7"; + magenta = "0xab9df2"; + cyan = "0xef9062"; + white = "0xff5f5f"; + }; + + indexed_colors = [ + { + index = 16; + color = "0xdf5923"; + } + { + index = 17; + color = "0xd70000"; + } + { + index = 18; + color = "0x2d2a2e"; + } + { + index = 19; + color = "0x303030"; + } + { + index = 20; + color = "0xd3d1d4"; + } + { + index = 21; + color = "0x303030"; + } + ]; + }; +} diff --git a/modules/graphical/assets/pub-solar.jpg b/modules/graphical/assets/pub-solar.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ec0624dcb6487cbef7a6b88bd84396824e5d02a8 GIT binary patch literal 525702 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%0AJ1;a772_lOZogC8`KK{WW&4|zDj&^rxC2L7 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%0DWS=H~zXNEo2ZblyJ7#(1bhOk{Pn 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≤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 literal 0 HcmV?d00001 diff --git a/modules/graphical/assets/wallpaper.jpg b/modules/graphical/assets/wallpaper.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bcbb7eed8dd1b6fb99ed375afcd66cd56ce0de36 GIT binary patch literal 171929 zcmb@vd0dlM*EM`4fpC+Xp-OB8g=(!PY8^pDkQ$-YI>ji8igiQV5oesWI8^EkA|fh^;)IGL4z1I-*FH(0@AJIB?~m`(Um#>W*SXH#d+oK?KG(;~ zAIqdqx_9Z;MUu%RNk;#rkGJI7Zh?Wr41Ifd>DKdGenMVXqJQ#FBx&NL$fH(;eY;(qsg0ifr}n2`dIkgrt-WR6*sI+)-}W6D+OPkd z&qmj6GHOTgyttzmyr+H9cEArymhGYscdv0&<}*OwBjazUrvqw{wb5TnnS%bwl`>mN zCRfyI6T7`(+s-4V9I>hpKf!-M7(CkFaIn#8>dF%<_6Q)VB&H+YAFVndg}SD!X+{7v(!8CAibu zi%tcMQzkC^dg(!jYwMe&`Cx>`aprMIG1HtKwyEq4PfttU_Jy&X?+onStsr2oq-Z~7 z=O<3(V;bNiXaw`hX=HWw4Lqyp@pXsj$Y$%JJTC=A>t+PIT!>WF^{H6m-+a0q9k<(o zgcY$X4Dyk0R=oUW6}@r(`SiR=B_*>zzxsOh?q}iZKB3c!-@RIVV{4@_XeLyk0W~ht##l=iRT% zF63R&G{y}B#)G)LojPW5gf5$AVc-ck$WXU(VI zXK>myG%JP<1J6ph<%&aWvo&Vw1-w5X=50PvC5LVvcc#6h ztP|=V7VJbz@!7kBv+V9&q_sl-475s3xI^m&>)3oyUXrae<chhn${voXnhWW`PG zH`bSwkAppRzLKMPWyG!^bE0TNHxs#Pqe=0ZW#T0Fz++!Yd+l=zXi^>JQImMC7Bz_t zjIb&1D$Yb>iH=!D&nJgVjzhkh)qJ|EEXX|8`UMAEAGVlA zOKe49vyalxPC0ORIj>T$(Rrg2-deKzp4>;Eu_sNPeF=sv!FMSBZ4iMy^scY!(+mAG z9NyB}?Hj)+g*?bf^RRezwzZhW*s;gHK1PSE*>!Wx7>rN0`Y)Fy+EGPI>*qWuzA`gH zv88-WL%-IYmY+Ah+ly6(#V^*qj{dUVv(Ht*+uF5zd@dxn_7yV2INL~C2;ba%U`)oc z#J`%S5T0KWHgBwcf{=yQ>}4)XlKr3L!c`8B-rTu{@DNmQW&dlm7Qc%(N~M;=v6at> z5bqxY1Cng{Cw+7U&Yg1u1APQPB)%&tBb+`7t6dB0sdmlPOC{HL;6K4n+ws)?rJl8Q z_9A6VoW_3UH#$moUXxD5oHC{-H(DQFPP5l0%k`n}eh-_+8?P^_S}N5;3sT((~KiO~;A@*x8`avGbJxU@Y*5 z(F-9LNh(PFFr?cFBUy++vcFij_)v$jD#fTW1JAzR8}HF7+W)#oa&9fYIh>vN0O2iO)Z{Q}ZGgJStyq1+A zJ2Fxag&Y|6Qv+J|BXBzAfOEJFJHSGyc~is& zGAyOp#^uo@-fV{MMiHfN3mpJ(+**I34Ez3!5 zp9_!G0qC(SedI*_ok0}{dSAkaZF9!CiNhSZl4VFstzqh>UyDyaovnq9#S&Qh*>#Bn z#Te5l@`-Gooql&_b5LMad})|K3ta#$=i${sLNd{sl*c2Go1w-GpI1_v51EC_LVAk+ zd5t}=M(4%Y*Nd{vYvclGP2#v$Fx)wVrR>3r!6TPmPk&;ixRO24r`X&wlChc3vTLjk z&#R=T0&3H%Wr2l5K1$tRvJY|Dji=#falCGlBAVvIUBkwtXl*uPH4TkEM^h7}D*%6- za1gMCCd&w(cs0h#u~iLjsTSJFOR2TH1r!l*wBz| zJ{(%rpR_{`lQBtM<9q*y^AxGimKxsKV)*!t@6MxH=|e`2W#eT=K(TpCJARZ-%tmB# zZZ_kiwCDq#K7Z!Ui>gZ4FYKCTb%Dvegf$osrp&yoSItO1{8KzxQ=hw2|Nh60Mox|+ ztRKas@5tzQGV2T?Y)5~1j}a^0a-w))-mi-w#tYp(&jNO3MfD0&fA<|d?3ryax%QQG z23!-()(IyL#Av`EU@D5w=u0_y!WypIcIp*RLpypAXSY~V1L&9^Q3#5So8EQk1qQCI zw?<99|Ml9 zv2UIdcH+Y~U1lrcID#J{Nie7-`x7FQmDCzqw`y`iBHP%))iwdn_rj zfSnV_I%GOMJ(4;1Q9dKn8L%X9*c#wvwb#Gn3g+62PWo{A&F5P=zZnkJY|xm< zv^3A>%$2$ zkD$>QjuYp7uoCkvbMfkPYi4hw;Vy2U^7Th4R6}m3`|Ge4!^3+GtyR2hBa+If6n50) z$5pm^vl*lz(dAjCFYf8G!?IKzFe*57x}^m+*&J2yXX^*QU$efzg7aiX;d_xebCw3% zBtz$gZ=#WFYhw+Jg9oHpad0);zhlKw-!60Mbuq|8YNSORo|rEv>q(P>*z0f%4s=~2 z`JW?==q+sUh({XybnOe|L}4oGlG_3BS)?5Xw$n6A z(gA=)AFbhdd30VG%vDQ6toiY=0=H6{pTci*G{RsUhfuOj363SVo>#_5urJma$B}vi z4s;mrFee6Q+sUX^@xk1$4^INmYmH-cV74{Ck1fP`_@=zVTkRHKZLQgqx9G>8ZtTdT zC4J#s%LR+S`}x&DI)SQ<#AE$N2UZ7p1)UNkbK77Y1ty6D4pJ|V9C|5iMoEj*41LT& zSzuZ~9SM293P$11-VWx)o-)^xI=IY*jm9Ce2Skll6sGt8D1GA5?N7;24;g(c0sR=O zz{*v0%p)FY;DseT-+*(eLoiUgUSy!0oR6wlI{UcN6487s5`tSCFUMk{fEHlHG&dW>48}LNdx9ht8C=C3wee-z9nVjm;lQywmBWX^5>;rT`F_?qTkNJM)N8cGzq6S zE^t>CBV$WIK7(AQu{}}4%7xLorg)hnDAnSfU-F41=yZXIm2b!>M!84k@$ zlXK=jll{Zk{moKkF8N#fXZ>MI?EXetIr4dBiV_0FaVm%AMBy4c2)a{tTNoGKL;nnd zf&wNp6QjbOw2~!BprnUWbvvD;rT8NyYYb!uT8*Cm~~* zb<#gcX+9f4!FG4qDW5Y z<5ALG>kS(d;N!{4a(;hL*9EH5nB@ycuxrB6?4i%6v&4;`M%uiKc(P`I{ zXSxlHsL5>8bZVE4ASPULLbv<0+FOqovhGg~E}Cg@bcw413vV5COg4MhzW5Hk>0e6> zkZ)e4WUELo8n~QE3dBsy4ep=@OW{16S?t?oX7*U-Cv3*9XV!-XR+|I2<_J4pM&O{~ zxAnHC?#NHcAv#FI%QlqO+mK7AbI-zV z$c}WrjGW*US6IA1V;N%@p{BC_$ogV`!O5g(*)V73&Sl&38#5zfva7#)(M4@vn{)Ij z$z+Z7W*_?~O&-x4M%5NM$WF@ZqPEa!kb{Ng+>SZ3vzZh^7O@MAVZQ(}onuyne@5Mh zZaZo1JHjL^_)B(Tb7q3S|FYA8s_m&eH{npG<4{g!HEY;)Smf^fw#dEiDB4?BLKFH3 zkOpZwi;*?-qd(abRA*L#i{>|T%yRi--ucU&))+aG;D>n`(>-^wE{u{|E9tGo7OihR zhYN{JUX#;Xx;aGcWzjx?(7PlaWVpTK89DA zqZR+zI$FaEyNTUQIX2Xpk3n_K9DM56_#OFtvu6E$P&2I!WGM5Oj_}uX8IjBKQeT4$p*2F39 z@yZ1iOhL$0TF6ET z{;{(z8%6d?(G68kxiMMcJ@fBrDuQW1PB01Cg(>v5{{z@QUr2V_e6@U!d8!Qek&1Fevy@|8fLK-LC8~ifcFrQ7awM?&8)}w| zP9Opa09)<(!5o(&t!$1mFGhP}bJ*qwj1M~k>?(%1x&LD%a{-yi*mCpA!NJ+9e@`jR z=ZHzDBhzRZnx0JoDDC1ZFTa;+_Jm{CZWuf9c4f!Ivp=7J0Qdawce4^{rJS+krVhKp zqaTPUW%kqye1GUN|0k1^nO-@0I{a)vyxt0AIK`S*j@i@NS+QzT0y{TB54K#Glf68) zn3z!J{_2Kjh76vrufh?5CNcaAfb!vb^0@FFxU+*<%+-jbmW)sFsX6*~cOO7>w?i^5 zkhtl2`ses8A7)^r$BV);rZcnVxUT-D3xnE??(H9w6Lt7qKnx;w82OWx@FP4=X}{3v zs+yge_xSU(7stZ}F=$4pm9v{K>ieN>e7oM=1l}UvOr6Ro-m)+oZ&2!a)^`qI~)>-<+il4omqK#V)t9W6^VbE@ah-s}CM zT}#A_W!V)UB064=eEXimrSefY4-< zjDajACdXXBBLGg_Ub(;5>tSF?vHTWA$l&T(P`?oCjT~m7cuHR!*P6vQ!%Ef8Hyl{vVWlk`d zOz4|EV`F$0Q*Aond3O_>-s{}9U+tlRYc(vB}56kU1ytk#Z^vur5R zHhH$A(fW?h!`2)G`1bfMv`w4#`g0LL(H?MKjpccg-6zA@ zE*aJ8@&Tf8UVJ5$GbUZFtV8%iXSz*BJFQDq*!tLS!S&jhD6Wzzn12YhPQD}p7V|gs zj4e^8kNLA?I$39*WKl=Z8Vo7sq?IB(S@3o`+1haB?43{E>%t`l14P>-P_Cpqljak4 z=f#`1GW;;Wmd^U=SR`Ux1P1z;) zxGba&w)*lhUji5?&G~o$S7De#jbJ5HHGBql!V#JcBB(l@9*ls^{M{CC&NUs9t4*0& zc@ZT(h8m8UrCI(BfnQ=PJ*V}#^kmkeF_%V;@qV;=&xY+os62k~McA6Zdp~kLV5!C@ z(>(WXb~HvmC%xy!IQQ|{6Sf`UO4&~O(wMs(pLUYNab*8jKl-Co$26_l1Ms7UB9#0& z2NL=4$^q|m(VV!3XN8o^@F@qNa=X8v@7YNT4N#yTaPH00y65#zHzc_)c@`2=)$NJn zeF_%8(Mk42Xv-l3nS1))vsVf8UyVWoGc%kI zTT9_Mu}p>4C?cyk8oRI-pawuzAX0NyDl8v|O0yFXOGAP#%4o54`x1CH1V~X>01qZC zl;5pKq;)ttzkZFkpst-3*opjA$=b#}+U@li)@kvsEpV}(JcZ2b=2>%n7K?N`8~RV+ z-_v1f%oM@gWP~<@aC^8Z*=m-!@lhLuSB+LWN|1h2gKiQBerUtQal}Frv6DHquU-**`&2>*JHqUB0UH_8Px4w6lzddkQZ3)WrJ^H=) zD7n5zh?)6mkc-QnQ8x}WtLptG`-369b>gpu-^Q&ur2=se%Jj%wTGv4!7EPQeu3)Fa zq8R6peddskVKW8|_6xtYVp_LJ8bjOA9jVQG4_)A2HjXlZIEj83y}r$CvfL#BOPAIn zSN@TZIeRWYpHClQxAOG8`@rxWDG?7ON-A>&R<4N6l$so%hd3C*9K_UBuT={&wMJ#u zNa+w8S9N+f>kRvGyyz|{+4=>+IXj*YrYx}@nR73zBt&7?Yt#0YoRN8PMx3_#tL1A3 z1r=$pD9=&oNCEb=KnMJ`|DMW0IXeN$a8XcJ zIBs)~1t-p}Dt@P9x!TIVxn@haMS(gm#;cr5{sf7s=ZybGa7vKC5+;W~EgzZ^V3hfB zOwbx$xoqU1o|dmAtCq*vlu0HYl(0yojTca5^$N8m6PDj$)RW{kwoeYrAjkI`~-;Y#EXb#}UbV5S!KB zJkXTyB(kFV5vDyNU%ZOr3JC`g$6Cz>W#_HKK-?%}mLc|mtY(&+yaP)o%t*F@7v;$+xBI{J z?bTADp?82GK*Ux%RSyeqSfC5fe{xZQ6dE5Y6{OwR$oga0x3KLLA^O_isAawr=f)hl zm6OQxn=p+qQ;fqQ60T07hd2eY)L(1Vb65u?xMLQ6y4M*$xRt^kFkXhtzpSUl$c;;Z zW;EcnB+k+WJ%P}kc`v2odlL#en4efqj8Rf{`QxS@)@v=5 z9CNg#rz{cyyOQWP=^uK&cy08+5C3|;Byo@;Fa2>#zK%nH$w=8Y#bTnZt+f^`B0F<& z$NX(-NoY5<9!KXhk;^`924&1Xl1d)S4ked8@-+tG7NpKln!%eluy4nCtZ8(&s-H!H zCtNZMNlh|8P*|hJ|8s4>^5WzEslS@iCr(QD=~ZxU`e@hNXEd8GRUB~oZT6w}#=^6y zv+s1;=Il)xl_ei?qqLHHpF^${E$Z+1C`JExG>eq<;jTu(B3mV;Shizqp|(KsKOdH5^Y6Z|_;%O;3u%6Shs3Ag6Hlk9k2IvPb~iA9wG z@dz=NYNRd4#|=U}1(i%J0MBBIl^3ERIGc}X*_TeeXI)t+E#9*zu3TY}9(h8pjn)g= z7aW5S=#NCea|-5t@wXT%IVxR2QuCbXv;8Lr`B4~T1zG=fZ7P2p;6ioYotMt7C>nWf z0CZ)nu<t_2N*thoR`8$l>mocR6Pz@8@QEV4KMZ5~W(Lpxdo! zL#&UPD@&hJ^=2~b#*d-df}OFJ>QWpB@CHDB-6EO^;<1xI*x5w-7A&N1DU zu#!AF1@^7-Fe4xvrjgUw_i^F?3#9x9%0^^SozoryJCSv`w0?9Cs{kJdAnZtI6y*^ zwJ^qM3H-m8rdpZP6$Y#qI#vYtdIj@dRyu2Tl?-Wr^U~zP1G^tn?LVm3(rX#lXNUhq zvl~BDAmt;p);eb1`{4OD>9gZ`o4>EP_H99}iqAAcsnvs)JWKu7vKJYCR>!57wMJAu zY?b!8=6WA5qufj^Vm$yxK$&3iorsHIT8=OS*M26MImijXWnVtNe^tKvRs;Vo zZ_@8Y@zw!jpX64d*w1NMHd}GZ0T`7i{Bt(Li8phH))F6Ela&qhg9m`aSA9k7KSKH# zEIP2CEH(#tun>jn`ykF?=kZX5BFm`_vA4p#*0^pP@|vE-uUyP#umy;W;Hb}I;}nbC z2-2`LJaKcb#RpittqBgf?YO*&^@E%;DNSnuNOYtFXY;M#?|mK~`|yj}Kl+>Q%f?5z zvJ-M-kntJT3RA_xH4T4A$HE!WQ-*MyogBLq!;UwcVN(l~Gpy*SEqi7`A&%x@kA}z9 zy84cF?!EA-TeC~MhuUDpI?)Z3AA6)&QGO4jX`e2b1uDRY_U=7;M}A{6b*-Lpj`Q=# z52g=#=JI4Z`7}5qbL$@6BRnq{2fA+-2wD{JY7&!}=wawe2&33MU^b9Bb-}6R8YG90 zQedgNkMG!wFzFgVW6L_Vo0O zth|R=>$vjX6Hf0QR&(xv{La3J`^v`xU3EKRnPlJ4{=Y;({zsx9&&3(X2nm>@Fh$~k zSQYF`h;CZIimw>YI4Y^1mY!Mt?-V4#VHun z2x^nS1~=l3!t1I=_|HTNt}wvd2>(M=a!{ zrw2cbYB%ciw87bLA8bzBJb^ky=WPKr)W0k?gA$Y}>KA;J${!Dh3dGK%Gds^(<^1ccAeQX5A zSUczBjF&0?!6`;vapMOo#{YgH*<~#Iq^uV3i_V|lZuox0yC2!f=p>s5giL^i*pDc> zP_dp}hVxf@W_8PV)=@r1|L6yG(QH(7rJfxxbf8ISe^cAm=(yq6**suIJ_WQE8aK@n zZdunWuixZCcVkDMh6OsXIqu5%9(fl#m&H2xdVzLK=%4wEosm3>M`xk|D^@`fiSiwD zAx;DdHlQw&-;BU&gr`9;JQBRim_&M#`_az8w{)K~4H|jna5dHU5zn|QC)Q*@7UV)I zA4c?EmfH-IP^uTHJnFpGj@SaLP4hzHu~P zqOp|i?f;HG97893^UrZ4^S!?{&a@h<48*^a@5KHKrm%Dw>Dut7T;$_63QHD{j&@xG znOrJSN4g*2s5gy1P@#`KRJZrgd{kE5fkk}vO@T0Sy+@t;xzDBjmrhGnw(Pt`9AJ11 z1(C}}q;LrB)m$u7_<$Snsl=S`CWjn!a`oD<3$0MEp9ttaV{RMHFPI0k8~XW;kUi{R zgleoEhfu&AAqSwP%A!vk0taC_g_?C5!4(VnI|ebFX&0;^H_k19Fy?zqAU?P0`&DO# z^_+O~#}@*=QCr5T*<)C{OQzoz`VJNWqIoMH;Wma&wvZyx;QK})_&7wubb0ZG+~2nI zZ|?O?Luhv%f|*JLQ?rU%t9PPLu>=Nt`xU{P89#pb`YcSyOQ;pd>7rt?z2MXJtG)-! zJL?F%a~!W_TJ?pF&Dx)w7kB-^1G?<6@GbKmh}uZ{&!=~h6u8~MJ+fa=u&IqP>B8wp zcP1a$4KSd}9lb8_4+Dyu(#b77PG>kKkGrJ|fj_p%9@OXb(Ck?mdn8Xfl`>Ey#moil zh};tF+4=7IPS4j|X8BN54K`-gS6_WFG#+n zy|yyZcdxFECKc{JZV)NTiQHIjw;eUgjVdi<2aVxSsJ@}t9Hp^+tsq|^wm#@#t@Ds$ z;00*bn^6OcOM(%(0eajZUK+zfA%kS^P%l~Z(eLb9&znd+6 zmptNYqhwQ#Q%ntrmVQhP^lp~WU!xs4_mxPqE^@6TvF+&5A+H{HkAAJ=s!3C))f88x z++>4*L~s|YPu%Svjo96Di4Pd}{~=zR_r!_oE2GMzTdZpbbwKSnr+v?k4xd5?!6?M$ zi4%!8Q2OA?wA~&^SpDgU7Vcp}v2QJs6gUh;d!dKGxF_k;r<_V@;4uD#Z}d`G9F-rD5m(ZLTB_ zxa<_GV;w(bbnqWe@O?;;$jel5?-g^hsJ#Pd@dga6+Ed0Wf_rYfvvug<;;TQ`sh(BK zUIg-KLWi`oNxy)^oJ+e04(HSg_=a;-)evBmC|{_rSWAd|&!faDVRyz{)}S^ez3XIb z{U-J4Cem*dfxEL=N}g~4&?dQ=pxwM<&) zysjJ3fwqYd?wc#`j97R$Ymt}=>iiC%C$q2!53p;sPeo2}<2)8x5oE|@D#y;X?OOG; zEjc@K(@@t%rVdtC(aYLfc-C@{3Di6;%Wy}E#s)O z!$9{sGXb7kpFAxWeMpc^3JcI-gXrLwcq9M&k{16QC{Nps9v$=QaY*}U-SDLpaFo5K z4jtk%p?tt6P2kiqLqg}}f&|aN?D)Jl}Y#V9dbqab|AOr zXoS!(EnrUE`%@uG>a;X+H8xr7)S|dd?^km9VmNudPw5Dm->1yaf=ZORbf1sEpKTOH z8JnVVcfY^ti_C-{AHw-py^Tza+A14BOGV24b>`KV0@&qbq=yWg853`Fk^Z2x$npv= z`Z7gtlqxx^(HC?jvfPA{S+a_-6U$KDvGIg<(bTMN2oL&HhyuY}svy&ZpDHz}?XYHa zyo4HzAoXwMHPXSeju6bRGx$?$CXh!QeHpg#i*n0A3y0g{%405Jw zfhL=LCTmHst-+!A$vsz+B@O61cz7K;AuJb!8G~t})(f*E)29q3w*hQXlVbJdlycuh z*Nv0GlEd>u=f^Yj415Z!x0vB-ikEgJXF8R^o$IJWE{=V>yDXeQP2ASGDFfb`UJu%i z>GknEMD7tI=0PW#G!!MPoWAGVOUgil)xHcG=Ao;Z!(7uw3%|C zi`8>8Xq9cLZqu0)&xw~EOOB)VTRL~-@mmOD`w2oO(4RS%L}L8R+d_m;ZOInUyBk2u z1Q?yo6(n%H9e};t?L$G1Q$vF0OtgPU()!qCJqlVEeVOKyery~tekC+2TaoIWL>=)E zP(B|xI&C|If{iIh{>}6eX!Y)t_n7%#yhJ2skDI(%@bZ^q!0qR|2%-m^umi0HV_0=k zrs)Ro$K`M*3zY)|<*Z-+x?AIeX#xI7A9K4~bzt@-fM>eXoQf{RJc3u5aGRh+z@!Vcn$skgcZ8WReod7zxmr z=ocBTMV4*u`m`NY1}8&Z43JXQ25?Zc=3X6AYD&p50RM4vdW~ekUfdvVqK-QqliY@U zdJZ0g;$9C-uu-yu3l zk*7SC9#rY5)=tAtrXMtH@Y7}yCZNw)ltRELLitd^OsAuVS)1)g1jkHO(`zK3!hT4e zL9d2TYBu9xan`QaWpoindF)Kd@&sTALosKk zf+DN_UJ0cuM`CiXah4)B4nkdR!S%mA&tG?AzLdG1NK$X4JtF3#%YJ5f_G^B5J+wF} zA@Um(sc0^%m9PjRf(Nq8AP?lhBuI@acTz&K86uO*HgVDED3|r-RqjIS<&6%1Hau&234UZE@MPBlDTPT zW{L%GB_uIim^%xl#9Xj9_XT^ynoAZBDS-1&1Lzer|9<&$eLbI|<4%04_%$O@g*yUq zW)C>Ao9noquJA|pdBhh%A(vCV$@hjltW>#TIWhLCZQWtXIS34|OL)S}fO*SkW#-X$ zt&Li=3+Gz);j^}-FExR0kG+|>g<@rEVur@Pn)RWzn}nW3MmlD=L(f$2dto5z!^kcR z)?$A}7Rnpm(QBw51l=J2sZviKO1mY(mqC}!z zuNIwYD6Yh^vnoo;9x}e@%H-Si3Q&nxEJqqfc9E9i_cCmAQ^avc$n}?J(26esEO0zo z$UVNiLD#>M4CE_17R`uWE8vv7Ts4x?FgndR*1%b1dd(3b;I=>vauMhS>l-qy-ER)u zI;)<)1#B%aoE}b!-=hXC%bPUxz>?yPZ^#!1dXop@Mjn?0j%->)4*7DVoJ=j;^iA)% zIcsR?N&ScW@@!s{fz=#xvZa!?QK*)MstD2#KBNsej3aAkUnt&J14PTXYc!Q6oJ;rw zB8)iw)aXTx`zm7a(YYLn3uycbt^?6ZGS%xq>32AdO=AEJz!e^QQISG5ic8RG(7&^! zKxi_^kMtlS=M;(QuhDs3<%JW~4!bhYU-MY-%jH$hR~^~vx!)l>9ijiGsQDAp3Fnr+ z@oQUj^V-`UK$$%9C+o7OWiPXNX-!oHrxTOk*PCOFZA&VHsziaRhQ}zOF}Z%b5z0~j*Vi!|?oKT29hddJ*hV*8UvL#EFz82R%FAG6A`BnPUo z$IGr5PA+4)(=s^6cF!}`ygC1PE+?O&w7i3sSNos$f8qbd-JWDL^Vc=m*Q#Z*_mr%k znfL15WYU5)-yH--nS$A@-EMTxu@#SYhsU)KZO&CGmGG{6Ae_|I^qR@)3IHTT|Vty z!f;_O`M0z?=u;63o?gsFv6%ehI94zS6XE1IeXGyen@cfme4uhlk@UQ+Ml;&zj6^`T zs6TUvJZfa$C?0mqroxG6QuQWB4Boha$>Y|&xH*|AVNh&-1F1vyea7sC%2k`Tfi=i#U~l6RBj%L(`RFhUY)K39u$t|6lzl;xX3 z16)^GhmzCNQC45z1Ri-l3S7al2PSX-C`~hcef9k%nS~i)1;6NRVR0ZF5$~hJxfXN) z>BlP9`~=!3lYd!X=}R|#`veyc~50pp&m+H^e~z_K(LV+cPQ z^J;!1z#R*Zqc$w-Q5<%7UyF{*r}$&VLTTu(1j_`OB9}a~BLS4S>;0u^{X`$pB2ju1 z@~!!+nb;q(1+%bNsM$`j`!ZJn;vZA5NFYBVbcC!ZaCU1nG~Wr{-s?^UHns$D3?bt@}vpmYVDJg~P-bpDf|nVgBYNZQ+0_Mc$js zh_(KVo#)?WyfW}7<(Y@x==-B|U#pgI|DuTQc{ zs%G3viQc-)ew8(GboTuy4GaGSICjQ;MzhwWH}hbxXD$yv+lhk228Q}EC|BJ0`&FlW z=dy8-aDF+U7*CJcY^r37qt(ew%efwOZ*F{?o^Pk+! zWvlp$I3dyGvp3ngflJ)K!n9&)1i?M>mE1YcfQ!g6=n=U4WiEk}%xbrIP58vRMv)hB zU_P7vcosLxEkRyzbPxH_U()r&Ge|S!Mlk)n6Y=uE>DNweDGRL|7QDmM9x*|8g-XlD zWnvQ?#unPvEGhx?gW$wOzg^gc4)VXzbM)bqR}*@RyYVhKwvs+h&15ydikpnf*hQr9 z<_&B-?DkYu$a`68!U-hnzY{p4twUU6AguA28=Zno)+eEvYd3dQL`@1mGjmv-BZ2#Y zyOgUKNEKDPJr<6_*>$Yb_T-Gn@|_7Yqvl73`uiQtM!wDzMGnB)3kXxE7Iz7~@@5M+ zzA^Pyt`q8`{UDYOYDoKAO)4kOn6MX2Ds%pu2Td=hu6O6)bUO0t z5)p0r>GE&`RX5LXu6VHPkzBb_c`kX=?!*zkHD8qU{qpo1)7FOU+fvp5Q}{eqbad0> zYlhaFUYzSAfM=}bbL_VaYnRpBo3W-7J6|Kj-R#_@kt3^mQ54TQ)YP}>CM%sOuvi;j|Fq_Fg3FNAHNu>(#L0*-*VN=gT$T$K_5|5I8}(8P{{=px{FX zeouLyFY;XSTmj?2cI%!BH?2rxe26+j5Du4&xgj^m=c~ymjxjdkw>CS2C9dzsW5NWE zu{u;vy6s zoHR45?#3(2>bxSReHwkd*Tu>^RYeq^(2C~)71ex-XB~L=KKi2h+ruJ{m+DU@e%_0K zVJufQOtgesV^gC9^nzu?T4{CBWrou9S(b*w?tz~n7PnV4~2zYOJrFo*u_Qar8 zUmuKmmNh9iO*md5a3PoZ_0Ehu*i|dCkCseB8)s zXHTm)T3;j=j+M~3NoY5?%ZF1FR=;}knXpTr^V_cLU)=w>>X%hG(9663@=v<4H^_zS z{j2Xh+m*Jq7yC$%1+gC0M`~QoXp#J7QS0Ky8+@7+*3G#Zd8W5>xA%v=cVY)BN2-Eq zx_+~6#JApiUc6azwWRUj!s1?wu&IU*Rz>>-hrgIL@)Z?JXNC3dpD`SdxwQZ0{Q9AD z5n9J13DgS~e5;>LF_L`HV^cKZ*bedl-AKd+eo_j@W2Qj;rJM(blkH7;LR@@b*~ z?N2<4%Bb^7VWMsQbtTK5WctePCv$nVyP5=Lk!5mozp08gxYkiI1P17mA&;xBQnWB{ zl+KJewbYs+rNzf4z{ll_%=h1(R#LE|BoD@NQ%A*c32L2O_PSb6h{ev*o4Y}KI51pt zfcxnMFN}8G^*P@b7EeBS8h$!fLr9PcIX*dW}!fM^btA_k>q_|2&& zApw61m~<31*Zb3DRRT+L6cKKf9HWf=Dr%$hMYQ7xHgXqEnVj7Eps|r>hUrhHcA7Le zb;iMp*KZXgdQhUru98Z6!JdIk5uy%x#0OptHxaX?JS@DNoPZ+|YaNCyET3EPpu}RD!i+6S&j36YWLww?e zk(Q-Ekdk8N6`2Uq=(Au8N8>l|7&>cuWqEL^5eKf^4}CZFb<(7HRTKC@TwLKdIAK4)FU}A75EK|NW;;{kmKs7vs^h)aC2nrqh6v z(a4mvX*3lA^TOO-RbnA+X!F^buA8rA)42}60uGzJ8E<6G5Vo!xq*wyR4+68#Z3WEn zho2^s>lYakm2_r^r$^EhJj>n^;~saFuygOJKDOt{n%BI{44C zt0%G#$fFP0ju`H-3k3yRd+UDbA`fA1Fc%r2?N>X7e)z}xT*5--`srfpzki&_d&6Gm4vuJ?;5@W!?6zm`!|PWlO170#0xwj}RTx$)tEXaJM3-JW z91re)c=c3jw?TWCTEug9k?Mr?msa#I-pk+1eKuZ~O zhp6PNn+3z~TJr`fZwS%;(+50rLb zf>_&wg*WzJ53ASn?t%1?kD5ICXA`hrTh{ zesr;-Ge{;5hhU)6|FbL1J4D)+sR|;sKV;rtEa|g%oM8 zc3M*NaYZ|)1|8Th0kkO)%Xmv;E~&`2(KebOeU?PfgGEkNNU-(n1^s9|1ge(@~`Ays-cGtM*r!<47SUA*OZe zA@ZM4d{t(BMRi3#pW;2?b@tKL09mwAYU~d*W6Q9M8t=}!=+8$h+m@c*dhMXjf{;!9 z0n6^S!&bQ)=*YOu!)@p2-j8-?yPvtw&z6m6)W>+9_5;nkuskWDYRn&%snTH1pgVIX z%>cZJx|QLn>M$tM2(6c^6{bG`b)yGC!cBSbE&HdGoH%qq->=!|->Z7I>!#H=-KHJS zpT`dA9;<^GQrSGHmI<=ZO;nGWQ7YZC=xWZ>Yb+smWIsY9M=vtB_b{i)ykpWP@JNH% zHEb2EURW>onCAZ4BW$-PMKcn^&@w>WD-h3#N;?JI^q++{c5H$L7@Je>j5@0{ijaksz{k1w>b73-(-7cI>XTTwzZ*t() z$VVd|{j`KZ@eAy0X6{Y(f+uuDW#0r~Y8rskcNenp{*HVg9u8G_$wTgk`z^im&WvW+ z>sIi-+|Q#31oq%uzr*mn&I1Q3&%jqlbx&D1v48f5ozFf$vt(ojVbj#C!S{;GpIjsN zrJv8liNh}Xvh@#K@2`0__?>A4=JrmXv60^l)1R9i>W}bpjK7d+)ed_8rSjONPA~rF#rMS#uDtFPLb-I$A|J{Oh`d59vO^>xWG$L0B5&?Y_+Cd4 z`vzq@1v%Z0XYX*1eD&B%NB;fbetqJCE=OajO21}MVbR#jb|1cXei``gx@Ci4Zq)=< zyf57IKE5j&(doh_*j&x%NnT7#*I+ZCzC!=ZC1l&rpTF6_3qbN_H%+k^-A94~V^_jO z0mX1CO0jE($K#Ij*7mUHIKDd3F%w%Ut|`%TFq*sSJBRFt#MYn5{H|N65;HL^0o~l& zuuW$rLE&DUpSgKt$c-v_G$C7KWQxvK=1VGT%e5%Xdl9pj<%Al(6lE;imed~mO*vgj zX!-1gBw-TY73bV@&#b2Tjz$(5x(R&G*BUy5J`*R*ON9>u;j*w-DIc_M`^SIYeJHy~ zW-z(Bbn&hJqoi&>P~s#rw!AB?bRVJap?to>_~NZOuWm7F=E8|U&bK>EvdVBItABK2 z#vt858`@bP^ReaY&_FjJCwUK7&FdvCBqJ6g7O{mGgt@Y6{h-(x7_-ZRMMc@%KE^;x zUgmppY0kKkeN9VCZEjgefY=_E`V!$&+6j9B=z<3QEJb48TIy7~Im-_m7v1dqcg(c9 zq9Y2CU;)JNoI;=41jfd_~Qii4KjpxM>kF7Mhaw4z6Dwv~z% z6z`G1Fbc1b&6}IlxV;P$#I0p%=}4Sop%_dSoa(sKjqepFUT-(?GP5kn)sTBmoLC4G zKmYLcT_ri_xLg@^__wng@=F#jscuV5gYhW3J}x@(pwM;T|tsk7ul1? z>n3DgNndc8V`aUzq;jk%X%^KK+Y+;DUk}CyKE%rn@6$b7yFL4>gDHXM_*_9h)UBXE zds()OIMvJtOC~CM5i*a4n%fNt4QGa5RiPGV*D6HSrNHltuzdJoCXGnuMRVA(;$Ec; zbI9A3q%}cpACoUM2YA;00;>wJKZlVId1k$lnu`Q@?_G*~84@Lh{hrh9^|92ffO*+d zhkkevrBB#oL(~LAT=~2TI9mlPNppoRQz$Yy`pAPV?6s*Y!UHt{b^YhahcK`V#BEwO zpfmvkQ^6gV=v<;rcKW`Ivt=4bA{S`4M5?a zBt_WJRyRVH+i|)298q}(TBCncqlcRlCjV30pDMmg=XyaRxx@6FqOl|@jQT_eeQU{%!EtCinC${N3*g>NCo zvqgCbj2?HQ)F)Qgk1RKht4Ne;^Hm-jMBc$7LH8G5o(hZ1aS2pCV%IdW50|(o4<^Y; z5>&42kl&a_m)?J=nPTn-l^_uOFPG9eW96+Ii6AM-VxBm>N?g$DJNKz4Ty(5_iQv6Q zgDDlB|5dJuTMDF9;5n9Bpne|0`g1jRbP#ZjcNzj^!A5J59dO+-S40`wwAQ@$fC+V? z;a=6Paw3msW&jYJFIuMuTxP|hrBE$^Pg!5Udw^r;qBI8H0nD~q-(9_zS1?5YMHh=E zz*q;T*A@GPz;4$rv(mMEAs6)~nqYBVl9B1w_b`S+O+I-c6arF_RdQwjr=EsD5>Rt* zE=#P0+ve$L1ZqMvHFH^y)9W|h-&HAp)pO;fJH?NOYErTL%@&yTVy*;ZQ?H(aIQnl% z+tJsvXEhpHCIJ4eDZzN1k(1PBTqBuMT5EYYIbyPBbyL)^Me&F)?su9Rcf>A)eC3w@ z6wbO8iA~G zxWs-&@5cT6ShWQ1Ja$ga21Gr6oranI?6YsWuKylK1Ce>)qLqDAzQrLWBUaqyygwDNz8qH# zY+x;py6_GNkTr41?J^U;Vy6TH*Bu#&YWSy&^A2o#B}?SIOdJiJ*Fe6o7#||9iY9pa zRy3Me1zxsldTW_1f^(9ol3Zd5@d@Or1v_KU1wz@f1+=T;AE(e0BWPa1Z0LWp636*z zz_46AV}(*mtJCFU@1JIUNNqtV@!*;4))CS^zt!>J_%avza=}Na>^^jNetGQOIr6;N zvp`(!*jrpnnSd?T#Ow==1}QB7PLeB9`BZe1Y+0ku>9Nw!WzO5!y<8eG)XU-RVMcNP z(*VMUia#4L*}2JhO%hE}AS&1WsU%ueV>pWqpthy?0TOzeD_+~QLVE@8VN*%*K=LHz zQ-wTNu*7);b%rzd!137RLH*72?z9zZn@V50tuw?`h3ZNfGxJuO{TpE zf_(1ie-*p6GS`v39o}syZ?&Xot)e}MCG1uEk1AqgrzsW9&X54dZR!P<&&c>FC_$ zv6&rSi`I`OtP-sktK%*O1dwFtDh=eFD~G)3KloxYLsr{I)-AyqAmj5yyQ3`uyntyn zC>n^S=G{sGEHX0#lsO54n^=(AQ4g)xG_iTWBKa3)h0ZZ1WX%GdxHHx-998XQWx=ow zb8}^;750i9EK9NPq$-?LxM&{!@-Y^SC-6qawuN7q7)`i^xS9eY<dS%KC`j?pWXs{2pt!1!_oJ2 z$>abwOrsq6k>It_q|6+G!-bra zAtm}lA%8zv_+XddrcF$~h@Jp@l-m>(5=2Sy|4>!fmsq#1GO#}4lrn~c8p#({KpnRh1 z(&@GGIk9kl>ZA4_&F%N81->;_6VM$qN*>AM3zC zAf$62GJ$!g5Nng8jwP-HQ$%h;DUGPcVH~_Au6c*4%N{G+((2i=e)rKS5$>Z-UCEhn zZOP-uMj&FdS8jQ*)BWwd=Q=a6pLeEDWd;`MMn*HiVS_&I)~8_X6P>oHP(^Q@?iuW8Hvg=%pY3fHprRssjzW^s@H-Nz`3Z!GarS-FF+=TiQY zY+-JK_`1#P0(;O#wnP1<7ww_lU`SENb2Ut4!8(sm|TFyqB83d}H=8Ap)dCs|R(RO~Tk*mr)l{Ex#azh{h0I>21G{1CS~ z8Q8h1cUX4}o@HkZGpzc5v6ypzc>3GLKlU85XvpIH;;tX1#ru*u%J)YQpzCRqC)&kD zs(Q@R8)@wJCs-#YxP8GqaB{EK77V4`eQo`KhJ_6tj*p2*fWgwcA}v`3by_U zUjgVS?|SY8jzetHP2iQwZ~8QoUAx5HBf1gch5aTw$zEZV(Le; z&8%}ZO(>!Fhe5mu73|UI&E`&nxl5flo}^1tJS@60^Qj_?Vua|+hz+thXKoy6h2AM4 zIYM_SqUQ>~zPyoVkwso>7T>qB283AQ>t@mE%KSZ^wJD+(p&B~lRHgZBFmJDFp!b@` zHD{W&Ai&NwO#gn+Lvr1lvonITzu)t1yUVok2W_P>6xv~yWKS)Cj6%zjy=yeXysrpO zOW^&M7Uob_#65plo=I5X2Q_ajBup`TX`G>I(_aXz_{6NrA%BO(Ma!NpTcwi8(R z4Rx~KxT9EP?f3>Um9$Zar#T+l{WPqe?k>*@Q)(Kw9kh*D`JRNqQEq>8cLOkvow>Jx zRlVi{-LXVMK?UH?xH#t8H$tAD) zmrnb>($Wo>$K@3xqjV6-v#0rKx)c$I{8`txBR&i>E7e#45Ggz&DK{-wN>HiPp6fpJ zm?F<5X~OacFCHk@gxx5Y6$1>|ZNsKRvDC%NbOm_Lv;#Wc!M!L8tH7B-rl``h647K3 zJvRpKX>EFJgJfXwgfzk@OutPCCDa6|yKZ|)iea7Dm6jT@BCrcjKy1ENL!Ln-qsH&4 zP-yeOp2j6wH~8IRFMiU`6^q&q{FTJp+Om3>y@&4vE`0Eg_NJ7zq`8p(bp<#rLtRg~ zQRD*Qe1Qe?=7pABYWq&f{fdHsmf*`L*0xEm;aowm5J8+}5fgY{`M`zL3%?-_6~^kT ztJKA1eMQQBPp^Z#2iXZHey;PACVIMjcJ6ZOC#E(vdUqiY!&YLp4aJpGEDoBT40RCD zE@|y0HShS!&OL>+EH$@;G`XwPmWvq?E77)enEQ~&S62T&biE0DjQ9RM{>+Rd--N_% zGiujef}(1RD2=$NZ926UMbxFXrlJWYSIr<%YH1t0L?@Oe5<8_Rf}-{iu~kY@4HA@~ z)#Cp?=kqLSfA@c1S6kc6GtYdU_j2CnoOg5rO4xL;hr>*9YDGEi=mr82to0&!VqBsw zdsuFVBG{e~?2+)NQ#};aR45O5C%;!r&k%r(X!OSqdaK*gA)*A(r#GzTv#(oX4UAr| zZ^RVFf08^j)MD(7M6loy3Ly5IXfCHwQlN^)&ba}fmO26G28-VX9Whhv(B|bLSZM4Ah$U>4LCddME zT9)S=r;GYYRy-K3meR+L?Y`=_(JfxMmH21SMg)q5*?s=lzwwj13+XkGrsTN{MkzC@ zNpdD>jzJN1Z28UrmPretZ=!OVBllu##0`{4uN@dyv&ypBVa_vzlv(j!m4q;1!Hiyd z6Sa$3VK^s>SBM!XGM(%!H=9qG%2uj6qi5Vv}nm6i+(Ti)&cDVEZ}mysrQ?F|5hg5n$)nbjLh#y zD2_oG?7pl7_jsavsIh#H2OCBAcou3SQSy>n|?%FSqcH z3|A8%rOE@vMobaxuJ9_h4RtSci4Uqk+W>)Z>j6=o%o=P>t8WFWAUBJ7`+aE8f7{RK zcb-W-Gx$e5$k&>~I5H;ihOi=%;YnFt#N>$Lsz4e*e+ftpsz(Y9Lu&D}+-aN&Ycd)l z_EnaqLb6k5P29oZeI3q^P@I&;*v_~B-~slstpr732@!-Gv>C>ml%az1EOd~UzQ zNacs)O7@QAfvqCNgeHbi-|(Dt2dni)+r}N3r5xkL)>c>HY06On&q?K!X)=mbyY>e1 z(<8oi?)TK`jWdE)2>pKQp5q&g2pWf9-VX8SCb{RY!ot@{w}OyVC0#i!pQ>Zyf`%0b z2ov$XR64DXNw1o>a)G!GZXds9^S_RFmGFs~BcSZwz3mZACM62QaWIYBPkrYs*mOU@buz}{(EvQl3zUd^Vfk5`t0?YqN zeHY^3UiPfco5-v9Au9SHAr0zu0!?X_6Xk2Ct({9sMV)yZrrUy=V2hgXfg2vsR-%*6 z12z>i;r+}!F@SVfe&jX4oe$vYNopjnI~|F~?ss*rSkiY%$K`>m2P7IN$<>$>M`e%_ zoCYrDY5wKCsHru?G}L9BFLYhfxVT&Z33$8VMVGD$-=?Jy3J%E}AK*rZsmKkwS_?v} zs?1y}XHHS?2o0wy&5Ww+RR+K|@(e>Zys-8sztmi+s#P*le;_n*jQZ?$($D}+LE;bM z-f!t%qvLtbq|Hl`QH5^j7b#x=XhM#om?{v47e8=G*6h~&@r(1}p7%Tlo(`}`8emYi z=ff($+m3MAL7rSVoJ8WKHGUo*jJcS}wh$Iw^dwaBRS+~&^ry;U@XNSg;$J2|go}%> zPAaV|HaQnIR_R`nHA)-QC@@-)Ef~3vfbBJr#W6H1EuQ`Tzi$+jzwvM(f z76JIC-!Q1p64>=J$$%(0v+g4_-y;&lpXrnLM9W%*vi8o8m2XsOR8B*kYkCj>;J}ZC zVD~50leQ;dPVW(EsbRC~P5fG{NMGU!MJ6cUM^2D~pk(esC^ej~k2Nfxw9Hf`qr0!( zT=J9sQ}I&#LOy+{eEO&~t4Q`k3{3`K(=7q7hS^s8UsRix755l^h~4FUrfkN0+s#nt zai0{LXkeWj**hFUEOi_?(aAsoqP^RsQ+|R)8%KYQ?%j4|<{vwZSq46`8dE5*fRa=MdP<(uRNM9YX4$TUYZ4A0l@!fs?i_pi;h#d7k$GCVUZTU; zdbL;mdS5PGlD9FfJFGRp6|UZrSr+MIY~*OXp4QJK;MoWf3p}FmSq8HXtME96jZkul zEe1=fLDs38{Tu$7n8}v^%DvtrQeSvn>Db-pL4La`MN!tLKR(qm>mS?>M->cV&1hIb z>~gogFDNfa2!qKtQKBQYf~IN^=0fs?>D&vVQEVqsc#xk=W58}(rLDSKk;D)c3>zYc zgm*E?-$ahLaB0@zadKt}_XLCU`?b`DSjJLiy|A=1PZ!Ph_5f0 z)bbFs_h8~c>YS>2H^b;h!LS5`t~5f`oytR~G?ww;huDsQXL3}Mc4gD4wH8|hAOG1@ zuFq;EXA*NbEzg{l_r>@?Oum|9CS(ID;yy&-2bMtb%|JMFY{lUX`=DXVb&)h=nkj(; zKr)y43^VV{!UkXhej|_V6dVkP{7{oWE@LJ);{&)e%JVZB);wJidw)aREd?X940oMp zYO8|xt%5JMA}UBH{;R2!M}wvFi&6_8IK<0QmaAOirzVSHv@DdLVa4Nr_fi4lQ)}mG zW_WS1WgV}}LE>?D)hy9u8t1%m`@0F>J^RaT3C&bORM)*~;)ppo&afgaWZbqV`AJyB z2#h9J{12b9x&kV9C1Q#>i4=X6p5JtFn5te2bqh$9Ew3?)K4%H@?g}Fh){?+*hVoP22!`?;h>GU`eXv zI_`2jLgh>nj2d-9w;_%gz>{Gp-IgHdZKlbHjDHV0XFDx*l-xNVxpIEQDFWi9E2(xm z{&3&P1+((VSzd@Y#uxQgKPgR;o{=#T2t767ThdAn{Kbz*QNiFs5fdF~XVrwB^)|%n zG)4j%^S0gx2rKZa?n|b~8A1HOtnj&pGvymxIkMad%93#ftso&HD@VH16-(hHN{HqP zVK3U~9IS2)u3RCg1z7DLIMY>1Cbn-uFILMs@h-ej!aEVY7WaQC-o0~)!K3Hy5@)3- zKB-rUu%HiW&$;43lb_7}NRmjnqc~i++iKJ&sI_EZJ24u^Oe|?u+k`q6lM4ixZ)rWEKhi9)$jT0+SFDapco=ZXe8uyw067)>UG%0%{P_tvyr>gHk z55Ieu1ja@i+YD|QRpM;y_e=*rt&0C#`7VK_L{mo~Z_yz>cn&^|kGsY65mAKlo3MQ@ zAyfjX;`wbr8IJ*hfaen9hY&B5P@>PKl)_fpFdqn>8*%7=UU~)w*YeuBNk(NOu*AVi zIp~x9k2ZO)&`DM+bdreE-S#b9bi6QD$UWd&dX(x+RA#1Mr1wL5Bi|@rq~W+#wa)PY(CFSl!xF%)_m))^IKxnp#q6q2MX|*$N_DzOLxNDt1>XglglSfFXhV zw=+_#f;M|URhB=t8Q8nmSX!v117a&2%NknQUof1f%oH45UveSoM<>64u8s9Igzy1( zH`3K^eFYPq`eUBxz|iNG$i*17INYq%25eLoF-rA~L7}%m(oO(rnJ$?a>oP09SnNk~ zLKUG?LaNE(R1x?x3Syiv1*)@VR0>UeDB3AyOQ3j(?cz2G+-O`Qhg>xcb#;0TaSk&nBTHg})8(G->8Yq8b}`7#TE za{UQ&9N5`SWl^q>_TiA9FzX*Jwy;u}EaZ!#@al_5rONeI%BpXHdxD<(+?_KLZ zmj$nwX+8yn(ko7Du;?xvJOuBg5N2l!PhbvbYN6BQJW(?37b`&?Uzx*O^uhdDy^>rg zP)EFT`1{Uzn_isGM7yZ+rwg`@{`YTil!)4k?FA zxF`p#^Uj~2Xq(rMJ}QLir+{YBOz6Cx4+t7qM2aBrNwOBiK1@k(KKiJjfl(6g+@;## z$k8he>=;W3NH@WO4(>aC%_|@0?O2u517C*eL;k5kqU9-3=shlAAefo#nMhoD8Nnp& zpmbrB+@$uLoKXD2uPCB}biCYf0l2G!rE+sr>Ni7Zb47D072Eg5%9kz3k>Y=+0d-fq zR{&l=Jh*s8+Y@8DN#WGN!l>Y(c>}*o+X&^oQUOy_lz7n+m+PgDj$0FZTxOC7PMg?O z`{BZVP6{Fox7udTA`Ol&6-rj^5f-P|C$9|;PPmcZd-t3lw{CS%$&Wk0VfZhM9P$7x z{=T3=%an2Vb=_sB(`(qc__O|J31Fe)F{IFqWdSR{YOuArGm$u;{G#e}mNClBae-A( zXeK1D)hb+yGdl!OcXsZWv0>?Zx=sMItOLJF$3uboN(lze;p(5Vd05hs>?_n zK?~7JPQ(Wwmf_GBa^#f^5U&*;(J5@|!(1e}aifHvdbdJsL{_%YIe3;pvIUYJ_!Dd2 zV5#8RGd9`_&6y)-9y#QZK2O8UOyox8cZ7{F)jE&qwD(NsGmi+cAsRi^_wG}p8;*Vh za?ERhh15=obIK8ls;0{TsvLyiP(GFii<5}eQRN9WNLj%415S$tV+)SxZ_-q5z*20n zco9jRRm6aX|2_Qh2*pKs!94D+&|e3#yB1IL2I`{q>ijb6g85XLf3%+m8FX%9V{7WzM=eR<$z{)evZkd# zgMi)?w`OdR-X6SShGI3lJa7m0nUoPsA-8@RHNbB@K&0PteFHR+5J?z`B8bFra_?&Zp`?YEnfr{=>bq;6j<_o=Nu zH~(ce z0E!cWdYLomm$9sujwlON#KfNJFZb zloaK_D4V5Tswkvm=9zM46Cps1~C{Nw`-uRk#vC?BN;?C@b2;>ev zFisv)@*x_cHAhv4AOBYZ@ShF{AyQJ|hq^}Hygy7b9`Y4e@SuvV!wA7lP@_?g#>?k< zKa<-+CFe_MMoO$@vNDD!9)Gt@$JvZ&DsQltRldyvfZS}6QF z(&=MClY>Yl!>PXSa4WRpjg*?wwuhr)ie~Z_P&+E$8WZwd+GlBK39$&TqtR1X`ii2`R<@e?l|qFBHY~#`q)UdgHOfsXkx6 zp7>Y&`*Q9x>jP^HwIU4G$mv2#}JY;6TB-g5~fx!%e93}kq_4>FsF{mWKmjm8CdFD z9w|m)jn+&;wZ7{}!}!HT@sQkgy1-_cGftj$z_0z^+|?Odz1B%x)=XIWx<`tJ+{p+e zR{Q9<&XX_QH>W2-z?$yO zY0+gy`pI4wo@&~4^SnHhh|}V;=3m#mKDyJ$hw^#OZM&Mac}4T?7FRTimfB{AlS+}N z+scZXnTj#-<@u`vgy@b57_Bzxq?6j!Ua)@n)<^C&$=}O08DshOd#%({s=eebF+cH3 zz}qE9snv7?vV>e@^r1?=)Ol!9-^5uy^A6U;_{6U_yk=(3R=iDg@ij*a=$rltVKZ>h zmYYJ1hGY^6O;*j9L^uoATGrsoATfeIR;5^sem5oDm$?i+24@Ih1n-dtU_}dwj0kGE z_-e_?ieq=6L^#krIC^wiFebbIo2S3!#7@fMW!Fu(k^FgiumWgdr57d~bqA|?v(>?K zHzxNZOn+C#3@A*(_&RtjIEuofdIJ{~Ii}RhSzQW=!{t!t(TDln0bs^WFKBss{rs+N zi`Ok3RAXOjJk$WUIH~`Sd?vEN@T=%qJ4=n?!FaxbJY>lO<#PjJiuTGCAjs(P;yHOT zq7Fz71ED#fI+m%VWDJHNg2=8*mC{K+#Dh_ zGysu1rynKw~R}UrlOFZ{lMJC?_h+y~FNQb2DJ(e(S!iPTorV>!E zHe$bL`0p$JJh{+Y6y(@yt$y=Bl!@}MI&6tjo)d=3 zMGAYhbg&f8rCuS2X8kX^QD~-6chuS>8zB+^BOGc}|LF4M1A7k}@1l0ungw=P>}iU& ztw7Ij#)!>s7*CzvB8}ELi`?(w5d03%N&VxM&lGQ~Q{C=$Xp)kN$Yptz4n!d#kd`^{ zhT}&NG5xV?z*6a9k|^n?T(+eD@zGQ3&91rS(9lf{ADxtux0-+i*1_saW0^umz3*0c z`*S=^U<2kH{OZHyF8LDfZ0TBDVioXKf+E1QbVT8qWjDHG!vLozKt@}QCjT&;=7N=! zW9tQo=S2s9=UVN^y3O0AO<1!LHS?PdIC$Z50xt${N)U&#RSg|{qz0r*Ce`QK7s0=q z8X=FAQoUh<{4on6UAu2X`$q2XP~hKm8+=>%J?arqMobD2GDpD%T_csgJ3w=|p7dgZ z#7uK6R%)EA5{LE9w87KolfZO!pT<%5kD#&3fiO6$#FNYvI3USFP4CiuBXh<3+&l(2*C*PAG(roj-#VMKcLT!>8 z$Ik#}HjZ-uHI4~93&hAamoQ8{lM01v@(Vmv8bm)USfvB~}+N8Oz(h zmNWe$INSCAxcF7cQ;!G1SlTC=BO&ex3oyO)O#L}#Oi>>}<(E`SqzlVR8XMj^< z#plD`sX+vTBI}?(J}NmByZD&gBd1BTwA2IXUU*=p1p3cuSW$HyHi@U7`%<4)ER`Jg zjGx-UK0@#!3AFBr&`rjJph3OkY^tfH=a86&eR$=WL**z_QU ztC~$Npe6<#?!thYn6gVqy@zjFKKk5g%osYVnG&V0;)+2E&2;bZnoUPPG z{ldzLH3ZUM`QFl98D6`Y!ot^8XfXS8kt$oxgt1`Ghz>&4pM<#)^ zl2oudAxT27J|H0_e11aDlFk{B~SaxZyF=hxK-`4zu zg0vfgrwVw;Lf1myAfDVtkASLe>wQCSqi6;1$^ zPrl^c*3V!Ck3nFVhI`r~%uaAdgoCNBYR zqd~+di%<1Bk2hFhF9;3buftuzRKLtC7QVr;HPycx_T$4e&6sXS6EE*{T|c=+F@UJP7Jpax+X0Tr2I@?~;y=rDNYx|)X* zz*J2$IiF<8g-C5RQexxZ*3mX5j!h4iZ$i4(npyUfol>ydl(4G3<(ayxr|@^%2usJs_P4%Xa8hrSmUDvXJIHujA?nl|9y1LyR96W{3D7*TbCifWu3A3|wX z)i;q#V?sRi9<1sK{0W_(hKDyC**7;0v>ui;Qw7257TmJdx>>~KsGbUYr zAAe86=Ik)M&~b20JicISPEGF;<;;T56o%u{TY|K&hl!)uIM^~n>(~fV=AUzGgr~S7 z)(2hhxDo4df`KeMLEapxFwd}io z)3i4Z?=!|FF(hW83Tj5)05V-_f3iu2@~y&=pD}q-=mv50oD2URe$G~m9KKlhlZ(n` z8w4>YUBDWoZD@GoH7QraCQ2pnXintzQ=fBV6{2*6RqRrTOY6uxaUCTJNfc#~3*=re zv*Gxom)SW|A-v`W!h%Rx`p@DDb+R+$7#9g=NDfteUk%S>=uEvVHEMEmhe(_u$aAbN z^+)^%H%2nMERW1SIU`6rgexb>FI)rJ5B%^@ZZMG=ZIjFoCLCK5Y2lvkbwV6#$P~(A{X4ab0ZSKXFN%ITCfQwVjS0=(sVkt`4WyUMH z5UBl;kp0R@M)Ul~7`HO!zeb#fu>a$@{f{b5SaednQ}hBH)JsD}a3 z{=1*z|9q4={e>r5TO!LWo5BLO9Y+s#N|ZM%qeq)KN9b`&om34Zmii>qqzZYVf|OCp zq($yu8gU$@Lzm*DwaMopn^K7oL)eR90X1j^s8rhL!D$3c{7>C-3s3?Fo+LWoB1wBT z%Ip#4(TR?ekL*Mhjs|N*88jve5 z8fLtIY2B~&(J2;aP6W)1^Gv0+&&yYGNUCB5*iR*21(55jz^9ZSp4}k4MD0Yph>HaH z^L*rH$zT-?A1I1j=M(1;s9G)Qn#{UVP#2vMIO-fAC6nQjL3V3Z$~t6Mj4u zd+V%`z~^^w+U9XeXz{BLM;IvfLbQ@gGUVLeGlOKxMiBQU0V#o*mn+u=$1sX`*Coj7 z%<*>OO`Zv;%2si{uA`zn_I? zyzxV*eK0wkC{!f1pMg+%z)6E|#HuK%Yzeeh^{~i&&N%!Xpl(~|_Nw#Jk6VVG{lAgF z?wDNebRl4s2x$l|Txfgt_&Qe|cn&3+^5V{dM;^rS%{KGVai|^C+v+M<%RlT_rJta* z>Q1k3B*<;6S$wU+degN)(X|Bsd33OIrzB$kv;dg63Z9Ak1a#NCLC}iR)h;Dv+Lf23 zh);43o?~O6c4v|;rJQ@ocA@Nep#!5wb38v8kpV$iMOl2^togyPbcM)C*MD?X{+enj zJztH@>Yd>`YS!CVZ+~HRDa1lpT$QeA)_*-3UPI|Leybq+BKTugnbR zGow8cATtgC9UFM4>9i#RFV#s7t~_G{do(xqX5gNt6o$~J8L-2{GOx1O);1jibJ^D98%gOq8TUMLFpMd$&Aqie zl8Bz#XN$rjSXrv0R)Dp@LZo%#a$nMG`RpM~>}7ZWl&MMpFbCoy6E}$}*YPT+;Jym- zt4j6qYNBH_eAI32xudnb#zi~iflIV9+#8A%SOw79k=}e}pSHuOt4ZfVH~T)ka&-Jn zNmv}-{!;^GQ+PjExqLK20D6~NXROgCCL~YFR z6^Rec1!yP5l}+yhD9De~x+$dAh3pmstlZ##l0AYPrRH;28Zuz+_7qfCkqx~a*OY(w zid*KqhSg0%SwjY(^rQB9u$)S7UI?U_aB)iJ__kx~)cxy*f5x4g9VPaL26yQYI&DNVYzBNP zIbnDm!+PO_8siqdzjBQ!OlyW&Q-%6q@ZA9?>bYUp=1lmWZ&E%3pvo1T?Ivcc0=5J} z#+FNs#({i{mPG>zTbOyQ`lrtDJV*A-cxv!^05#m#Ufx4&s1yTf-F%F zihs=-)Biuao?J?kKoo^w4S*Q!mwA6~yGj~QFxoA;@0ZE~ZXXJ0ynk3}IE95MLL47* zg#rQY9~;3Wp_rsHz%k>o(S4W|Eb4huRBDi(1jt}YhJ5__|0{wUzlK*y1yKe$%=qD` zC@}#l-q|ed(Wm1F1GYcWfN&P}Xe>%oa{S6k5Vjo8USmcb3NWfN>P)gk@gJ3^r(uNh z?A>8+6z-A5K?0}%Cvp1OJ!(x5igbOY8oL57MTHv#KuNx#`O_T0dAa()?rIpDzk$-qH9;DSUgH@Iq~Vd3j+O_O`# z!Z`2&Aze2;nk8Z}2K%qkxy1SyF_i_{NJe^jyUE1`Y+_y!yEOSkI1`vOtd>fkX_%9- zI*QS7mmF4o@>W8`kJ)(=ribv70^~M%j%b74ZhukVA1Wd@rFy1$a1+HK^;32UucKut zRj+f<%G1mNIo$v+!z?8L?Lu(m1M|1Y zU)y3<#jX$_M$)lEW@H*0I3$Fpv!tNvfQ=5RF}%=MWzC2r0}H3}aH|He_@HoxuX_ zl@qPne1utUj9R5rUB%W%Lhbmu<_&#W2FpehAPAREjA4ZX1V)L|NJ#+NQ!2v0PrS4U zc8A~uahnbX#QED~k7xJcqo3M*;YN>Py?_vXkXF?x+s?MXcy+>uk|53bZw+~fKn&FS<040JMQlEPSl4TvV>3z{&r2 z3}=WnG68^8Qy*ZwJtnQ~_aS_!^(2=2#C{oG+I-T?AUqV20;S7zP?;$DP zGvlE;kef4g7PgkIOOZrJIHQu>=FYQ`2;aE6a>DT`e{5I7SOv)l)kcvlT>{VGCd8J8 z$el8`+D5o}5Mag;peeID%AVxk3Cb3vMkLup-OLZ$! zu9ewiP*cEN2?ZKPte@(G*;$p%J{It&(#w< z()%19JC--ui*i@N$<4)!;n=>_6{?hX!#~Epjj0jRb|SBmv4$8MKqtvC#86c%^_3YF z^H4f*7iCZb`aqeR-Y9hl3=lshQz@sEpA65G(C=%X-aM-7&aIYijP&pj;h@r6!dVXn z?*9@yA02oXQlc0jOlOf6R@s1@4H2)JsWR7P$&(mtmNG68y6RRuDmj_+FdAzvLr&&x zQOv)17%^&F43Hr@$(pMoR6LKJ&Ipi-pJN~6Ja>4^w(=iN|B!aP&b;B*_7$Fu--FgS z-Xb;z?(Jm!743uq=XHBnKWsq|YK^W72t1o*mb#2jqy_p1W57J8lQ~G3M5lD~*0_p4 zAqBz$L!5#W8_h^uNj1Uq5L6+cK5aDt$Yea1)?Ab2cnvAf)lxW>C;G!{U=|cSB1zM8 zoryGzZ)?Csdum_(J!|~nCmJRKx?T;G$1{MY_-di%Jo`&R8|EXKq&rxeD!%E|@yc`R2f*QRNLBec&W|97cbZ|RX&8?cF>_9sDOvTv44JDT=z!>K9?E%00+!Vv~bczd#6 zIWP*6nFd}3^H@9wbQ7`mjPCWtK~t!YCGcsZ5qlHrf0Fz{pm$4|AxYB{&y`Qd_4=)} zU3eUDkt$VA8|eLNQ_IsT2~9Bje=zXg>nS`toT3b_<*RVHdUHsynvT4x+&To%)M0J{ zJ1Dtd_cwXp4i?3QxH(Fs61X4bi8?=kd4e#n#mON>%7s42;F$R0jO!*lkDYYnl<1K` zy-d*;DQ~i?UEhQtq2Qh2Yx-rKa;`4O&vmx&;&!virQ*Z~Kv14Q9hFXtG>IotnHwve zJwSZIpj2^yQImv^UW)C)excFv%A=Em0O#<`=NsU>hYTO^%2i^Sd>Ij)WCqk%#K|){ z4}bhzf%IMaRVW)>-RFI7$J6ic*i!fPd2!7Tj<~hxj|-ds)9%(^XQ(ILJ#ECA&wjhn zbZEf_^Dh%vAE!pA?fW&z`)*n0=!^tj5qEB>O4|5sY^R2HNgNs_Uy+#XQ0Q=KKjp$ROT&q!F zefAApIhPu&9c3TnYIo8k{lEa)9HJW*5w6;XLp|~QxsbrN%a>DBQ{baPwav!ia6j{V z1xBXd@>FJBam@r(L-lEfdtv2Y9MD(3WAmvC`$to7Q8oK?-y$&5G_Bz_e+6`+_4P(RWm48X{R>oVGTw8>LYE(l6tW-1)}U zkrPf#`QuTm2omrG;$Q)8Sp8_>;Z8-LEOR*~+`;`x0Y2>=Fh+(*#*lw6yObkt4p7l@ z&u$$%Sm=%>_yyN1vge8Hn=6-)6$MyO1Z1s*e}T!yfAZx*^>%6vXshjr=>fHwesI(6 zaciAUwGc|d(9^-&xw=2`k8AaPWk0y}>$322QQ?i`*vD`&rk{MsuJG9KDxTPS!*(pH z;`)MnVbO7gAi4)eYfbhjI0W zSu;`8T29U73~L->zUad!L>_U(s#`Hw4%zbC?igerHmyn&$kumvDJqQzY##sVMpbQ( z+n`q|G$N95mV~r~p!sN|0$|%CZ2+hRv9=d`8;pKv{eS_vXh;vYLDCs&FnEo)}7jJ zlzbcV2}pHOCc{Ye=tYBuLXv8j9_`6+-pXIR*6I-KpD9#GsjC2bG!!sOCr^q9X?;@B zg2n|sgU8=Iv#pcWb~s4tkSwA^w6Bt#YVkeOI>^*lO-k*L1Ui~HMdG$jFx}o~!|_kB zRQ^(YK1czAr6_|n=h^-(cRu^cF=6`OxqxSYr&-a%T3_Xj&UJ9CCD1DXo((xBkI6EY&^wT_1%$M>o97$LK*SSCrpI(q zs#5qw`|UvkIADs2lb-8b!+-4b*2;ZfnlzfgRnl32r#XaS-l{2ZX|wC&E9KKj*n@;l zKNod|a=CmYB;`*6;B*2G;Gq@{{5{z?T@A z8!|G}R3#VFv>-gb&Xnl|diXcOYzUWq8pB)GSr^^l50*xeNi zM3dA4Wd|Uh58BE&XuV_v9{cHd!f3E27Zot;kNMA*?0P&Qa37+uzZB55a)Uh#@Pe?c zh_n?3X-<^qmjv+#Obh6n_u0&$7!=`r1In^s++gZ2%L%xtVoc$4z)v zTrk&_th&f>Rzn5wP(U8s{bX@1x&25D@`2X3-;3tg&z^y^03a1~PUPoA6(*0H_xk4{{cfJE((*6JLUo0&qmN?0VSjuP2(Sr36Y1$Btel?ietuac8v*=gp!-v6QrNeO;q_Ff&Etw zVl(Pfh0|!{TN9`Xqd-ge98#uD!gtJ3+|O+gz+sY=Jly&Yn98ik^&Agt7XFm-0u)fE z%DA3g`V2rA4x8REyH|g9{-Av>Ixcn)wHFvT)$tQ1ttKbkT0}y;FND08B9o`i707B* zK{Cv!Upkrz#ZUg&4f~m0d8an6czMxQ2KB>%d82Vp@CYs#UyEd!3FIyn> zH9d`@<=C1`^v+<~vamKcc9{wZKOF02m+{#A<58dutcDY!Ob8K9#ad98QxIF6gkR!w zrHFeJx#;7+L-ikwISh<^=NTz))xPq9J%ttU0~%fYFiQUCTff?ZRHew#NA+r#9kCIy zjel38REo-(SIu~jm|vZAYSl9|ia*tI_IDvT-m=q0Z~*og9$2{(d`;Cu?UWtyqwdeM z{o4Op@pG|eGI(WY!G%{<`Hfo91Y1b8FaI1J;DZ?HOW`aYy1C;~GgY&N)g&B~fMeA7 zv}EakE&~qE+!I(O1R-_8;dt3STK?|usxlriI-|mUhfk0iWu2@ALBM~0+@NjOToaLD z>ouf3j@wTW<$WBzI?|(@#)drs-WiX@nZTYrQwmixO4-~FxWp>Motz<3p~Gm$?a!U6 zf#)^|avzzLL`(fuiZtVAKCpFxjBqB_Z~uEE`+wxj$81!Bl>7F;brJQyt?FGWH^3?A zf95mH3aLQ89YUPs0}+G$K5D$K{9soiH{B+*Z8?+4z*4VO%160F)k1Ct$AHh9nq9F9 zgL0BG-RFZU!=5KH1Kk4crM%H7WR-xFi1vAYk0@0sYvACMS%vl8Qh*dO9EnOolKK}h zzI8j~pQle_%+XgKDB4KGps?|y>$^mMHR=fHprsr0!36fULKRpt&i?JeNMh9 zBlNt}{X}oD0auAnQ>}@peuXWg>do|p8S;Ti#pDKiX%LLy!|lmS9>`ma6A_f!P0|pI zl(%=L^}X;m>KsJr+0unbJXYwr(H>qk}8ByMoj-XQ;;{(RHi9H-R*L{ntH>&WyiyvOuc&9JH z>9$>y<8KI;$Z%Q?swKU_EO|YBRBgKI>>t-UP_!}3o0*t4enzG>%S5{`1fcDI{7k^F7xU`YKgHEKsWNfB$RVCvP>_JW`n z|8HjvD&r8oT&T2Jaaz@OP#TMQ^PWeQ(%#{(Ac&!+wOE%>ZIi(b;I8JH|GRMx-R*T) zhXb`gd1i}cFlU|exkjx!$U6uR?RjvubE~@PFXD>IY{l#6FLo-?Aa%BkP{-> zC1<#z|CPB(tvbVe3@Iq+$ZKp>vsT5u2~#d)YenmX0c|Q`kbQR_sR$gcgs8*NoW+>8 z)e{~9o>`Kb_P=+ynSv9ElgBX@%O-SpCwkHjRv>ZHk z&0OyQ@I7^-1Rgyas8KQRqbY4t^>lAE@2-0mzAd3={i?(V)bl*0*xZgu|0<^x5M23-zRS|mz zwqRceDFAa$Jv4t0=6*C(EK452aje;JSYf0?Ve~5t;cxK!S50!wbHgE`6Rr+lGjkke zc0mh_Jp;Gp>UAL&EgN(!XWB+VitPfnC=1U#hA^&aw3?#re>=-M#)I7E8TQM@!9D~c z994w?bOb5dj*MAl%b>?M|InT61!df29MP!b+|#)loU7ozugUtU{FIt~vM*( z3HPe(a52UM5hsd-xLp2SbVa(&O$`O4Dz#+{afRKXvy{loHA*a=#vlD`D&=dy{12vSX%R5}8!E2(Y1}QjN@`MB*Op zHuy3J_OE5&zB9SV6S@K-W-qh0vzf*?$qgg(HO9({nCKYGsW61a4+nh%Lni^jkTuiB zd^E@st%i?v?7_X&Ct|Vkl-G1Tj`{Ub_=EsPSkVeO3N_6gF1{@y_oVJqEiWaoRTkB0 z;Sepn8#gtb33HS3>8wP%1Y03^=(OB*)mO!-M_#0BU2&KXqoHj&Ex{E0VATrX%`QP$ z88+m5y9c9xEc3H(#j*VySh4mc+En>9M`ME!=Y`3+2Bf8ZF5S|r$y5LC{$X+bV``yY z>B@pzDsY{X_9}M{BkPRysEpmqd|-p3Y*8+wpzNBp^YRnz>*muI7#X>$WC8b?To-)k z8JMF-FEpL(oM?E|m>H)zeNw6I9bb-VB+8gWW8`2k0&~3oK@JD9AydG2>ENM;RfcQI z1FjZ!`&VIJw_eN{Gl$bSQ}^#!KO zZq7mWRjR8hv=n`fBbJ|Do%#7TjFR?)u(UZ_ZeK<{>Qv;>sdTh*-bx1QpG#23O~YGU z&yW(8)wEfrO6g@7gaNAvJV~Ggy=DZf+?>dv<=>ii8{gPsocHTfo8t3dn!+s-*I!49@=u63yWAUF_9 zWvXvZ=`GB~=fA;h<>7RL&Yj#u&iZwOS7Y)Jm&mV3a?|VM;3_Sbnm9qI+=or8`ZRsH z`8JsfTxuMUMS5O1^9b#D{*+v~yn5+h=LY;IT-UE>)LU`_>bs zo=r6cf3`mODb;rarJQ?Iuy3{8uK}>gz{yoCUWtcl>6uz*kd1g8p}c)CtLJKvWO=IJ z2CW)i4WG#~NeUwf3qWvF{|Sk#MFASPJ9fVZCv$HnYGP(C>i*ul{xhFwmo^4TZzDmv z{Q6tJMbU%6`?+$Ldo6xn_A?i4s17DyAF_MgeTr;C&f8JtL|luyb9%zb?K0fc8{3se z`xgO?4(TiDGQE`wHZV^$(uvqdr)i{w0&IB{4y_8_J2%Xq?*|WFl7S&)&KB#G3Ds&9w0&G9`;^~H0&~rgZO(Y2b?;s4y&E@g&e%2vzU}Li z{5{N*X>Y24E6YDM*avbNiLsvqp4Ism8h76wm0dL9$01d19nC3T=!{Q(e00iISk@#= z*93L`ZA6BP5?L*Me1OkjsfUVLpRQGgZY3>Bo*(yIWF)zd(F~|k>8TK19RQqHg!5|N z<7~o0ZYB=d83cG`x7Y{*4OMwI${v-vQCY4uhT+GVc%O88#v{#d7*&dWW!N$hR~$q! znj?rtCcPp9vO{ame;0+z3ODq)Oa;kOsi;(dvf8zmrvTgEbbcZAXELQawsOVw*&ncJ zZjv!-WeJ+Am?OdkQ6I-oYJjf#hWCRn)cbVSn_D=YiG>g4O^g_eIE52Lr^ z*KsAkD{FBLLVJUKkX~vfy+E3ySO1Z<>N@KKK3I4C$`+^rQ8Fg8VhwK)^ad9$DEaIp z*rRm{koES1z_(t?zw|4o|J$kW^uDulrMTOEBmY$6*oc4lSfxb^oS}9DQu@xGWsV71 zkWD4wUe6I>DJeAf$veT$#5DTuk$Io8&5FkNjDX z2m^?H?^$YvQh9+3(MvrP)Pw@BAenEwj^MnFmmvy>Z1>!|qeTCtGY-%IxKy`CO@x#W zD@fNusWGt>e5Gof_=7tyk+$u!P^lbtz_G$bPmzh~3vDF>bZNG6>)`qs|2g*TTDg|R zBw4cttAc347wFvYW+Gb4*5B@~zyDJZK<>Qv`}}*KdF8)yhFtrm$ICf1AD=1H(J0zs z$?HBK5{{Bhrj?f_HPHF&kdX>_(y{u~UE_}q$4Gn&>(uZ_ zC`@J8skA&$GkIe)wP)nBvt}3!kJX5AJ70U$Z+!b3lGMGeet0N(NcX8+Yxvk;jHy_C zYPUh$NKG5>4_T6oZVbEu_n<<9GpQBN2Or1-PQ~yiQP=3R?e~RZ9#lnD;@%RiOtFMF zkJOT-%R+~b(@$@t`usO(8HsVD4Rm}Qp>ixnsa;cM;sb896V62=rUZ<`TN7Brm#FqL zuP_78t<`b1Qzzs2W*f^uNyWJ$O9NXW>sH_ z_$KSm@xI)g5IM;20s>=Za03^J5uN{o2YKte6}bf|(JAoKp+nLkfkr2s%Q6qKrvpPg zy)!hhW(s!QlYy^tUJ(L~L3gq0-+!fLXZ3A+K4IjVp=yhV`8E5?++)SBYx=FuyWjz% zLwCcv^xcbVhE}9z^d)NG&YF&7&G^SuN?ov3V$wa)`{} z!RYNNHT&MkKQt^cybA1em~|o^&Xm9=x70MxG181*Clg|l*{A#=0d~}+GgT>Uhal)l zvM}H_dAL;GfHj)AFBouP>hC|l3XM`F=E_%uDb{sYl&Sg1K?NcDZka)0_`oD0CxBX| zM#g&{=D`d|Vatx^N|d^vOh}7GwXyj7zE9QoVk8p5IA_?+9yv|tgH}H}mAB9XVYT%ps#WcQ__PF;HUoPgK%$SqM%kgVLW{V|mAd%T)zK#2JvqjxQj}mpXzf{-h`uSD%(&hSwmU+q>=u1aqQ4 zie>I?&A{ypoqkpjpt9!p4W~;L3HF3eLVZ!?UZrsI6}wzZ9pAF*?t~b64M!)L=(d;* zwEP$j23iFK3>l;w+oo+>6fIKqfn9OH5JF1rz`!v=wlXVB7n$13{7+#<2K5lRZ9ag! zQ7CkdR2MPCxkh$Ry0j!ljVjNe_xtXc8p z`t?T&B2LUsk;UNy8_@;-Ba`PH&cfFWK8=3t)M@YC4YM0s-d))F93myAZ^$_*Uh^)@Ka81S!daK*gp+}&tgyz4y38w@W%Q=7}Gpeztl?Fpm`Nn)Z|F zS47JH<`-1Hys)V6hWNZ$YtAqav&yYnZH63U@T(Vh>K|HT-N;juA00ds)6}$%^0EcA zW+uTN8_sGKY2XoP5TBH~Mj1?#0hgG4uMFHn+3Paq*|9ZHIHxQq-6jJ*f_! zQK6#nKUPdkCRcE5AnNZV8|!b07DoN_^+ljK>r56Z&n8DDp{NtAS&hXD34$(2E39E+ z^|r_dCgsCZ)qk|0nHWKafv3W9VIiBO$^C<`$(ioWNH=}p_6)iS#28BZ&cHO3MVp6Qc?h~sHjylm!O6h@Uz46$U z>$Vk+`nti0K`RgI_m4bM6GS)}{;O%%hah-nfo>Ak4QZ*&b#w4_XY^c2xukOXb%WcL z58Wo%iqV)6(;Z-sxoocK^ikRE@w|shsS`%&o<$YgrK&@}QbRs`a$r0B;2m}3K11I` zxqw%s|0L%7%(YKx2XIJ}C}!+?7QV@T-}45e+zyPzc2-|*%7;?Ow625ajNiw<%xma`CB#X zPo4G7w?jndff9u1;Xh(HbH9XqZ+e7ywRTFs)+a{^+k84$ErHl+yPJcTET{jIQNOZB z^Pef{94X^4LuaAT*R*oyVt>tryv+B}{k{^mHC|pR1X)Kg{5e=HAM-I7ytq(P&uHva9<%TaG?P8N#Ebh(ft(ZvABZU$Ryrh zb14hEGgsbKYnZRp%?ZLNGgy0Qi~0ajBbaMB>q?voni1;h#!`51sbwoi^8IO$#iT;!@_WL>hIm7t|_rT2TR2lNyUHGQM7m{le#+OG%p`u8(P1f#B5f^s4zno(muka%sq;N&r6y% zI1~(BW}vCO2DjqpC{DG1M5wg*d;Dv zk^SR6k>7}!m0=iO_3g>`imeG-LM#`$xUlt7kxtxdwu_sGx=itv<(X#`ZsP>*Op<%d z6@FQ!hhfSzNmIU3b)Iq#)JMQMn9s@hQ16CYeFcDeiIwNDKSc4ud{z((+$(viZ$#1M zeg(_&;ZznsutoFTM!V1n%#W-QDm<&uG88LlHg+@BgI|It?GW0W>bys({z9(Npw#7K zw)m&fs-%!#P6UQr?ch1q{=0jKuUoiF=L8y^XImLlJ%Y-X2jyTetPST}3kPSB8&=V> z9Hd-8Zh-PoM_Qk95_MJb2f!uG(^{UFqlj5wn>0NJ;vyr=I$FuO(Pf~i=$_PoNn+Hp zd-8w+rP(DHWb#B1n`6|P8IJD))&d@o&bG7) zrAVUm{}V}Dc)vRP;P;#ax(a?ScCh@PjV+&SIM5UpT_ei;74tuQ;>oRe9FFJIp-7bX zbTHxqaFB>ACQRgskgx4{+%w=&#DwxX;aEt{I-t--xE^8{C^J5f8E&hboq!IX*ucb9>g6vo{S^c`__&(86`zBp3& z&ab?`bDo<~DmPulbyw(Th`{B2Xbhxu>VkM(G#64$E|g5RQ2joLGHcNq)hJ-CIRU3GoyPucRhRDtml27~T(0yfSu;T`b?hJt_-9wlD!A}yEL=obCGVJI zMx5h-G7Pqyl&FRkdBo1P1JC`w+D><>y?@l}SnyH7&iwa#lPDx;``nv-Kl$a-$Hl9;E5@wB zT>{kVylxL(F?3o~K9??}NX#_|h`1ZZA-e{9D>X1tggX3G;EVk1!B;ZI#4}SkKKi0{ z{rq1~rn;S_*#5P`ob+|ka@+(2{+~@FwEU|qklQvHR%f!$-Gob8ryL-3Umiw9QjaI! ziXpgLU7@h?8tX!b?>)mp+ad}(W-i=+VxIRjY8?*Z#*KNRRqzeg^f?w$!z&1w5(|A{ znvOk$YqtGTPZ{&1 zvtB$pv)>6$s%l6)w*8DiUE1F2z7*7AAu|xg@Eg}1zbBp%$W(sKjXL!jb=~U-LQpIr z$`b#%((nL-=z^Z(`RF}g=q0Wue<6xIW?jcYIAb$P$5+btTky%$33nWWIpgBC9W^OS zIW6UZHp+-;id-y(>&Y}NGn|OJ|E}gzfIl4KNoqZ3gsvNk<4i)|Sc?uA5u~6fZE%0+PeuiD~K4(xSAw)+C_hz&S}98zhXg#h)XJ zmdqh*Ss{WFEE5=s2GWY@>Hw`b!%vU`n_K;G1F<4U*$PTaD}O<1Z2g!|f-DR87%gD! z$%5`SL-lbGD_Mv;XJp4+(<>`+Qb(MWCZSEI`7!DaItBpCI1l9CtlT0#X z?S?<16C~6r@69P_-P@Fl3@dNL1t3A4VH4DX|QEZ-*bhswCcSBX4x-!wQu&0VcFxF46y|A|d z|ExjlE^U~gUf^&kDGKknSdtnwvyO&T>ZT_!mZQl>e8SjRfwyh>3OOyq!J9<;Z`K^%ZqQ zFC)~@9bRu91Wx=9@TyF~K?~!E4t4HDO|9qk$nTSNpo7jd&j^Ez+TWv3zfMco4|rvO zwD!8QP(wYk18=Y=*OO=<#n<`o%+shMR14SI?)X32PRSgyNn7 zhzn6v(Qk~GtPZ`EJ@CFk3;nyqKw_?D{*P$;($f3KhX|O81$dJ({KML|Jck>`&!oc$iBj0 zHNru}GPwZ~4~$3Onh^a8tWf#=LS3zl+rM?0MSc5|tk4Z=rpMG4L?&p~f*A`&XpYd1 zkw(h2UPh;!4)!NTYc$U_UP0*d7pXSpP|x$U7I({pMla3x%ADc& zpt$(1HNF@u;WDPempj6%bA8DP3+}mISrNxHf$* zZ-C3MGJfn>Y7wu2a9rLzqt9rY)nBV1)xZi+RQf&c{CLN0NYviy*WlV;4`0~#-g~iW zsXsFsS2$NtaoqkLEsx*1CsZy~PKRZku5|W9lOq?7P7?nka|@1{{JhvQraUs#g7}BB zuY`IXX@YguU7>s^g?m>Jm$@ZjOsrLnk0T|mkpv>PBS{6n1KTnKY*iHJJwYNZ zykfl2iaoliQ;+UzVy|ROh!@2>25}Nq+80Cw8b8HlA{y?^1dP02UHC6cM9FQ?2!N71&wx}wOjcMv0&Ow>ZR zIehC3C0z6Ta_KR7FyY9BeO|`95+(sWL6;qX#T)YP;L08%unpx6UGgJX zf_HQ>$8IEbg}k$SNPrZrv$s6ax;(r0q^(_X;uBHIaY2lmqGXpUB!^%UWA`+LF~vGn zVZ=U6Q8zuk@QTDW`9Gsy;C`Q?8Q62`akN&9>z>uBka=h~SPDc31-TU&$l!08J;MVp zm%Dxno~4-_yX^4AgKnVe;b)_a#bssTNu<0VC@9&I)c?09T7LDtBV?kN2(6MUw}fD= zwgN#uH%wL`P>26kC!nmjQOmzCRxdpH2Db}1YlQ*E(Tq8|yFOECFYp@dN#*nsM)W0W zMCa)u*^O31E)$sba+7^YHK7Y26|~Dj1W|VCQUe)arEKAb!B*+2jSI8`KD%;5P;0Opr@y3!ZLrkmV>~Pq-;! zcUu$~SASn?sJEE@2yh|*P*nmQw)bJBuvH}6XgY*Ph(_z9)xR^j)#4B?VL=| zea`iu1!51Fp`*itFRNwpTg2W!vwBhIFE&h$`{j6|5q$4;zV}w2?VDQQ`7jwOo7YYm9azZK3BCvnD>U&m&JMo09{3V}`I{r=~e{rnjS9D;=n`Gl&wU%1H5J(W9l| zlR|QoZC~&ARBL9dzX$HaL$NiZY+>f`2 zSVzFxSLK7#RVas6o2Y$~K-s!D_>)6BOFWv|Iebx--$(^-{PN6%lT&Wr(=d+GHEkXY z!ep(l?g8h27#xOj@()R0M97sIqcibRITtDEy#8+E(v3JOsBD*b$8p#UJuGtz^M+Lz za``?0eRUjR(`2v^nA1rS+70AZVW$OPp6#zU+Z&}A4YZah)xpCIT#e8eq9eWyQh;ow zaQl7iT*2hmSOBZLJhMJWy)&o?VjR+PAm?oKu8CqQ7GD$lTy71Uk;BSetl$j?=4ENk z2X|U{YmIb{3Eo7sh*Hq3%7Vb%AN$OKIGlIYmtTR27&QHOY}fi&Ga6;*CPguqjUvpCzqqXGBlsNq7i0Gr;Sc$9)H%Q^Cyp+Z=z$r zfhS(FrYJ-Z`W<_D(3&r=FFEvk=xX3q_2sZn$ug0iGMB&?(b5q%?qq+ku%Ke%1z_O% zShM@^hIv0e_=B)3DXYI=!zaz3W!7YDcf^q)>%zJn@=Nb`JgYYyyV1!#XDYN8V&EwF zxQrPUIjob>HHR*eGK)8a{hWD3_jpBCp>N2sXmcnZDJDEA7p(W;uS@%)(uChl0q%h< z%j-oCqiL4)cm%xI!w@J@UPspfDiNUavA8=il4T4wZ65|Ngk{t0XLp>8vpyB)5&h7K zA3mIGxQ;nQ()K%WUX=A3tY?;KoKEeN!=?-RR_Q&hmXVJi`8R`2kwhZ-CEf+XlAR zOwM|O+TVaoVIaD1;Ci7OTW}MWqQz<@eu#~__Zg#SwqqC^W$DUHNH?Rqgp*c)jWRhz zaZ-o5gf>0%I_DUQV!?w^1lw~|ne2EUPaaNA)u$C_8qu(+OFVUq8Na9HXKEICQFL^m z(x$_)%IeV4iGhFWw5V_;pn?;ThAwZCC|VBK_Lajxdh_;f75{y)0j1Rm=A z{{tVDe0BM@l%!~@MJjUN#&+9Wt&pUtT;)t|hS7FNk}VZ7j8YWJmXLESMT{d!nkJ3= z7G_+-82|VC{h6Wf@Bjb%K6bymEi+^0^Lf2rujloG%K`ahQROPAt%B~cy;0zK(B6P* zn29gwP|-UC@eF}8>TKC5&}(z zHtL1p1+s`7AQv)%n86+_kZJ|BQ!0>i!CspusEg2Gn(0>$uguZ^4cU{IzT}3~LvYf- z&L0SS?}O@3sJ}8_-qjJeFvag&x;P1t(Iz<~U2xljjs}UG5KH(!bUeHwMR1^~A>QVv zkY2#cgRn)M!cu(B$QYzG(a^pTtrFdW5IKJTx4+F|SsQo+hzFo#deqQ^8no}hp5&4g zU#!l7N5f&SKBWwXp<(M}By&xX;9GS01}T*NDCDghjv&az4lP9*22S!_y?nO- zP{u~itS>J4uo@-W@KJl1gNDkPOa=l%-+x071*B5DV4;#<7Zw+xVP$p7N@Ar6WVA)$ z{`W_hT>*!kf^-AD*|0Z?u2uk&tZPE1klr-B^dSZ7SIv;VJv?-akS-U7R2mO)w#c8bQIG5iwN&I&jxp8=Ts zb-2)oCQt#C`$vV-1-5>eVC)3LBOXIu_Gm$;ZoojpaSLhaMBNQ(ew|R*og@6U9i<8k zA${@(lz^FU5r`%n4AlgPg6O}CjVkO3BoL8dh9c|H&TMQ^2|IgY5}1$$AlZhqu-$0} zmp-Z^FvkZTy>;N3e+ka-r`awZ|E7zg(Le}mnZS2GLpm9?tU~%{l1|iI z?%xFl&G?-eYETyB5{a-EThuTirP~e|Z2|^Xfrt(^Wgh(88Gc^~u7sRs!Pp%S*ZnH~ zgd=Dm!b`A;2}TEF^Eoi)3X*Er=;KE)%>q4zp4R}CfK@(IYEbuv;DoLCSD>a%L2Ro8v^p(TNn{_F?0a^?E(i&+(a87~Ibi`fizVfJ z_+KwM3hhU}P1xa`fx-rZMLUMb*2UHv+ua7M1VBciQwv-^D6B>pqav%{nP72-@Y4q+ zHx*VLXszT&9q@Nvoxphjh%4P2k}Wmb0b>+&)Hpxn0) zwwqczb1Up60p6(S!%ah^44>Cku^mWF{&m_{3;ck^M1S2I7H@`v12=Y%WaAedI zgJ^S9X_H~h%kpcWSR$sN4AgkgnBq_h0PO$v@W~@k_^ZGx6#;*3Sa4rKHv;<3J>VY% zsW(fF@Lk`*R6XVgp7ANL{s8kLzpv)&*;F9>J%i@*BmfH`H|KribfGtQ0;7Fl}NDw z%|;p&J*#hrS5iz0y6Vw<4by2>i^8;ta0rv%g*r#naokw*#V{Ox%QNj-u@sRHqICGG z)(gS5H31gPnXHB42(3;P;DdY!4t0LO-U9fAQfbMd%LTtHSOob0F*l1cVhi9tI0*q5 zhT<5&b%*KvU^0||IR|4ie|}Uv*e(&tT;oR;^S(9f?=^ z!octknyJBRAMFJ5_$Ar^Qg?W3L;PoPq{94DWoVk+fkNX^7=eIqdAJu&&j7>|Xf!vq z_}1EkknayV4x$JrUwo+Lf1zR~fo@5do_!6DRmn(n_+Qs2BFJqXuAh5o5UAnF0I zJ7Ns@FqF^aZZJRfp%qTn!*H@*eC%alKo(@;ph*)tC8V1_yzrgdPuy$-;-P$J1+B=G?1H$yhO`@)n2!{bl8gs%O>Z6gYKLL4U_;)6&aTEtqY_4C0NZd@$93ki{LqSynwQH z7#;ZlBErJPq~J9Vv3}!B@UGoPkrUY7k;OzB1kHdaz%JS{SRt1{#WQ4d(1sge!NPnH z>AR6!75?5!KfeId#S^HZUAW4ZEhtdWq8=D&hp`;R5KvNKcYrKi1=@>tR3vrA!ox2} zEm|I+!2`?l1(nSLCvO4DAS$#=!0}(!Xaoo*sit|{=6InLSi)kF`bYLWv*R!S{SA+g zpmbsRaXEo+0!5h7<+Vskj=Q$lUv!xSWf zT8C6lD~wQ^D;^EGg`XPPb*LErgG^c{@=0h8Ij0DoTTtnj z^uXee75Or3qXx2up=)jZ2Gm9&^8XE%;j!i}Ix=T)7UFpeV-?){xMksT6uKZGG!79^ zP;K;#kg3cqRR&8BTB(t zWwlt(P!q8eHp@>|;x;2k;2G@(+vcAft>_Q8f#wRz@HXWyknih|l?~j-0_7kmNrGEC z8q9<#;5!$iR)JwKIziQ~v}7`L;dl-g9idA5u zTY@6bYSO`tftVcFTdamt0)Pdvt*)R6-2{(_-4$pvoRNPDdf%4~^;HH3Tm=}#uciRs z%!B}}hdtmW7UxqlkVY=Zv0BJgSb}azGqg5!(YA@&2?>-avw$=#UjyDvK9IH-q^cjw zv5R~M;a%{?U{Wqn#RcUJ#;n*{HYIE zoCj+njNp%K8!4&y`13Xa{ia6_s{h>6v<5AZF&&quw zAE5qT0ZLE(R^zZc?x#wpyygKcs;F5%ej57^X2l3B5KBP_nJ^Ax*=KITz(w++g#NVI z8@O*2+y+<$SvI)X`mGe4{_>dE5Qm5qB);-N2_`j@K-BsS?S5N~l}K9I`ag6eUj?-S z{OKV~0d>Ylfb}_I#*GCzGe{D^4t8uLGsFHfM75ANP5}jvAlr5S*F`&zHl*k+X8y0R z62#U5h1)Yd^hvz&FzdGM$9Y5UbxFpB?DX@Zjg?Z(Sx;fReid$^I3P3-4grB{sH=q> zD%9T<_AFEmJ&ncoMtDeY=jdL`65Osh%zX~t%l~m?L7l-hEP)sl>xU>4bP>x8!dgKn zOIHkjBE8SgMDTD+ASNn+fEO`b@Tu^Lxiq*UWabv^eRE-2aS<5APr|dan$$awD=Mr4 zJ-TMiLTb*I#rk>)atUD7H5e`za?!7J0;>`xzP+Xa$42N!$q@LRjFBDn9NcLQAp((G zHVf}R*b*h+RN#MF*0~s=xdIKgCH!gTPj9RQfi7Q=^y2~?#slzOfm<;$7AhJ7hBhM5 zdC#KY41Az=3w<>5$SsM3>=Yc_(IK=N1>7MlQkvWhmsBlBQ(kluAdW9L8=*WP2$6V$ z#wV07s048JbwGEA^Vb4Ea}##_Y}_MSl@8CuOaGV&86i9|1=g7*;C=lsCY8Jf8*^Pm z9tpjQ0H1TXFAgnryjcboaACo#7{g1F!u#H_%zz-<`*9d2D5Q&FWLMFg49?9h&S;T3 zS}c1h9t_V=9Qd=+=q@DHC7`o*8~7b8AC|$CDyVD`{IxV3zC1L6LuN8I5;;|Y>K=7| z@XT+4XpZX7MHr&0vMf8;m+&6rW3!gxzXtIBR!58nn6m}D?Uyz|^^bz2csM9c6Y@p| zLPn@7K?lO=ljwK6!LREN;cR>9G;9T*X@lfHH0xr%nV{6_4j5C^WG^ipN;7e#odCIp>)HaUaztKjG{k*=|TlatTIpu9%~Qk56@w|&(bFd1x1(3%36LS8;&~FWg|xD1%+Dk+3Sa} zHiJ7|AP5p^L>?*e=L@7C((o_sC*MFCRa59>0>7vL#A4Zj8xmZ;f{`}91U(?uJjb9Z z2faRI8o-)nWQ9L41dB9s5y9;bW>;$$UIGYLTj&B2JSmujpbe8>b#Ra$gbmhSZ`hKc z)&+^`(Ca}%?YSLGodrFvJorgIq6W-73r+CAg76M?D=5onHRc%;j{r;@FyHZO6E-lt zS+nqqf`S0$K9yMltn$C0^D_-;$;@*7h8jN*RlrXxLde@sX-1GIgFt2gNDaZh1u2J7 zTbUfTJ@+@|B%bMZ%4V0G)(P8NTXF!~<8G|P~ z8v?RVa@|g9j1HfBx(BW%T9nj7?ebkqz$~KuY3L?5`19gJP?RyE>i@iKc?dTD;tCa& zi}FwnD;Tw(?N}WboI4&J68Q=ChKiu`M)AQ%?!mmJKi$A(@)JB74~b^Dh93LXOrd~z zZ$3E5kYWq0w=JbAH*hf2!=Vr+K8ngLbqm~5M(x^= zy@@ocg{9HBG8|UqWj_^I8;F+sB7g}zl8`p+Y{9pHuSMTJwt8G190qGZ^@hJdExOkv zkWyEa$*-zU@NrLJ_oj~3(50tAQ3VYnZiVo&PFU)elwm6jmRyF-^=Vjw9yfz*>BIk^ z6%!&E7^n-^!lTl)^aA?+U8qE3of+0~`kBBrj|%eZ!y2d)IQW!?mtiG7qm79Ch` zkGkkoXYj=8&$?ne3R(lD6V@iyB{pI$CB!`uni;*s71A=Wz(@Qc z0Mg5p(65I|su;$e!%YC!%@)Ie!zIx*LAHh;HFy~xlW-*{jc{S+LYSH|Qmg*d9nTm+ z(O^EU+AHC%B+BA-J|u7^t{EctV`kL1^44cQIeY3;@m=3nIEYSd~$9l@08o z(e-?$qXM!P7JNz!Vw>OUEXH4%>0kQYsBuxk4S8Sf|2GsY`fgEu4P=g> zv`k$5nq0GdvD^X@TCj*$0uj~p}4Km%i!=q zvyUPy+$_JH2|vXNuSimlNPiaymWEH?0besNLgiCK6S5k}$11B+rCP}?xtO2`t9YiJ)4!sFml zpJ#2~6fCfaGI?p_txiEF68!Ns2eY8W1T}#QDw#a|OzN8%k$u=4cL5i=6w>HV(ajgg z*IR%Trd)6VqYZisJDz3K&~Pa70qTKItD8+s;)h=&`WS`or{HvH+u? zXeUG}lqCoxSbZ0xTu^EJ9i0@*%Wz~+ups^?Z-!H_5O~h%(J*&F7~bd0Ph&QBGlNTs z;GVv_8rx)0hQdG$!a;NR8wARQq003=n$N+5!7sG%pllNRm;d#$BPFF2mKgvtmcUh| z$20Do`;(-Mp@)kDHzv@*&EN#dq&NfuUczXGOt1^-wlNY#S_Jb==P1k?A&1A7kArr2 zA1t5{pQ4}9MPw^h;tr)K$V-+Uuf{cl;TeQBVs%lP4@+X5<>~dR9o?p$;{-xbPz!k~7=icj7f46C@gu8*QAu6`=isLpOs5EoVNxd2 z|GaBEg=i#YsH+b@2`hVNA83o8%Ki>tSON5yibsW~$XlRm`o^lAsDVUJ>kF|$3&TWy zyp{C=RKEl%@-S>*p;n0Q5{OwcpqFVM_%LG&LzgeeurY-I=uHI<6sV~bUX~$vPe4LA z?7h)-D2`<)K^_S-zXImo7g%%znbW`Xy)yz`Cx%`_T;zsvayqy`p`=3OBuJK22Xn~P zMRo<^4E$abFs%y&)*bJ~xeone*yIO|EhWK)mCwr%kBu+(x)Gm{58X`ppy`Qhr9N{H z#yS3}D(HF8wY<6o^bMHgEE6)3y1;Dn|Js5T4)sQ{(Pg>NYYZ|;fW`IyS`7qcZ4a1& z`5WH>-Yk&I!=CdhTKfu_TNtU73m0u!-UfrvAHGm{`U{dzrJ&V0D3}gK^X~xa;MB#r zTNfJa512qeNe+F|p1@zQ6@yw)pv($XSu#O|CVL7mcqSHm`W4lc=fI-V} z?y9f>Me!<>dG3IAx@*QQaCU}DIwP=B54M+^!huZZ(BJtu^`$R>Uj;A`>`CU2f5eQy zs3`@}E&fvIrCR{lrvQm!P-lufGT#|QHr?WD1|MQeX#NA@WA3(>KnaSxF8DU_aIB@1 zDFc?53xJZ=M&UmSqOe%}ja27oK;8n(>ELTMViQD+-?lBefMnr9``#}JN8}^l#C}@f zNN3?zY=%+2h=3`BKa7)?fxOa^0B)@LObYK*3dlGD&OGp>M&MOL76epW)bLr9plb|q zO^+wxUNEwO1sZYx5z@xc);~AFxqT;u47H%#a{Y36MIs%KXj3!Q>_kl)(7Azb8vWSJ zDsZj{U+F|c_mVW!B!Z_zgCh#J1^YL^R$B2E$i(GWi|#-LOX8Iq90$&OT-#!17x+Vgi(w63pEv#l;Y4+Tkk0~H(FFQyB$@pk{u|~RJ|dU~1C^Hc zA-d^Vto$d%^pKHO@PTj1*h6ElW{J^~dXu?b9}lIZwC%||e(3;a~TH3x?N$KA5zs>uS^04mJn>%pAl z?9hQC5X3CV-@_cF2+H_rguNPAWyV5X$}?oPXfI4NNeIZc+5K!N#R4jtD*Aqbi3N+m z0ZJmWnAwl6`$Ym`)d7|WHyhx&4Efp zS{ax?F|GAx#O&fMu%%DS%g_!fRMSv11CoG1`?k*kT2jWrT2$amh7}BvxoC!IObJE> zs~HV*o@V?_dho0QqA>^*K0K-o+8aP{NEn7M!72*E^uR8-#e##X6b?}#W=Rw9DORIG zxYrLBLNh?b!Dj`4Uu=rm)0L>GqsdGx1GZFo;C6x3h~@9-`{Xf^Ob>)Vz#WK4DAc~8 zjLmRVTSY!WFcE7s!%I*tjY%W(E3(RR4uKgsn3=hPwII0^M-=C0CUo8jbS%(EJRg-q$o>$_zAV znG1(Q$Xd7_!Rm!@XPxja!R;M{w!H&IA77xnl)v~Yiq2<2ksAnr{sMw?`8`MyTy+O; zDPpo#!sBff2rd_ZQ%xC;)v>LN*%4x(A{g}&Y2A$ z@?qCJuKm%2Z8^!s=doa4kXC7uKgf`!o|aA6@xi<4 za4^w^Ot*3}Rg-W}DAl&7qZB{?KhXYP`#;Uh>*AO-FNMF6EB-&Es<12~`S-FQO(doH0}!cod&F5`S}Rf2n8X za7;7r@N{eUuDJ)S?CZ8PH`{W!JXe?kfL?O_*fq9{2WpT?I6`>Wd|6yWg|E;)~c3z5~~?^+)U; z1rCt|pNz>~&mHw%=Mh;rj|<7OXAc`@(`>;_5!5mha-{cw|4X$E4bqdXn2#aCAKZ1r zpkd_8n#v))Dp@dlVzXCf+zPGcH}8*C|Cl^BFzE4%kvginC~2q<3DTh8-U8<9n|z1Y zAabKZm5&<2Wg(EkXQiJCX@g*V{#w9uNH7L_*44JK6v%|5HXA{YmryHwY(cl0ERO(1 z90<$60K1(~vxuyP8w=d-# zm?;Il!@{-DGmZKni!XhkKV6tqQAR~P3J2OHb_^tPB5K1d$w<}+$FIs0I3)gV--|e1 zP_(g@ZUe_2eyqOG~J>CylfyGb)Qul5Pe2}1h18U3czEVV*Gc~X-r6om2e2= zVVD-0qc^Pl0y_zjCh*69dfP2NFtEQZ0*+n%j7v!G^HBF{8M43Q;1d`_JZ>aoYU_rWq_t7L3+djLk!cr%K&LJl;P@)R+Z-&43&5OneCK{a~Zxcr}d< zO_^VS+C?x=Htxg7tbd?pyA-xIvB>6U7%{9jk2BT-B5jS}8btWp2o zyd8&ze4|U6atI-j0C42{Rm@6g8%%M}W99Hprkig6$wo$zBj9#EZVnwFHc$qB92{97 z4_W8D(hg>(!5L&-K^jqOa8*ChLCFL{llHtFG5rsQpQdRyuO0CXaB(|kY03_(E7Bo# z&*KuQ{r9-auSRIKEz?RIo7$j*UbSI1bsV{{=_(d=EX<_=|5+-hdgdvwzm}}^k>t<2 z$xGyo{Cnc-evh=u!bb*j3K?gWA}4N*z2nT1#MgQp&?dD$+EX<*&LsV(a5^Tj*KKY? zgP{kFw=u}8J!33$j$*hwh}LnaOjezUXN!=1DgzsR;_eo69uRvIxPx8# zQM=f(w47uw_BD6#%nF=5*E-$OLlhEM#WUR;kS%X!grT%Nbg z(E0)iJKwda<*%GPqY|J)AH1g3Hjmp^x~Zp_s?oElKat4!JBU!jbFERmnXSlu&XO@E zU#zVuboS<4bFY`8vM!NoNDXSTy62DKw{`4R&QI&3hrOpptahHB&_8fBsYJsvW@WFl zxc1wN4Oxa$|s5x1ctQdc$hrv)RLOWgy{VJ_22yMb4FY?d53+S zl{a-wCH$eltU6V3yj*u*hl#zKOrpX4co^k%;1)nME*lv}f#V$a?vYRMI5EQMzk*G!CQ=x!=7;bD{L5t)blV@nV1XpYYXGQ` zbQt$g8%8(DIx#!K;fVmNJ*1r=s)5o;;E@vFJ+eg~{w)yw7XXYX?Ua`--PfC5t`H%0MM?npcWi4>ci4QaA-JzbgDP#t>Eeg`2XtX z#Hn4Lq-GJ;D2zAauZ;yVd3czt051y(E{(A8K#>nv3W9~%xPpX`o!sk-&Dn(W!)2?D z-{Cwt4%?TcL9QI516aW*Hxw3IfQ&z2SU*qvm^AlMc<4bBG`rDHTRa6%2w^3NWEcah zKIFR6QN2ec{R}j=gTZ4$ejf(KuVn6W1nZmNQ(Ovx*!)Vm25cOk=*>P(LXg7Y(-_Wz zAw4jf8LX2{2+KB1LCEV_?{T9=M8#~EC=-DhLYA-)#ymwCDah_F6aq0lm3bV6_oJf+ zoC2B{MEegC(HdTAgO6f@wlkeEuxm0<=bs|kNdeif)gY0U0SfZbUc%t8NL)kbFq%Xv z*581G3;8%g`jONHLA!xi95I-G_JLWMUs)v~@_-^)r6aPjRW6lffO!(A6aUBBviB-f z+Tf6P1UbtKkyug@JvIaH zgY%MjZndWTx~aY1leQXE8{)n7<11F1B-$J*%ntMfYVpCHr5ty9=C$?HmY=Z?YVWzq zl|LB$`SeqFU%w)@a1D*;agF`Y?kl~RvPNx!ddA0=N*f90hW+-wXV%W+lH$fgH3?6A zsD(SfMoN#3wuC*KJ8qxvwK{(ur``U}$=bhkV?0%~>hsn>rr)$_s)g+-}ihR+z}c5vRrkbd7KVDs2|kX*E6AJ zp;aH8CK-N>hZF;knhof#W!S4o)=M@Fw+@})JuPznzRB+tZP@zW2qP_5E^V-5b}Xup zSryAvnoW0_m7B}&eVNIJZk}kkC&V0ieXa4;Rs*mUN)XK?2hAhVwz^LFHZl`*>l*XL z8E%R9v(`y}o3Qvo@5C{x3@^5>H*Ut6Q|VPC*3E4N*mCkbt~IZSR_-D-LBBdS*e_f3 z;5li(Rlt7|=QQ_E#Bq|Q&yx-(dvP}syAw)(;To{0alGxsvo&g@hGIsdPnr$6^hg(e z)}>p7Hw@N(42A5pcNrh)8|l*{RJR=JCYnwiRnZ=$&*P*bD~H&OvFBX(>G%w#PB0D4 z_}lxwHD@#Caq?8@;*p*h!ysCnj3e99D?TWuLFNKmlAOa#ym+h$zeDY_Esv1cyZLYY z2mGzkJb!C(CntP{`%n*Anc>&;N_o(~*58|WVrU+B;E4ud?OH3fn8%fB+861~pgSh? z)xS4f7nC}B;=TU0scPQ2>F6#lWqU1Q16$7OflomFt6Eym0nROV&b5ZbAe$Rawez?g z^SEc?ZtYY9tLIPde|h0wYajY8{cdope=Xq~SO)E}tuoN{tQUR%evm#Cvm0d1+-jUn z2S;Pu(XN;X{FPf)W9Rd$@cNv~^*V_PH7x3O&XFFbJO_VYwP9c$_a0oDB%%vdGss3A zEIYlv<9lKsUWG#%AZUnE!e)@EyW*~WEIRp)VFLQ4ei?f`T1gQs|% zX_{z0!z+}nRmZ;Bko}}7^owSgau>dwN=qP7)Wq%)oBwu_ImAt=F|fZ$C;aEnObjnOE9a;@oUPNIQVT_%=0F(xQ??fF3)*Q zlI}F=Ne8k1^#nImE(k7_xI{(@}Bml%TGK3 z4y%O{N3i;i0f7L*P2Xk%7pN-&WidMaBrX*JL~u2nRw07|SE5<2fKp?N{;bd)L3jKB zzPRNa(%0Qsp#VgTf2$#SYZ=6jpq#?;_Z+ZJ;g1OzwqOJ~Q!%py8?I3hPIwg}5105r znLipOS&(6K3{e3^6QmB}6htdfAHP8X*D!9-ctAYuK~Ux2VCWN}gM-^bM0S^B_-P!% zDIqCgW`VOX+XkSdrQm4n*k>hH0w2W9NO>zC%gu}U+|xBfccdGf9JCqQm@)=h4!Xr%KrHcFvN%sK*VO* zH?l?b^O>Tqr}-%oh)%^i01R=mxQJFZgdYQ^`@_BYfQrz5f+^`BF1jSWT2w(AJs6TB zF3E#&GaJyTD2D|tR6t+LBY%`(i`-M_aNdLPJMDiI5XTGf>=Qu)Et$Df9pbrY@H~ZJ zH7%r5iNOxgFR)X@RDt?PTey&I1Mve$qCC<4|LXE{W#ExP=jYTdG03r)` z0YHQu2u%Ytm?3aZrj;IJgUUJAvZ#cER!SNEpFU89^Z4Tq^b3o}Jd)VuGAnZ?6si?b zyI_E1Jfck**ja4$&>N|5(3HAL9FU!uAkN_C*&(l}xP=%-qf;}m!GwRI;IB=9bVP|? z3wb5ofTZAS^~#W&ADzr_L&cQ|IBX;KrFZW<4(!r4{v>w1#r3=RE7#A-!MU!(2GbG- zk%ebN<;E`+Rzg~6B-gRzi7w~KFX?};6ExV>m01s79n7Mreol1paQkQFJP7uPE1k#1 zv;5yyWgUJNYn|oH=q$*xf>O3yPb68K#zjJe5d6agk zivs-?^AP9!^q)K_nZq=0RYIvuUVTC*jb~K%^^`C7aV=hj3u^bLp$2l;nQqD+XD%cg`BT%=ai#a(?JS+(lIM5VKHfA2?a>hHO{SZYjZ z085rk3972$5x_?s$JVsD=WNpbfLqf2t$}kmL8j2AM^>wrqWLJvJN5ho5kJ1&<|H$q z*re5WjP83VYo_z1R}}Y2^s#q3^|VQE`rt=GUg&|8m9J?s z08qVR4cp&#Oyqr#3t26I#?9$j#q6g10F!Cf#|M)cUk-7U$9bRQ6GrWwy(pBEMUO|n ztBqM|)$1uUR3sY=V*5#=q~DzgAAf0n5mx)%ZrbK=XK;{ld|0HKpln5UK1IKRqZJnv zTTfBqkZRS!+|y6F*0+k)kw#6QQwAu~TBd6?+;6Gy`bv4;d75>z4pIG8kz9KpiK>B8 z=N&gSO@^YVU_w4z`pZ0SfDq4G6{jEc?3Q`=B&SNg8vhKRnNxLVTzNJkj$79a9B-P8 znxsQ)N<(1$XdX3fPnvT)qhHH`$b2=A^Ri*Q;w4>wq^SI~8*|&-LD9q%%U8+#AxP?SGP_i$5p64;xfFV;~%>rgdaR%nd2 z9JPAg&>wkACC~qizBX&hRA#-x%?sBVYb6OXAGw`qLs~Kfsi!=|Yr;atPGCXYmeAs@ zZC#yL6S&(Tc-K@c%7cmc>#y^Pk6b<~uOOYJOi1lEuzsNTw7w?h$MCbXV!5;OV#jYP z#T@Uv<+)q&#`(l)7PZ*BXp+>MIs<0L$59<(_jp@!xzg0-pvAaM<1|%s{v}NuYT)fl zHKpk{WOpZ_pbh>{)C7dL5SpcBS2YQoPIR z{-m7TBj%Pf288s9rZ(bgW~#rlXS<#Q({aXplej76wqzxvLr!z1_4ANl181uKR6tE} zck)H+S|3gGM7FidM;2jskExiJW3bGADnN78>c*}19t)kvt!|euZ!}#SFqoKjF+PD& zzi0ek18eGwr=^*tc`JHUSU%QH{lBJ2AYMd&C=}UK9h7#)vvh|L}g_$@d z6m|2Qr%63x0Ajf3;&JM9ZSXxUN)5QNmHV?-a~O6speLU_BL>A{$}TS za?`nNYj=R*>;KCp)ifyf`sF0aR_f!!N2yo;$$gdo>L$rd+oWOVi>QhIwX>W&UPl4h zFp$)FOHHkMHhm9ILUwJbWNw3wY-R1--JnhlaPL(Q#c6U6*Raf$dPuv@7sz<>a_Xfj zz#F8%G4o4%;Inbi&_27Zv&w4Sag)~2DZj+A_K#dmwzE#=W~3$?Q`$J-f#4cNfH|aiV&pa=?S`;q2|9+-=%PvYL(&p2r=@ zd7yt#+@wkEmA{FJNo)Sfk?{fpHD6}Sp`lHgqc^8ZTRI4F`jq>QGG;Zz@KW9WNLsBNftQluY^w{q$l|$7Hzjb}dm46fV--2KT)2-ph8H;z zwfYqH3Vb1{VW+8awo51Vw`ng)Q=hq#n87sV#OYRPm*{D?s|*4dilW)hu2E?Y?(PlJ zd85=#+W3M5!&$}iz2^JavEt$?+HY&kj}vJx=>0kL^KE?k7%3Hg5+9=GX(NPg_NBn~ zNqBz;GJ{hh&c28=^1vxY?0iJ?{&QeI_ zjBTxYFMcB_kQD0r%|ibY25_fO5_m`FaeXj<3wcmZTP*A92w(MpnOXWrR4@)%9#o)> z{@_(8%Uc3^*l@)3FFg(OuV6z5zBUv8zH_Mzs7{c_1b9SXECc)kh!c(suq3z~0d2^I zohD8iW_RGQfgj=!eQ;&M(iHfgP+tg8BAie+Ms#luq=vel#M(&k$MOJ+;y|s=vw7Sx zS=v|eOAupTAqoMIa81}EgB1c8^RNQB7dGO+DjL3n4S)%Md5`0S#Zr(v*KF64aNR|Z zho>;G*rS{V^Itu2r>dWC%5`h`8gc<+Fm?fS2)TbN4y>@%fU#9i^oky@E}L1_5w7mY zaME9&T(Ul-tYA=)dWCE~;V@tq{S@qsxoz2f^Y6FE7M?{8?F|^0-M&5juQ<5#3#4h~ zfmGvhurdS4(FDCMcqOLidoxeHXklKLd?klpZKaMxew8EQ!J}Qu|>Pv#8MD#M=7@ z!lnKpJ9E7f>H1gSNLbF}l;_mworsXQ^BSO$ex#g{x!$PKZ<|*l-Q@#=W7P?t= zcK0#cXzS==mG)1pbjoxC(4Fw$NZYrnM5yXobu|aqZC#i!`iN25Pb)0RJRheTd3^PX&OO#t>Kc9 zM!lAK+;}}+JZwYokbG?+V0RPWQ0wsJaWfWbgjie0WUFbZgq&-E4GCsm)v8(Pb)^^U zbZBZ_wlW9qlNfC03yh=yBHKQs;d_|)%<}rrlpn5iE7>2JPV6vx;)_D>UZVHE?BWqg zQ^JqJ^O5BSYSakPI$lT+b2OUmMbU5UCK(1*)N>BHuw{;RakDjgckg6Hu^b2!5%)>k znzXn~1McVO&qH|2cB-h;d7H_`fLTpK=ZA@{IFk$z{~lWbcPI~fU+VIbuNe9-Q@mnjsZDqPw7D);04Yw&>?nGG0ZS2lF<;cn;DEEIoXv1Ru z-Rq&|GIciSvLKn^A45UXs*9++4b(IWW#@Aj^q&=4!@fv2@|f3 zjlXShB)ID}wf?Aq?9bG24=^~yjrtMtIoHOQF zCFQx)D0~aMQB^_ulr=Es-$Ib6ZSOaGU$vp!bB=i@k83lSSGDntX=C1y7b8DidW2-* zOx00!xzl_9yCWyeqmfn|N8*xww#WABq;#L)WS%N$#wpJ4d7) zojXGo_b(0689vDY9X@+)=&XNhKMCJ86z2JnD%n2p;CzMq1-i69vl1Ws%M8VJz<~AW zmakFr?p?(uoX_!%SDXC@*OvEHeB4Ag&3(;0^@Z}azf#9Vs`Yb$^&eHgxiWUS#dZy; z5-B@BULm(IFe;cf~H z(LEm@S-6eSd22(ddmtyn-ySTYh^H>4@qX(yVNZT{q_JZ5gn8fN=4;O5{(9fXdr@~i zG1Kr~L`O%xS34MhJsJJwJZW!6(@KK)Oo6$K+QeWU;ab1xMe72k<5k>4b2d9h?*8}D zXZ;MQuW=qkJVSXQ$ue7LYe`X&Qa=IGt*iNlPNJ zI!V=}^ZvP@^|skPQWcscyC)lGh92_*IDxrid5OD9yeG%U3;kVuW+?3nqophADN6ZDVzuHw}}C)d@M3 zPBgWETKycd8VTGTB{|mqsXy?$JBxQ`M?7+mG)d&n-QY zD~H|2tQgVk$+}#<>tYtAn&(>0zGmFpaFtH`Eqxn}_^{VxEHO@7K8}6OhcM!`B`A;O zCB|`cJy-aBx=>CjI?laN=Ph%Pr1?2{Iqhw;#tE}8jIi%M8yv<$8*hH&khVBcE}m?; zomU-Z9_I|ebZ*OUJO)q{QM9vb*+1N4 zuPtrP%28=@@}IpDqN&x@8e!XN3VHhJhsPQHG`CrwHfDS1J;&03TIOn2Wr5*^hSJkD zs>N}d006poj&wJ{>;62hR!t;C?A|0r;IyPQ`Z;A^eU@#^NioKxT#tkFiMiPH_*-Rv(t

KHQ@zp*R* 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 BB8~t6 literal 0 HcmV?d00001 diff --git a/modules/graphical/default.nix b/modules/graphical/default.nix new file mode 100644 index 0000000..8911970 --- /dev/null +++ b/modules/graphical/default.nix @@ -0,0 +1,166 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; + yamlFormat = pkgs.formats.yaml {}; + sessionVariables = { + WLR_RENDERER = + if psCfg.graphical.wayland.software-renderer.enable + then "pixman" + else "gles2"; + # Fix KeepassXC rendering issue + # https://github.com/void-linux/void-packages/issues/23517 + QT_AUTO_SCREEN_SCALE_FACTOR = "0"; + }; +in { + imports = [ + ./sway + ]; + + options.pub-solar.graphical = { + wayland.software-renderer.enable = mkOption { + type = types.bool; + default = false; + description = "Feature flag enabling wlroots software renderer, useful in VMs"; + }; + }; + + config = { + hardware.opengl.enable = true; + + environment = { + systemPackages = with pkgs; [ + gtk-engine-murrine + gtk_engines + gsettings-desktop-schemas + + matcha-gtk-theme + papirus-maia-icon-theme + + glib + xdg-utils + ]; + + etc = { + "xdg/PubSolar.conf".text = '' + [Qt] + style=GTK+ + ''; + }; + + variables = sessionVariables; + }; + + services.getty.autologinUser = psCfg.user.name; + + qt = { + enable = true; + platformTheme = "gtk2"; + style = "gtk2"; + }; + + services.udev.packages = with pkgs; [gnome3.gnome-settings-daemon]; + # Enable Sushi, a quick previewer for nautilus + services.gnome.sushi.enable = true; + # Enable GVfs, a userspace virtual filesystem + services.gvfs.enable = true; + services.yubikey-agent.enable = true; + + fonts = { + packages = with pkgs; [ + dejavu_fonts + powerline-fonts + ]; + enableDefaultPackages = true; + fontconfig.enable = true; + fontconfig.defaultFonts = { + monospace = ["DejaVu Sans Mono for Powerline"]; + sansSerif = ["DejaVu Sans"]; + }; + }; + + users.users."${psCfg.user.name}".packages = with pkgs; [ + alacritty + firefox-wayland + flameshot + gnome.adwaita-icon-theme + gnome.eog + gnome.nautilus + gnome.seahorse + gnome.yelp + hicolor-icon-theme + keepassxc + qMasterPassword-wayland + libnotify + vlc + ]; + + home-manager.users."${psCfg.user.name}" = { + home.file."xinitrc".source = ./.xinitrc; + xdg.configFile."alacritty/alacritty.yml".source = yamlFormat.generate "alacritty.yml" (import ./alacritty.nix); + xdg.configFile."xmodmap".source = ./.config/xmodmap; + xdg.configFile."user-dirs.dirs".source = ./.config/user-dirs.dirs; + xdg.configFile."user-dirs.locale".source = ./.config/user-dirs.locale; + xdg.configFile."xsettingsd/xsettingsd.conf".source = ./.config/xsettingsd/xsettingsd.conf; + xdg.configFile."mako/config".source = ./.config/mako/config; + xdg.configFile."libinput-gestures.conf".source = ./.config/libinput-gestures.conf; + xdg.configFile."swaync/config.json".source = ./.config/swaync/config.json; + xdg.configFile."swaync/style.css".source = ./.config/swaync/style.css; + xdg.configFile."waybar/config".source = ./.config/waybar/config; + xdg.configFile."waybar/style.css".source = ./.config/waybar/style.css; + xdg.configFile."waybar/colorscheme.css".source = ./.config/waybar/colorscheme.css; + xdg.configFile."wallpaper.jpg".source = ./assets/wallpaper.jpg; + + # Required for running Gnome apps outside the Gnome DE, see + # https://nixos.wiki/wiki/GNOME#Running_GNOME_programs_outside_of_GNOME + dconf = { + enable = true; + settings = { + "org/gnome/desktop/interface" = { + color-scheme = "prefer-dark"; + }; + }; + }; + + gtk = { + enable = true; + font.name = "Lato"; + iconTheme = { + package = pkgs.papirus-icon-theme; + name = "Papirus-Adapta-Nokto-Maia"; + }; + theme = { + package = pkgs.matcha-gtk-theme; + name = "Matcha-dark-aliz"; + }; + + gtk3.extraConfig = { + gtk-xft-antialias = "1"; + gtk-xft-hinting = "1"; + gtk-xft-hintstyle = "hintfull"; + gtk-xft-rgba = "rgb"; + gtk-application-prefer-dark-theme = "true"; + }; + + gtk4.extraConfig = { + gtk-xft-antialias = "1"; + gtk-xft-hinting = "1"; + gtk-xft-hintstyle = "hintfull"; + gtk-xft-rgba = "rgb"; + gtk-application-prefer-dark-theme = "true"; + }; + }; + + xresources.extraConfig = builtins.readFile ./.Xdefaults; + + systemd.user.services.network-manager-applet = import ./network-manager-applet.service.nix pkgs; + + home.sessionVariables = sessionVariables; + systemd.user.sessionVariables = sessionVariables; + }; + }; +} diff --git a/modules/graphical/network-manager-applet.service.nix b/modules/graphical/network-manager-applet.service.nix new file mode 100644 index 0000000..a321465 --- /dev/null +++ b/modules/graphical/network-manager-applet.service.nix @@ -0,0 +1,15 @@ +pkgs: { + Unit = { + Description = "Network Manager applet"; + BindsTo = ["sway-session.target"]; + After = ["sway-session.target"]; + # ConditionEnvironment requires systemd v247 to work correctly + ConditionEnvironment = ["WAYLAND_DISPLAY"]; + }; + Service = { + ExecStart = "${pkgs.networkmanagerapplet}/bin/nm-applet --sm-disable --indicator"; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/graphical/sway/config/config.d/applications.conf b/modules/graphical/sway/config/config.d/applications.conf new file mode 100644 index 0000000..00eecef --- /dev/null +++ b/modules/graphical/sway/config/config.d/applications.conf @@ -0,0 +1,78 @@ +# switch to workspace with urgent window automatically +for_window [urgent=latest] focus + +for_window [app_id="keepassxc"] floating disable +assign [app_id="keepassxc"] $ws8 + +for_window [app_id="virt-manager"] floating disable +assign [app_id="virt-manager"] $ws9 + +assign [instance="element"] $ws4 +assign [app_id="Signal"] $ws4 +assign [app_id="telegramdesktop"] $ws4 + +# Launcher +for_window [app_id="launcher" title="Alacritty"] floating enable, border pixel 10, sticky enable + +for_window [app_id="pavucontrol"] floating enable, border pixel 10, sticky enable + +# Floating menus +for_window [app_id="blueman-manager"] floating enable + +# Open specific applications in floating mode +for_window [title="alsamixer"] floating enable border pixel 1 +for_window [class="Calamares"] floating enable border normal +for_window [class="Clipgrab"] floating enable +for_window [title="File Transfer*"] floating enable +for_window [class="Galculator"] floating enable border pixel 1 +for_window [class="GParted"] floating enable border normal +for_window [title="i3_help"] floating enable sticky enable border normal +for_window [class="Lightdm-gtk-greeter-settings"] floating enable +for_window [class="Lxappearance"] floating enable sticky enable border normal +for_window [class="Manjaro-hello"] floating enable +for_window [class="Manjaro Settings Manager"] floating enable border normal +for_window [title="MuseScore: Play Panel"] floating enable +for_window [class="Nitrogen"] floating enable sticky enable border normal +for_window [class="Oblogout"] fullscreen enable +for_window [class="octopi"] floating enable +for_window [title="About Pale Moon"] floating enable +for_window [class="Pamac-manager"] floating enable +for_window [class="Pavucontrol"] floating enable +for_window [class="qt5ct"] floating enable sticky enable border normal +for_window [class="Qtconfig-qt4"] floating enable sticky enable border normal +for_window [class="Simple-scan"] floating enable border normal +for_window [class="(?i)System-config-printer.py"] floating enable border normal +for_window [class="Skype"] floating enable border normal +for_window [class="Thus"] floating enable border normal +for_window [class="Timeset-gui"] floating enable border normal +for_window [class="(?i)virtualbox"] floating enable border normal +for_window [class="Xfburn"] floating enable +for_window [class="^VirtualBox Machine$" title="Running"] floating disable +for_window [class="^rdesktop" title="rdesktop"] floating disable + +# firefox floating menus +for_window [window_role="pop-up"] floating enable +for_window [window_role="task_dialog"] floating enable +for_window [window_role="pop-up"] floating enable +for_window [window_role="bubble"] floating enable +for_window [window_role="task_dialog"] floating enable +for_window [window_role="Preferences"] floating enable +for_window [window_type="dialog"] floating enable +for_window [window_type="menu"] floating enable +for_window [title="About Mozilla Firefox"] floating enable +for_window [title="Password Required - Mozilla Firefox"] floating enable +for_window [title="Extension: (Open in Browser)*"] floating enable + +# Technical media stuff happens on ws7 +for_window [app_id="screen-recorder" title="Alacritty"] move to workspace $ws7, floating disable +no_focus [app_id="screen-recorder"] +for_window [title="Firefox — Sharing Indicator"] move to workspace $ws7, floating disable +no_focus [title="Firefox — Sharing Indicator"] + +# qMasterPassword floating menu +for_window [title="qMasterPassword"] focus +for_window [title="qMasterPassword"] floating enable + +# vimpc floating instance +for_window [app_id="mu_vimpc"] focus +for_window [app_id="mu_vimpc"] floating enable, border pixel 10, sticky enable diff --git a/modules/graphical/sway/config/config.d/colorscheme.conf b/modules/graphical/sway/config/config.d/colorscheme.conf new file mode 100644 index 0000000..3886c3d --- /dev/null +++ b/modules/graphical/sway/config/config.d/colorscheme.conf @@ -0,0 +1,19 @@ +## Base16 Burn +# Author: Benjamin Bädorf + +set $base00 #1a181a +set $base01 #2d2a2e +set $base02 #303030 +set $base03 #949494 +set $base04 #d3d1d4 +set $base05 #e3e1e4 +set $base06 #303030 +set $base07 #ff5f5f +set $base08 #f85e84 +set $base09 #df5923 +set $base0A #e5c463 +set $base0B #9ecd6f +set $base0C #ef9062 +set $base0D #7accd7 +set $base0E #ab9df2 +set $base0F #d70000 diff --git a/modules/graphical/sway/config/config.d/custom-keybindings.conf b/modules/graphical/sway/config/config.d/custom-keybindings.conf new file mode 100644 index 0000000..6d3019b --- /dev/null +++ b/modules/graphical/sway/config/config.d/custom-keybindings.conf @@ -0,0 +1,47 @@ +# launch categorized menu +bindsym $mod+z exec --no-startup-id morc_menu + +# switch keyboard input language +#bindsym $mod+tab exec toggle-kbd-layout + +################################################################################################ +## sound-section - ## +################################################################################################ + +bindsym $mod+Ctrl+m exec pavucontrol + +################################################################################################ + +# Quickstart application shortcuts +bindsym $mod+F1 exec psos help +bindsym $mod+Shift+h exec psos help + +bindsym $mod+F2 exec firefox + +bindsym $mod+F4 exec nautilus -w +bindsym $mod+Shift+F4 exec signal-desktop --use-tray-icon + +# Notifications with swaynotificationcenter +# Toggle control center +bindsym $mod+Shift+n exec swaync-client -t -sw + +bindsym $mod+Shift+m exec qMasterPassword + +# Screenshots and screen recordings +bindsym $mod+Ctrl+p exec grim -g "$(slurp -d -b \#ffffff11)" ~/Pictures/Screenshots/$(date +%Y%m%d_%Hh%Mm%Ss)_grim.png +bindsym $mod+Shift+p exec grim ~/Pictures/Screenshots/$(date +%Y%m%d_%Hh%Mm%Ss)_grim.png +bindsym $mod+Ctrl+f exec "( pkill flameshot || true && flameshot & ) && ( sleep 0.5s && flameshot gui )" + +bindsym $mod+Ctrl+r exec record-screen + +# Launcher +set $menu exec alacritty --class launcher -e env TERMINAL_COMMAND="alacritty -e" sway-launcher +bindsym $mod+Space exec $menu + +set $mode_vncclient In VNCClient mode. Press $mod+Num_Lock or $mod+Shift+Escape to return. +bindsym $mod+Num_Lock mode "$mode_vncclient" +bindsym $mod+Shift+Escape mode "$mode_vncclient" +mode "$mode_vncclient" { + bindsym $mod+Num_Lock mode "default" + bindsym $mod+Shift+Escape mode "default" +} diff --git a/modules/graphical/sway/config/config.d/gaps.conf b/modules/graphical/sway/config/config.d/gaps.conf new file mode 100644 index 0000000..0dcc508 --- /dev/null +++ b/modules/graphical/sway/config/config.d/gaps.conf @@ -0,0 +1,53 @@ +# Set inner/outer gaps +gaps inner 10 +gaps outer -5 + +# Additionally, you can issue commands with the following syntax. This is useful to bind keys to changing the gap size. +# gaps inner|outer current|all set|plus|minus +# gaps inner all set 10 +# gaps outer all plus 5 + +# Smart gaps (gaps used if only more than one container on the workspace) +smart_gaps on + +# Smart borders (draw borders around container only if it is not the only container on this workspace) +# on|no_gaps (on=always activate and no_gaps=only activate if the gap size to the edge of the screen is 0) +smart_borders on + +# Press $mod+Shift+g to enter the gap mode. Choose o or i for modifying outer/inner gaps. Press one of + / - (in-/decrement for current workspace) or 0 (remove gaps for current workspace). If you also press Shift with these keys, the change will be global for all workspaces. +set $mode_gaps Gaps: (o) outer, (i) inner +set $mode_gaps_outer Outer Gaps: +|-|0 (local), Shift + +|-|0 (global) +set $mode_gaps_inner Inner Gaps: +|-|0 (local), Shift + +|-|0 (global) +bindsym $mod+Shift+g mode "$mode_gaps" + +mode "$mode_gaps" { + bindsym o mode "$mode_gaps_outer" + bindsym i mode "$mode_gaps_inner" + bindsym Return mode "default" + bindsym Escape mode "default" +} +mode "$mode_gaps_inner" { + bindsym plus gaps inner current plus 5 + bindsym minus gaps inner current minus 5 + bindsym 0 gaps inner current set 0 + + bindsym Shift+plus gaps inner all plus 5 + bindsym Shift+minus gaps inner all minus 5 + bindsym Shift+0 gaps inner all set 0 + + bindsym Return mode "default" + bindsym Escape mode "default" +} +mode "$mode_gaps_outer" { + bindsym plus gaps outer current plus 5 + bindsym minus gaps outer current minus 5 + bindsym 0 gaps outer current set 0 + + bindsym Shift+plus gaps outer all plus 5 + bindsym Shift+minus gaps outer all minus 5 + bindsym Shift+0 gaps outer all set 0 + + bindsym Return mode "default" + bindsym Escape mode "default" +} + diff --git a/modules/graphical/sway/config/config.d/mode_system.conf.nix b/modules/graphical/sway/config/config.d/mode_system.conf.nix new file mode 100644 index 0000000..62d4557 --- /dev/null +++ b/modules/graphical/sway/config/config.d/mode_system.conf.nix @@ -0,0 +1,41 @@ +{ + pkgs, + psCfg, + ... +}: +'' + # Set shut down, restart and locking features +'' ++ ( + if psCfg.core.hibernation.enable + then '' + set $mode_system (e)xit, (h)ibernate, (l)ock, (s)uspend, (r)eboot, (Shift+s)hutdown + '' + else '' + set $mode_system (e)xit, (l)ock, (s)uspend, (r)eboot, (Shift+s)hutdown + '' +) ++ '' + bindsym $mod+0 mode "$mode_system" + + mode "$mode_system" { + bindsym e exec swaymsg exit, mode "default" +'' ++ ( + if psCfg.core.hibernation.enable + then '' + bindsym h exec systemctl hibernate, mode "default" + '' + else "" +) ++ '' + bindsym l exec ${pkgs.swaylock-bg}/bin/swaylock-bg, mode "default" + bindsym s exec systemctl suspend, mode "default" + bindsym r exec systemctl reboot, mode "default" + bindsym Shift+s exec systemctl poweroff, mode "default" + + # exit system mode: "Enter" or "Escape" + bindsym Return mode "default" + bindsym Escape mode "default" + } +'' diff --git a/modules/graphical/sway/config/config.d/systemd.conf b/modules/graphical/sway/config/config.d/systemd.conf new file mode 100644 index 0000000..66759c4 --- /dev/null +++ b/modules/graphical/sway/config/config.d/systemd.conf @@ -0,0 +1,8 @@ +# Note that the systemctl commands must be run synchronously and can't be split into +# three exec statements, since otherwise the session target may be started before +# systemctl import-environment is complete, and services that require certain variables +# will fail to run. +# https://github.com/swaywm/sway/wiki/Systemd-integration +# Also, import the most important environment variables into the D-Bus and systemd +# user environments (e.g. required for screen sharing and Pinentry prompts): +exec "systemctl --user import-environment; systemctl --user start sway-session.target; exec dbus-update-activation-environment --systemd $IMPORT_ENVIRONMENT_ENV_LIST DISPLAY WAYLAND_DISPLAY SWAYSOCK XDG_CURRENT_DESKTOP; systemd-cat --identifier=sway sway" diff --git a/modules/graphical/sway/config/config.d/theme.conf b/modules/graphical/sway/config/config.d/theme.conf new file mode 100644 index 0000000..eb4427a --- /dev/null +++ b/modules/graphical/sway/config/config.d/theme.conf @@ -0,0 +1,16 @@ +# Border BG Text Ind Child Border +client.focused $base00 $base01 $base07 $base0D $base07 +client.focused_inactive $base00 $base01 $base07 $base03 $base00 +client.unfocused $base00 $base00 $base04 $base06 $base00 +client.urgent $base00 $base0F $base00 $base08 $base00 + +client.background $base00 + +# Read the gtk settings from gtk setting.ini and pass them to gsettings +exec_always import-gtk-settings \ + gtk-theme:gtk-theme-name \ + icon-theme:gtk-icon-theme-name \ + cursor-theme:gtk-cursor-theme-name + +# Workaround to fix cursor scaling, see https://github.com/swaywm/sway/issues/4112 +seat seat0 xcursor_theme Adwaita diff --git a/modules/graphical/sway/config/config.nix b/modules/graphical/sway/config/config.nix new file mode 100644 index 0000000..b811c30 --- /dev/null +++ b/modules/graphical/sway/config/config.nix @@ -0,0 +1,217 @@ +{ + config, + pkgs, + ... +}: '' + # Default config for sway + # + # Copy this to ~/.config/sway/config and edit it to your liking. + # + # Read `man 5 sway` for a complete reference. + + ### Variables + # + # Logo key. Use Mod1 for Alt. + set $mod Mod4 + # Home row direction keys, like vim + set $left j + set $down k + set $up i + set $right l + # Your preferred terminal emulator + set $term ${pkgs.alacritty}/bin/alacritty + # Your preferred application launcher + # Note: pass the final command to swaymsg so that the resulting window can be opened + # on the original workspace that the command was run on. + #set $menu dmenu_path | dmenu | xargs swaymsg exec bemenu-run --no-overlap + + default_border pixel 1 + + ### Output configuration + # + # Default wallpaper (more resolutions are available in @datadir@/backgrounds/sway/) + output * bg ~/.config/wallpaper.jpg fill + + ### Key bindings + # + # Basics: + # + # Start a terminal + bindsym $mod+Return exec $term + + # Start a terminal + bindsym $mod+Shift+Return exec sh -c '$term --working-directory $(wcwd)' + + # Kill focused window + bindsym $mod+Shift+q kill + + # Drag floating windows by holding down $mod and left mouse button. + # Resize them with right mouse button + $mod. + # Despite the name, also works for non-floating windows. + # Change normal to inverse to use left mouse button for resizing and right + # mouse button for dragging. + floating_modifier $mod normal + + # Reload the configuration file + bindsym $mod+F5 reload + + # + # Moving around: + # + # Move your focus around + bindsym $mod+$left focus left + bindsym $mod+$down focus down + bindsym $mod+$up focus up + bindsym $mod+$right focus right + # Or use $mod+[up|down|left|right] + bindsym $mod+Left focus left + bindsym $mod+Down focus down + bindsym $mod+Up focus up + bindsym $mod+Right focus right + + # Move the focused window with the same, but add Shift + bindsym $mod+Shift+$left move left + bindsym $mod+Shift+$down move down + bindsym $mod+Shift+$up move up + bindsym $mod+Shift+$right move right + # Ditto, with arrow keys + bindsym $mod+Shift+Left move left + bindsym $mod+Shift+Down move down + bindsym $mod+Shift+Up move up + bindsym $mod+Shift+Right move right + # + # Workspaces: + # + + + # Workspace names + # to display names or symbols instead of plain workspace numbers you can use + # something like: set $ws1 1:mail + # set $ws2 2: + set $ws1 1 + set $ws2 2 + set $ws3 3 + set $ws4 4 + set $ws5 5 + set $ws6 6 + set $ws7 7 + set $ws8 8 + set $ws9 9 + + # Switch to workspace + bindsym $mod+1 workspace 1 + bindsym $mod+2 workspace 2 + bindsym $mod+3 workspace 3 + bindsym $mod+4 workspace 4 + bindsym $mod+5 workspace 5 + bindsym $mod+6 workspace 6 + bindsym $mod+7 workspace 7 + bindsym $mod+8 workspace 8 + bindsym $mod+9 workspace 9 + # Move focused container to workspace + bindsym $mod+Ctrl+1 move container to workspace $ws1 + bindsym $mod+Ctrl+2 move container to workspace $ws2 + bindsym $mod+Ctrl+3 move container to workspace $ws3 + bindsym $mod+Ctrl+4 move container to workspace $ws4 + bindsym $mod+Ctrl+5 move container to workspace $ws5 + bindsym $mod+Ctrl+6 move container to workspace $ws6 + bindsym $mod+Ctrl+7 move container to workspace $ws7 + bindsym $mod+Ctrl+8 move container to workspace $ws8 + bindsym $mod+Ctrl+9 move container to workspace $ws9 + # Move focused container to workspace and move focus with it + bindsym $mod+Shift+1 move container to workspace 1; workspace $ws1 + bindsym $mod+Shift+2 move container to workspace 2; workspace $ws2 + bindsym $mod+Shift+3 move container to workspace 3; workspace $ws3 + bindsym $mod+Shift+4 move container to workspace 4; workspace $ws4 + bindsym $mod+Shift+5 move container to workspace 5; workspace $ws5 + bindsym $mod+Shift+6 move container to workspace 6; workspace $ws6 + bindsym $mod+Shift+7 move container to workspace 7; workspace $ws7 + bindsym $mod+Shift+8 move container to workspace 8; workspace $ws8 + bindsym $mod+Shift+9 move container to workspace 9; workspace $ws9 + # Note: workspaces can have any name you want, not just numbers. + # We just use 1-10 as the default. + + #navigate workspaces next / previous + bindsym $mod+Ctrl+Right workspace next + bindsym $mod+Ctrl+Left workspace prev + + # workspace back and forth (with/without active container) + workspace_auto_back_and_forth yes + bindsym $mod+b workspace back_and_forth + bindsym $mod+Shift+b move container to workspace back_and_forth; workspace back_and_forth + + # + # Layout stuff: + # + # Configure border style + default_border pixel 1 + default_floating_border normal + + # Hide borders + hide_edge_borders none + + # Font for window titles. Will also be used by the bar unless a different font + # is used in the bar {} block below. + font xft:Hack 16 + + # You can "split" the current object of your focus with + # $mod+b or $mod+v, for horizontal and vertical splits + # respectively. + bindsym $mod+h splith; exec notify-send 'tile horizontally' + bindsym $mod+v splitv; exec notify-send 'tile vertically' + + # Switch the current container between different layout styles + bindsym $mod+s layout stacking + bindsym $mod+w layout tabbed + bindsym $mod+e layout toggle split + + # Make the current focus fullscreen + bindsym $mod+f fullscreen + + # Toggle the current focus between tiling and floating mode + bindsym $mod+Shift+space floating toggle + + # Swap focus between the tiling area and the floating area + bindsym $mod+t focus mode_toggle + + # Move focus to the parent container + bindsym $mod+a focus parent + bindsym $mod+d focus child + # + # Scratchpad: + # + # Sway has a "scratchpad", which is a bag of holding for windows. + # You can send windows there and get them back later. + + # Move the currently focused window to the scratchpad + bindsym $mod+Shift+minus move scratchpad + + # Show the next scratchpad window or hide the focused scratchpad window. + # If there are multiple scratchpad windows, this command cycles through them. + bindsym $mod+minus scratchpad show + # + # Resizing containers: + # + mode "resize" { + # left will shrink the containers width + # right will grow the containers width + # up will shrink the containers height + # down will grow the containers height + bindsym $left resize shrink width 10px + bindsym $down resize grow height 10px + bindsym $up resize shrink height 10px + bindsym $right resize grow width 10px + + # Ditto, with arrow keys + bindsym Left resize shrink width 10px + bindsym Down resize grow height 10px + bindsym Up resize shrink height 10px + bindsym Right resize grow width 10px + + # Return to default mode + bindsym Return mode "default" + bindsym Escape mode "default" + } + bindsym $mod+r mode "resize" + + include ~/.config/sway/config.d/*'' diff --git a/modules/graphical/sway/config/wayvnc/config.nix b/modules/graphical/sway/config/wayvnc/config.nix new file mode 100644 index 0000000..23a885d --- /dev/null +++ b/modules/graphical/sway/config/wayvnc/config.nix @@ -0,0 +1,11 @@ +{ + psCfg, + pkgs, +}: " +address=0.0.0.0 +enable_auth=true +username=${psCfg.user.name} +password=testtest +private_key_file=/run/agenix/vnc-key.pem +certificate_file=/run/agenix/vnc-cert.pem +" diff --git a/modules/graphical/sway/default.nix b/modules/graphical/sway/default.nix new file mode 100644 index 0000000..7cfa343 --- /dev/null +++ b/modules/graphical/sway/default.nix @@ -0,0 +1,101 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + options.pub-solar.graphical = { + v4l2loopback.enable = mkOption { + type = types.bool; + default = false; + description = "WebCam streaming tool"; + }; + }; + + config = { + boot = mkIf psCfg.graphical.v4l2loopback.enable { + extraModulePackages = with config.boot.kernelPackages; [v4l2loopback]; + kernelModules = ["v4l2loopback"]; + extraModprobeConfig = '' + options v4l2loopback exclusive_caps=1 devices=3 + ''; + }; + + environment.systemPackages = with pkgs; + mkIf psCfg.graphical.v4l2loopback.enable [ + linuxPackages.v4l2loopback + ]; + + programs.sway.enable = true; + + xdg.portal = { + enable = true; + wlr = { + enable = true; + settings = { + screencast = { + max_fps = 30; + chooser_type = "simple"; + chooser_cmd = "${pkgs.slurp}/bin/slurp -f %o -or"; + }; + }; + }; + extraPortals = with pkgs; [xdg-desktop-portal-gtk]; + }; + + services.pipewire.enable = true; + + users.users."${psCfg.user.name}".packages = with pkgs; [ + sway + grim + kanshi + slurp + swaybg + swayidle + swaynotificationcenter + xwayland + + libappindicator-gtk3 + + wl-clipboard + wf-recorder + brightnessctl + gammastep + geoclue2 + xsettingsd + ydotool + + sway-launcher + record-screen + import-gtk-settings + # Unused on teutat3s hosts, see custom-keybindings.conf + #toggle-kbd-layout + s + wcwd + ]; + + home-manager.users."${psCfg.user.name}" = { + programs.waybar.enable = true; + #programs.waybar.systemd.enable = true; + + systemd.user.services.swaynotificationcenter = import ./swaynotificationcenter.service.nix pkgs; + systemd.user.services.sway = import ./sway.service.nix {inherit pkgs psCfg;}; + systemd.user.services.swayidle = import ./swayidle.service.nix {inherit pkgs psCfg;}; + systemd.user.services.xsettingsd = import ./xsettingsd.service.nix {inherit pkgs psCfg;}; + systemd.user.services.waybar = import ./waybar.service.nix {inherit pkgs psCfg;}; + systemd.user.targets.sway-session = import ./sway-session.target.nix {inherit pkgs psCfg;}; + + xdg.configFile."sway/config".text = import ./config/config.nix {inherit config pkgs;}; + xdg.configFile."sway/config.d/colorscheme.conf".source = ./config/config.d/colorscheme.conf; + xdg.configFile."sway/config.d/theme.conf".source = ./config/config.d/theme.conf; + xdg.configFile."sway/config.d/gaps.conf".source = ./config/config.d/gaps.conf; + xdg.configFile."sway/config.d/custom-keybindings.conf".source = ./config/config.d/custom-keybindings.conf; + xdg.configFile."sway/config.d/mode_system.conf".text = import ./config/config.d/mode_system.conf.nix {inherit pkgs psCfg;}; + xdg.configFile."sway/config.d/applications.conf".source = ./config/config.d/applications.conf; + xdg.configFile."sway/config.d/systemd.conf".source = ./config/config.d/systemd.conf; + }; + }; +} diff --git a/modules/graphical/sway/gammastep.service.nix b/modules/graphical/sway/gammastep.service.nix new file mode 100644 index 0000000..d488ea5 --- /dev/null +++ b/modules/graphical/sway/gammastep.service.nix @@ -0,0 +1,17 @@ +{pkgs, ...}: { + Unit = { + Description = "set color temperature of display according to time of day"; + Documentation = ["man:gammastep(1)"]; + BindsTo = ["sway-session.target"]; + After = ["sway-session.target"]; + # ConditionEnvironment requires systemd v247 to work correctly + ConditionEnvironment = ["WAYLAND_DISPLAY"]; + }; + Service = { + Type = "simple"; + ExecStart = "${pkgs.gammastep}/bin/gammastep -l geoclue2 -m wayland -v"; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/graphical/sway/libinput-gestures.service.nix b/modules/graphical/sway/libinput-gestures.service.nix new file mode 100644 index 0000000..eed9518 --- /dev/null +++ b/modules/graphical/sway/libinput-gestures.service.nix @@ -0,0 +1,18 @@ +{pkgs, ...}: { + Unit = { + Description = "Actions gestures on your touchpad using libinput"; + Documentation = ["https://github.com/bulletmark/libinput-gestures"]; + BindsTo = ["sway-session.target"]; + After = ["sway-session.target"]; + }; + Service = { + Type = "simple"; + ExecStart = "${pkgs.libinput-gestures}/bin/libinput-gestures"; + Restart = "on-failure"; + RestartSec = "1"; + TimeoutStopSec = "10"; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/graphical/sway/mako.service.nix b/modules/graphical/sway/mako.service.nix new file mode 100644 index 0000000..22524d3 --- /dev/null +++ b/modules/graphical/sway/mako.service.nix @@ -0,0 +1,18 @@ +{pkgs, ...}: { + Unit = { + Description = "Lightweight Wayland notification daemon"; + Documentation = ["man:mako(1)"]; + BindsTo = ["sway-session.target"]; + After = ["sway-session.target"]; + ConditionEnvironment = ["WAYLAND_DISPLAY"]; + }; + Service = { + Type = "dbus"; + BusName = "org.freedesktop.Notifications"; + ExecStart = "${pkgs.mako}/bin/mako"; + ExecReload = "${pkgs.mako}/bin/makoctl reload"; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/graphical/sway/sway-session.target.nix b/modules/graphical/sway/sway-session.target.nix new file mode 100644 index 0000000..f35ed28 --- /dev/null +++ b/modules/graphical/sway/sway-session.target.nix @@ -0,0 +1,9 @@ +{pkgs, ...}: { + Unit = { + Description = "sway compositor session"; + Documentation = ["man:systemd.special(7)"]; + BindsTo = ["graphical-session.target"]; + Wants = ["graphical-session-pre.target"]; + After = ["graphical-session-pre.target"]; + }; +} diff --git a/modules/graphical/sway/sway.service.nix b/modules/graphical/sway/sway.service.nix new file mode 100644 index 0000000..253df4a --- /dev/null +++ b/modules/graphical/sway/sway.service.nix @@ -0,0 +1,17 @@ +{pkgs, ...}: { + Unit = { + Description = "sway - SirCmpwn's Wayland window manager"; + Documentation = ["man:sway(5)"]; + BindsTo = ["graphical-session.target"]; + Wants = ["graphical-session-pre.target"]; + After = ["graphical-session-pre.target"]; + }; + Service = { + Type = "simple"; + ExecStartPre = "${pkgs.systemd}/bin/systemctl --user unset-environment WAYLAND_DISPLAY DISPLAY"; + ExecStart = "${pkgs.sway}/bin/sway"; + Restart = "on-failure"; + RestartSec = "1"; + TimeoutStopSec = "10"; + }; +} diff --git a/modules/graphical/sway/swayidle.service.nix b/modules/graphical/sway/swayidle.service.nix new file mode 100644 index 0000000..de984e7 --- /dev/null +++ b/modules/graphical/sway/swayidle.service.nix @@ -0,0 +1,26 @@ +{ + pkgs, + psCfg, + ... +}: { + Unit = { + Description = "Idle manager for Wayland"; + Documentation = ["man:swayidle(1)"]; + BindsTo = ["graphical-session.target"]; + Wants = ["graphical-session-pre.target"]; + After = ["graphical-session-pre.target"]; + }; + Service = { + Type = "simple"; + ExecStart = '' + ${pkgs.swayidle}/bin/swayidle -w \ + timeout 300 '${pkgs.swaylock-bg}/bin/swaylock-bg' \ + timeout 600 '${pkgs.sway}/bin/swaymsg "output * dpms off"' \ + resume '${pkgs.sway}/bin/swaymsg "output * dpms on"' \ + before-sleep '${pkgs.swaylock-bg}/bin/swaylock-bg' + ''; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/graphical/sway/swaynotificationcenter.service.nix b/modules/graphical/sway/swaynotificationcenter.service.nix new file mode 100644 index 0000000..44d22bd --- /dev/null +++ b/modules/graphical/sway/swaynotificationcenter.service.nix @@ -0,0 +1,21 @@ +pkgs: { + Unit = { + Description = "Swaync notification daemon"; + Documentation = "https://github.com/ErikReider/SwayNotificationCenter"; + BindsTo = ["sway-session.target"]; + After = ["sway-session.target"]; + Requisite = ["graphical-session.target"]; + # ConditionEnvironment requires systemd v247 to work correctly + ConditionEnvironment = ["WAYLAND_DISPLAY"]; + }; + Service = { + Type = "dbus"; + BusName = "org.freedesktop.Notifications"; + ExecStart = "${pkgs.swaynotificationcenter}/bin/swaync"; + ExecReload = "${pkgs.swaynotificationcenter}/bin/swaync-client --reload-config ; ${pkgs.swaynotificationcenter}/bin/swaync-client --reload-css"; + Restart = "on-failure"; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/graphical/sway/waybar.service.nix b/modules/graphical/sway/waybar.service.nix new file mode 100644 index 0000000..4715fe8 --- /dev/null +++ b/modules/graphical/sway/waybar.service.nix @@ -0,0 +1,21 @@ +{pkgs, ...}: { + Unit = { + Description = "Highly customizable Wayland bar for Sway and Wlroots based compositors."; + Documentation = "https://github.com/Alexays/Waybar/wiki/"; + BindsTo = ["sway-session.target"]; + After = ["sway-session.target" "network-online.target"]; + Wants = ["graphical-session-pre.target" "network-online.target" "blueman-applet.service"]; + ConditionEnvironment = ["WAYLAND_DISPLAY"]; + }; + + Service = { + Type = "dbus"; + Environment = "PATH=${pkgs.bash}/bin:${pkgs.pavucontrol}/bin"; + BusName = "fr.arouillard.waybar"; + ExecStart = "${pkgs.waybar}/bin/waybar"; + }; + + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/graphical/sway/xsettingsd.service.nix b/modules/graphical/sway/xsettingsd.service.nix new file mode 100644 index 0000000..3905726 --- /dev/null +++ b/modules/graphical/sway/xsettingsd.service.nix @@ -0,0 +1,18 @@ +{pkgs, ...}: { + Unit = { + Description = "X Settings Daemon"; + Documentation = ["https://github.com/derat/xsettingsd/wiki/Installation"]; + BindsTo = ["sway-session.target"]; + After = ["sway-session.target"]; + # ConditionEnvironment requires systemd v247 to work correctly + ConditionEnvironment = ["WAYLAND_DISPLAY"]; + }; + Service = { + Type = "simple"; + ExecStart = "${pkgs.xsettingsd}/bin/xsettingsd"; + ExecStop = "/run/current-system/sw/bin/env pkill xsettingsd"; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/graphical/sway/ydotool.service.nix b/modules/graphical/sway/ydotool.service.nix new file mode 100644 index 0000000..4ef7646 --- /dev/null +++ b/modules/graphical/sway/ydotool.service.nix @@ -0,0 +1,18 @@ +{pkgs, ...}: { + Unit = { + Description = "ydotool - Generic command-line automation tool (no X!)"; + Documentation = ["https://github.com/ReimuNotMoe/ydotool"]; + BindsTo = ["sway-session.target"]; + After = ["sway-session.target"]; + }; + Service = { + Type = "simple"; + ExecStart = "${pkgs.ydotool}/bin/ydotoold"; + Restart = "on-failure"; + RestartSec = "1"; + TimeoutStopSec = "10"; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/hm-system-defaults.nix b/modules/hm-system-defaults.nix new file mode 100644 index 0000000..4bc6cf6 --- /dev/null +++ b/modules/hm-system-defaults.nix @@ -0,0 +1,11 @@ +{config, ...}: { + home-manager.sharedModules = [ + { + home.sessionVariables = { + inherit (config.environment.sessionVariables) NIX_PATH; + }; + xdg.configFile."nix/registry.json".text = + config.environment.etc."nix/registry.json".text; + } + ]; +} diff --git a/modules/invoiceplane/default.nix b/modules/invoiceplane/default.nix new file mode 100644 index 0000000..c086c24 --- /dev/null +++ b/modules/invoiceplane/default.nix @@ -0,0 +1,377 @@ +{ + config, + pkgs, + lib, + ... +}: +with lib; let + cfg = config.services.invoiceplane; + eachSite = cfg.sites; + user = "invoiceplane"; + webserver = config.services.${cfg.webserver}; + + invoiceplane-config = hostName: cfg: + pkgs.writeText "ipconfig.php" '' + IP_URL=http://${hostName} + ENABLE_DEBUG=false + DISABLE_SETUP=false + REMOVE_INDEXPHP=false + DB_HOSTNAME=${cfg.database.host} + DB_USERNAME=${cfg.database.user} + # NOTE: file_get_contents adds newline at the end of returned string + DB_PASSWORD=${ + if cfg.database.passwordFile == null + then "" + else "trim(file_get_contents('${cfg.database.passwordFile}'),\"\\r\\n\")" + } + DB_DATABASE=${cfg.database.name} + DB_PORT=${toString cfg.database.port} + SESS_EXPIRATION=864000 + ENABLE_INVOICE_DELETION=false + DISABLE_READ_ONLY=false + ENCRYPTION_KEY= + ENCRYPTION_CIPHER=AES-256 + SETUP_COMPLETED=false + REMOVE_INDEXPHP=true + ''; + + extraConfig = hostName: cfg: + pkgs.writeText "extraConfig.php" '' + ${toString cfg.extraConfig} + ''; + + pkg = hostName: cfg: + pkgs.stdenv.mkDerivation rec { + pname = "invoiceplane-${hostName}"; + version = src.version; + src = pkgs.invoiceplane; + + postPhase = '' + # Patch index.php file to load additional config file + substituteInPlace index.php \ + --replace "require('vendor/autoload.php');" "require('vendor/autoload.php'); \$dotenv = Dotenv\Dotenv::createImmutable(__DIR__, 'extraConfig.php'); \$dotenv->load();"; + ''; + + installPhase = '' + mkdir -p $out + cp -r * $out/ + + # symlink uploads and log directories + rm -r $out/uploads $out/application/logs $out/vendor/mpdf/mpdf/tmp + ln -sf ${cfg.stateDir}/uploads $out/ + ln -sf ${cfg.stateDir}/logs $out/application/ + ln -sf ${cfg.stateDir}/tmp $out/vendor/mpdf/mpdf/ + + # symlink the InvoicePlane config + ln -s ${cfg.stateDir}/ipconfig.php $out/ipconfig.php + + # symlink the extraConfig file + ln -s ${extraConfig hostName cfg} $out/extraConfig.php + + # symlink additional templates + ${concatMapStringsSep "\n" (template: "cp -r ${template}/. $out/application/views/invoice_templates/pdf/") cfg.invoiceTemplates} + ''; + }; + + siteOpts = { + lib, + name, + ... + }: { + options = { + enable = mkEnableOption (lib.mdDoc "InvoicePlane web application"); + + stateDir = mkOption { + type = types.path; + default = "/var/lib/invoiceplane/${name}"; + description = lib.mdDoc '' + This directory is used for uploads of attachments and cache. + The directory passed here is automatically created and permissions + adjusted as required. + ''; + }; + + database = { + host = mkOption { + type = types.str; + default = "localhost"; + description = lib.mdDoc "Database host address."; + }; + + port = mkOption { + type = types.port; + default = 3306; + description = lib.mdDoc "Database host port."; + }; + + name = mkOption { + type = types.str; + default = "invoiceplane"; + description = lib.mdDoc "Database name."; + }; + + user = mkOption { + type = types.str; + default = "invoiceplane"; + description = lib.mdDoc "Database user."; + }; + + passwordFile = mkOption { + type = types.nullOr types.path; + default = null; + example = "/run/keys/invoiceplane-dbpassword"; + description = lib.mdDoc '' + A file containing the password corresponding to + {option}`database.user`. + ''; + }; + + createLocally = mkOption { + type = types.bool; + default = true; + description = lib.mdDoc "Create the database and database user locally."; + }; + }; + + invoiceTemplates = mkOption { + type = types.listOf types.path; + default = []; + description = lib.mdDoc '' + List of path(s) to respective template(s) which are copied from the 'invoice_templates/pdf' directory. + + ::: {.note} + These templates need to be packaged before use, see example. + ::: + ''; + example = literalExpression '' + let + # Let's package an example template + template-vtdirektmarketing = pkgs.stdenv.mkDerivation { + name = "vtdirektmarketing"; + # Download the template from a public repository + src = pkgs.fetchgit { + url = "https://git.project-insanity.org/onny/invoiceplane-vtdirektmarketing.git"; + sha256 = "1hh0q7wzsh8v8x03i82p6qrgbxr4v5fb05xylyrpp975l8axyg2z"; + }; + sourceRoot = "."; + # Installing simply means copying template php file to the output directory + installPhase = "" + mkdir -p $out + cp invoiceplane-vtdirektmarketing/vtdirektmarketing.php $out/ + ""; + }; + # And then pass this package to the template list like this: + in [ template-vtdirektmarketing ] + ''; + }; + + poolConfig = mkOption { + type = with types; attrsOf (oneOf [str int bool]); + default = { + "pm" = "dynamic"; + "pm.max_children" = 32; + "pm.start_servers" = 2; + "pm.min_spare_servers" = 2; + "pm.max_spare_servers" = 4; + "pm.max_requests" = 500; + }; + description = lib.mdDoc '' + Options for the InvoicePlane PHP pool. See the documentation on `php-fpm.conf` + for details on configuration directives. + ''; + }; + + extraConfig = mkOption { + type = types.nullOr types.lines; + default = null; + example = '' + SETUP_COMPLETED=true + DISABLE_SETUP=true + IP_URL=https://invoice.example.com + ''; + description = lib.mdDoc '' + InvoicePlane configuration. Refer to + + for details on supported values. + ''; + }; + + cron = { + enable = mkOption { + type = types.bool; + default = false; + description = lib.mdDoc '' + Enable cron service which periodically runs Invoiceplane tasks. + Requires key taken from the administration page. Refer to + + on how to configure it. + ''; + }; + + key = mkOption { + type = types.str; + description = lib.mdDoc "Cron key taken from the administration page."; + }; + }; + }; + }; +in { + disabledModules = [ + "services/web-apps/invoiceplane.nix" + ]; + + # interface + options = { + services.invoiceplane = mkOption { + type = types.submodule { + options.sites = mkOption { + type = types.attrsOf (types.submodule siteOpts); + default = {}; + description = lib.mdDoc "Specification of one or more WordPress sites to serve"; + }; + + options.webserver = mkOption { + type = types.enum ["caddy"]; + default = "caddy"; + description = lib.mdDoc '' + Which webserver to use for virtual host management. Currently only + caddy is supported. + ''; + }; + }; + default = {}; + description = lib.mdDoc "InvoicePlane configuration."; + }; + }; + + # implementation + config = mkIf (eachSite != {}) (mkMerge [ + { + assertions = flatten (mapAttrsToList (hostName: cfg: [ + { + assertion = cfg.database.createLocally -> cfg.database.user == user; + message = ''services.invoiceplane.sites."${hostName}".database.user must be ${user} if the database is to be automatically provisioned''; + } + { + assertion = cfg.database.createLocally -> cfg.database.passwordFile == null; + message = ''services.invoiceplane.sites."${hostName}".database.passwordFile cannot be specified if services.invoiceplane.sites."${hostName}".database.createLocally is set to true.''; + } + { + assertion = cfg.cron.enable -> cfg.cron.key != null; + message = ''services.invoiceplane.sites."${hostName}".cron.key must be set in order to use cron service.''; + } + ]) + eachSite); + + services.mysql = mkIf (any (v: v.database.createLocally) (attrValues eachSite)) { + enable = true; + package = mkDefault pkgs.mariadb; + ensureDatabases = mapAttrsToList (hostName: cfg: cfg.database.name) eachSite; + ensureUsers = + mapAttrsToList ( + hostName: cfg: { + name = cfg.database.user; + ensurePermissions = {"${cfg.database.name}.*" = "ALL PRIVILEGES";}; + } + ) + eachSite; + }; + + services.phpfpm = { + phpPackage = pkgs.php81; + pools = + mapAttrs' (hostName: cfg: ( + nameValuePair "invoiceplane-${hostName}" { + inherit user; + group = webserver.group; + settings = + { + "listen.owner" = webserver.user; + "listen.group" = webserver.group; + } + // cfg.poolConfig; + } + )) + eachSite; + }; + } + + { + systemd.tmpfiles.rules = flatten (mapAttrsToList (hostName: cfg: [ + "d ${cfg.stateDir} 0750 ${user} ${webserver.group} - -" + "f ${cfg.stateDir}/ipconfig.php 0750 ${user} ${webserver.group} - -" + "d ${cfg.stateDir}/logs 0750 ${user} ${webserver.group} - -" + "d ${cfg.stateDir}/uploads 0750 ${user} ${webserver.group} - -" + "d ${cfg.stateDir}/uploads/archive 0750 ${user} ${webserver.group} - -" + "d ${cfg.stateDir}/uploads/customer_files 0750 ${user} ${webserver.group} - -" + "d ${cfg.stateDir}/uploads/temp 0750 ${user} ${webserver.group} - -" + "d ${cfg.stateDir}/uploads/temp/mpdf 0750 ${user} ${webserver.group} - -" + "d ${cfg.stateDir}/tmp 0750 ${user} ${webserver.group} - -" + ]) + eachSite); + + systemd.services.invoiceplane-config = { + serviceConfig.Type = "oneshot"; + script = concatStrings (mapAttrsToList (hostName: cfg: '' + mkdir -p ${cfg.stateDir}/logs \ + ${cfg.stateDir}/uploads + if ! grep -q IP_URL "${cfg.stateDir}/ipconfig.php"; then + cp "${invoiceplane-config hostName cfg}" "${cfg.stateDir}/ipconfig.php" + fi + '') + eachSite); + wantedBy = ["multi-user.target"]; + }; + + users.users.${user} = { + group = webserver.group; + isSystemUser = true; + }; + } + { + # Cron service implementation + + systemd.timers = + mapAttrs' (hostName: cfg: ( + nameValuePair "invoiceplane-cron-${hostName}" (mkIf cfg.cron.enable { + wantedBy = ["timers.target"]; + timerConfig = { + OnBootSec = "5m"; + OnUnitActiveSec = "5m"; + Unit = "invoiceplane-cron-${hostName}.service"; + }; + }) + )) + eachSite; + + systemd.services = + mapAttrs' (hostName: cfg: ( + nameValuePair "invoiceplane-cron-${hostName}" (mkIf cfg.cron.enable { + serviceConfig = { + Type = "oneshot"; + User = user; + ExecStart = "${pkgs.curl}/bin/curl --header 'Host: ${hostName}' http://localhost/invoices/cron/recur/${cfg.cron.key}"; + }; + }) + )) + eachSite; + } + + (mkIf (cfg.webserver == "caddy") { + services.caddy = { + enable = true; + virtualHosts = + mapAttrs' (hostName: cfg: ( + nameValuePair "http://${hostName}" { + extraConfig = '' + root * ${pkg hostName cfg} + file_server + php_fastcgi unix/${config.services.phpfpm.pools."invoiceplane-${hostName}".socket} + ''; + } + )) + eachSite; + }; + }) + ]); +} diff --git a/modules/nextcloud/default.nix b/modules/nextcloud/default.nix new file mode 100644 index 0000000..09fb840 --- /dev/null +++ b/modules/nextcloud/default.nix @@ -0,0 +1,13 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + home-manager.users."${psCfg.user.name}" = { + systemd.user.services.nextcloud-client = import ./nextcloud.service.nix pkgs; + }; +} diff --git a/modules/nextcloud/nextcloud.service.nix b/modules/nextcloud/nextcloud.service.nix new file mode 100644 index 0000000..f326797 --- /dev/null +++ b/modules/nextcloud/nextcloud.service.nix @@ -0,0 +1,20 @@ +pkgs: { + Unit = { + Description = "Nextcloud Client"; + BindsTo = ["sway-session.target"]; + Wants = ["graphical-session-pre.target"]; + After = ["graphical-session-pre.target"]; + # ConditionEnvironment requires systemd v247 to work correctly + ConditionEnvironment = ["WAYLAND_DISPLAY"]; + }; + Service = { + Type = "simple"; + ExecStart = "${pkgs.nextcloud-client}/bin/nextcloud --background"; + ExecReload = "/run/current-system/sw/bin/kill -HUP $MAINPID"; + KillMode = "process"; + Restart = "on-failure"; + }; + Install = { + WantedBy = ["sway-session.target"]; + }; +} diff --git a/modules/nix/default.nix b/modules/nix/default.nix new file mode 100644 index 0000000..1d6746e --- /dev/null +++ b/modules/nix/default.nix @@ -0,0 +1,65 @@ +{ + config, + pkgs, + lib, + flake, + ... +}: { + nixpkgs.config.allowUnfreePredicate = pkg: + builtins.elem (lib.getName pkg) [ + "1password" + "1password-cli" + "cups-brother-hl3140cw" + "facetimehd-firmware" + "slack" + "veracrypt" + "zoom" + ]; + + nix = { + # Use default version alias for nix package + package = pkgs.nix; + gc.automatic = true; + optimise.automatic = true; + + registry = { + nixpkgs.flake = flake.inputs.nixpkgs; + unstable.flake = flake.inputs.unstable; + system.flake = flake.self; + }; + + settings = { + # Improve nix store disk usage + auto-optimise-store = true; + # Prevents impurities in builds + sandbox = true; + # Give root and @wheel special privileges with nix + trusted-users = ["root" "@wheel"]; + # Allow only group wheel to connect to the nix daemon + allowed-users = ["@wheel"]; + + substituters = [ + "https://pub-solar.cachix.org/" + ]; + + trusted-public-keys = [ + "pub-solar.cachix.org-1:ZicXIxKgdxMtgSJECWR8iihZxHRvu8ObL4n2cuBmtos=" + ]; + }; + + # Generally useful nix option defaults + extraOptions = lib.mkForce '' + experimental-features = flakes nix-command + min-free = 536870912 + keep-outputs = true + keep-derivations = true + fallback = true + ''; + + nixPath = [ + "nixpkgs=${flake.inputs.nixpkgs}" + "nixos-config=${../../lib/compat/nixos}" + "home-manager=${flake.inputs.home-manager}" + ]; + }; +} diff --git a/modules/office/default.nix b/modules/office/default.nix new file mode 100644 index 0000000..483e33f --- /dev/null +++ b/modules/office/default.nix @@ -0,0 +1,20 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + programs.evince.enable = true; + + users.users."${psCfg.user.name}".packages = with pkgs; [ + libreoffice-fresh + gnome.simple-scan + # Tools like pdfunite + poppler_utils + # tool for annotating PDFs + xournalpp + ]; +} diff --git a/modules/printing/default.nix b/modules/printing/default.nix new file mode 100644 index 0000000..7de591e --- /dev/null +++ b/modules/printing/default.nix @@ -0,0 +1,40 @@ +{ + flake, + config, + pkgs, + lib, + ... +}: { + services.avahi.enable = true; + services.avahi.ipv6 = true; + services.avahi.nssmdns = true; + services.avahi.publish.enable = true; + services.avahi.publish.userServices = true; + + services.printing.enable = true; + services.printing.browsing = true; + services.printing.listenAddresses = ["localhost:631"]; + services.printing.defaultShared = lib.mkDefault false; + + services.printing.drivers = + [ + pkgs.gutenprint + ] + ++ ( + if (pkgs.system == "x86_64-linux") + then [pkgs.cups-brother-hl3140cw] + else [] + ); + + networking.hosts = flake.self.lib.addLocalHostname ["cups.local"]; + + services.caddy = { + enable = true; + extraConfig = '' + cups.local { + request_header Host localhost:631 + reverse_proxy unix//run/cups/cups.sock + } + ''; + }; +} diff --git a/modules/terminal-life/.config/git/config.nix b/modules/terminal-life/.config/git/config.nix new file mode 100644 index 0000000..dc50bd8 --- /dev/null +++ b/modules/terminal-life/.config/git/config.nix @@ -0,0 +1,47 @@ +{ + config, + pkgs, + ... +}: let + user = config.pub-solar.user; + xdg = config.home-manager.users."${user.name}".xdg; +in '' [user] + ${ + if user.email != null + then "email = ${user.email}" + else "" + } + ${ + if user.fullName != null + then "name = ${user.fullName}" + else "" + } + ${ + if user.gpgKeyId != null + then "signingkey = ${user.gpgKeyId}" + else "" + } + [core] + editor = /etc/profiles/per-user/${config.pub-solar.user.name}/bin/nvim + excludesFile = /home/${config.pub-solar.user.name}/.config/git/global_gitignore + [alias] + pol = pull + ack = -c color.grep.linenumber=\"bold yellow\"\n -c color.grep.filename=\"bold green\"\n -c color.grep.match=\"reverse yellow\"\n grep --break --heading --line-number + # define command which will be used when "nvim"is set as a merge tool + + [mergetool] + prompt = false + [merge] + tool = nvim + [mergetool "nvim"] + cmd = /etc/profiles/per-user/${config.pub-solar.user.name}/bin/nvim -f -c \"Gdiffsplit!\" \"$MERGED\" + + [commit] + gpgsign = true + template = ${xdg.configHome}/git/gitmessage + [tag] + gpgsign = true + [init] + defaultBranch = main + [pull] + rebase = false'' diff --git a/modules/terminal-life/.config/git/gitmessage.nix b/modules/terminal-life/.config/git/gitmessage.nix new file mode 100644 index 0000000..223bfc3 --- /dev/null +++ b/modules/terminal-life/.config/git/gitmessage.nix @@ -0,0 +1,32 @@ +{ + config, + pkgs, + ... +}: let + user = config.pub-solar.user; + xdg = config.home-manager.users."${user.name}".xdg; +in '' +# What happened? +# +# fix feat build chore ci docs style refactor perf test +# +# type!(optional scope):

--------------# +# + + +# ^\n +# What exactly was done and why? --------------------------------------# +# + + +# ^\n +# +# Any issue numbers or links? +# +# Ref: #123 + + +# ^\n +# +# Co-authored-by: Example Name +'' diff --git a/modules/terminal-life/.config/git/global_gitignore.nix b/modules/terminal-life/.config/git/global_gitignore.nix new file mode 100644 index 0000000..ece329a --- /dev/null +++ b/modules/terminal-life/.config/git/global_gitignore.nix @@ -0,0 +1,6 @@ +{ + config, + pkgs, + ... +}: let +in ''tags'' diff --git a/modules/terminal-life/.local/share/nvim/json-schemas/caddy_schema.json b/modules/terminal-life/.local/share/nvim/json-schemas/caddy_schema.json new file mode 100644 index 0000000..71873a0 --- /dev/null +++ b/modules/terminal-life/.local/share/nvim/json-schemas/caddy_schema.json @@ -0,0 +1,8087 @@ +{ + "title": "Caddy v2 autogenerated JSON schema \nhttps://github.com/abiosoft/caddy-json-schema", + "description": ": object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Config\nConfig is the top (or beginning) of the Caddy configuration structure.\nCaddy config is expressed natively as a JSON document. If you prefer\nnot to work with JSON directly, there are [many config adapters](/docs/config-adapters)\navailable that can convert various inputs into Caddy JSON.\n\nMany parts of this config are extensible through the use of Caddy modules.\nFields which have a json.RawMessage type and which appear as dots (•••) in\nthe online docs can be fulfilled by modules in a certain module\nnamespace. The docs show which modules can be used in a given place.\n\nWhenever a module is used, its name must be given either inline as part of\nthe module, or as the key to the module's value. The docs will make it clear\nwhich to use.\n\nGenerally, all config settings are optional, as it is Caddy convention to\nhave good, documented default values. If a parameter is required, the docs\nshould say so.\n\nGo programs which are directly building a Config struct value should take\ncare to populate the JSON-encodable fields of the struct (i.e. the fields\nwith `json` struct tags) if employing the module lifecycle (e.g. Provision\nmethod calls).\n\n", + "markdownDescription": ": `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Config) \nConfig is the top (or beginning) of the Caddy configuration structure.\nCaddy config is expressed natively as a JSON document. If you prefer\nnot to work with JSON directly, there are [many config adapters](/docs/config-adapters)\navailable that can convert various inputs into Caddy JSON.\n\nMany parts of this config are extensible through the use of Caddy modules.\nFields which have a json.RawMessage type and which appear as dots (•••) in\nthe online docs can be fulfilled by modules in a certain module\nnamespace. The docs show which modules can be used in a given place.\n\nWhenever a module is used, its name must be given either inline as part of\nthe module, or as the key to the module's value. The docs will make it clear\nwhich to use.\n\nGenerally, all config settings are optional, as it is Caddy convention to\nhave good, documented default values. If a parameter is required, the docs\nshould say so.\n\nGo programs which are directly building a Config struct value should take\ncare to populate the JSON-encodable fields of the struct (i.e. the fields\nwith `json` struct tags) if employing the module lifecycle (e.g. Provision\nmethod calls).\n \n", + "type": "object", + "definitions": { + "admin.api.load": { + "description": "load: object\nModule: admin.api.load", + "markdownDescription": "load: `object` \nModule: `admin.api.load`", + "type": "object" + }, + "admin.api.metrics": { + "description": "metrics: object\nModule: admin.api.metrics\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/metrics#AdminMetrics", + "markdownDescription": "metrics: `object` \nModule: `admin.api.metrics` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/metrics#AdminMetrics)", + "type": "object" + }, + "admin.api.pki": { + "description": "pki: object\nModule: admin.api.pki", + "markdownDescription": "pki: `object` \nModule: `admin.api.pki`", + "type": "object" + }, + "admin.api.reverse_proxy": { + "description": "reverse_proxy: object\nModule: admin.api.reverse_proxy", + "markdownDescription": "reverse_proxy: `object` \nModule: `admin.api.reverse_proxy`", + "type": "object" + }, + "caddy.adapters.caddyfile": { + "description": "caddyfile: object\nModule: caddy.adapters.caddyfile", + "markdownDescription": "caddyfile: `object` \nModule: `caddy.adapters.caddyfile`", + "type": "object" + }, + "caddy.config_loaders.http": { + "description": "http: object\nModule: caddy.config_loaders.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/caddyconfig#HTTPLoader\nHTTPLoader can load Caddy configs over HTTP(S). It can adapt the config\nbased on the Content-Type header of the HTTP response.\n\n", + "markdownDescription": "http: `object` \nModule: `caddy.config_loaders.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/caddyconfig#HTTPLoader) \nHTTPLoader can load Caddy configs over HTTP(S). It can adapt the config\nbased on the Content-Type header of the HTTP response.\n \n", + "type": "object", + "properties": { + "header": { + "description": "header: object\nModule: caddy.config_loaders.http\nHTTP headers to add to the request.\n", + "markdownDescription": "header: `object` \nModule: `caddy.config_loaders.http` \nHTTP headers to add to the request. \n", + "type": "object", + "additionalProperties": { + "description": "HTTP headers to add to the request.\n", + "markdownDescription": "HTTP headers to add to the request. \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "method": { + "description": "method: string\nModule: caddy.config_loaders.http\nThe method for the request. Default: GET\n", + "markdownDescription": "method: `string` \nModule: `caddy.config_loaders.http` \nThe method for the request. Default: GET \n", + "type": "string" + }, + "timeout": { + "description": "timeout: number\nModule: caddy.config_loaders.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nMaximum time allowed for a complete connection and request.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "timeout: `number` \nModule: `caddy.config_loaders.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nMaximum time allowed for a complete connection and request.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "tls": { + "description": "tls: object\nModule: caddy.config_loaders.http\n", + "markdownDescription": "tls: `object` \nModule: `caddy.config_loaders.http` \n", + "type": "object", + "properties": { + "client_certificate_file": { + "description": "client_certificate_file: string\nModule: caddy.config_loaders.http\n", + "markdownDescription": "client_certificate_file: `string` \nModule: `caddy.config_loaders.http` \n", + "type": "string" + }, + "client_certificate_key_file": { + "description": "client_certificate_key_file: string\nModule: caddy.config_loaders.http\n", + "markdownDescription": "client_certificate_key_file: `string` \nModule: `caddy.config_loaders.http` \n", + "type": "string" + }, + "root_ca_pem_files": { + "description": "root_ca_pem_files: array\nModule: caddy.config_loaders.http\n", + "markdownDescription": "root_ca_pem_files: `array` \nModule: `caddy.config_loaders.http` \n", + "type": "array", + "items": { + "type": "string" + } + }, + "use_server_identity": { + "description": "use_server_identity: boolean\nModule: caddy.config_loaders.http\n", + "markdownDescription": "use_server_identity: `boolean` \nModule: `caddy.config_loaders.http` \n", + "type": "boolean" + } + } + }, + "url": { + "description": "url: string\nModule: caddy.config_loaders.http\nThe URL of the request.\n", + "markdownDescription": "url: `string` \nModule: `caddy.config_loaders.http` \nThe URL of the request. \n", + "type": "string" + } + } + }, + "caddy.listeners.http_redirect": { + "description": "http_redirect: object\nModule: caddy.listeners.http_redirect\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#HTTPRedirectListenerWrapper\nHTTPRedirectListenerWrapper provides HTTP-\u003eHTTPS redirects for\nconnections that come on the TLS port as an HTTP request,\nby detecting using the first few bytes that it's not a TLS\nhandshake, but instead an HTTP request.\n\nThis is especially useful when using a non-standard HTTPS port.\nA user may simply type the address in their browser without the\nhttps:// scheme, which would cause the browser to attempt the\nconnection over HTTP, but this would cause a \"Client sent an\nHTTP request to an HTTPS server\" error response.\n\nThis listener wrapper must be placed BEFORE the \"tls\" listener\nwrapper, for it to work properly.\n\n", + "markdownDescription": "http_redirect: `object` \nModule: `caddy.listeners.http_redirect` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#HTTPRedirectListenerWrapper) \nHTTPRedirectListenerWrapper provides HTTP-\u003eHTTPS redirects for\nconnections that come on the TLS port as an HTTP request,\nby detecting using the first few bytes that it's not a TLS\nhandshake, but instead an HTTP request.\n\nThis is especially useful when using a non-standard HTTPS port.\nA user may simply type the address in their browser without the\nhttps:// scheme, which would cause the browser to attempt the\nconnection over HTTP, but this would cause a \"Client sent an\nHTTP request to an HTTPS server\" error response.\n\nThis listener wrapper must be placed BEFORE the \"tls\" listener\nwrapper, for it to work properly.\n \n", + "type": "object" + }, + "caddy.listeners.tls": { + "description": "tls: object\nModule: caddy.listeners.tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#tlsPlaceholderWrapper\ntlsPlaceholderWrapper is a no-op listener wrapper that marks\nwhere the TLS listener should be in a chain of listener wrappers.\nIt should only be used if another listener wrapper must be placed\nin front of the TLS handshake.\n\n", + "markdownDescription": "tls: `object` \nModule: `caddy.listeners.tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#tlsPlaceholderWrapper) \ntlsPlaceholderWrapper is a no-op listener wrapper that marks\nwhere the TLS listener should be in a chain of listener wrappers.\nIt should only be used if another listener wrapper must be placed\nin front of the TLS handshake.\n \n", + "type": "object" + }, + "caddy.logging.encoders.console": { + "description": "console: object\nModule: caddy.logging.encoders.console\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#ConsoleEncoder\nConsoleEncoder encodes log entries that are mostly human-readable.\n\n", + "markdownDescription": "console: `object` \nModule: `caddy.logging.encoders.console` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#ConsoleEncoder) \nConsoleEncoder encodes log entries that are mostly human-readable.\n \n", + "type": "object", + "properties": { + "caller_key": { + "description": "caller_key: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "caller_key: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + }, + "duration_format": { + "description": "duration_format: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "duration_format: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + }, + "level_format": { + "description": "level_format: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "level_format: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + }, + "level_key": { + "description": "level_key: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "level_key: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + }, + "line_ending": { + "description": "line_ending: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "line_ending: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + }, + "message_key": { + "description": "message_key: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "message_key: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + }, + "name_key": { + "description": "name_key: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "name_key: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + }, + "stacktrace_key": { + "description": "stacktrace_key: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "stacktrace_key: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + }, + "time_format": { + "description": "time_format: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "time_format: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + }, + "time_key": { + "description": "time_key: string\nModule: caddy.logging.encoders.console\n", + "markdownDescription": "time_key: `string` \nModule: `caddy.logging.encoders.console` \n", + "type": "string" + } + } + }, + "caddy.logging.encoders.filter": { + "description": "filter: object\nModule: caddy.logging.encoders.filter\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#FilterEncoder\nFilterEncoder can filter (manipulate) fields on\nlog entries before they are actually encoded by\nan underlying encoder.\n\n", + "markdownDescription": "filter: `object` \nModule: `caddy.logging.encoders.filter` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#FilterEncoder) \nFilterEncoder can filter (manipulate) fields on\nlog entries before they are actually encoded by\nan underlying encoder.\n \n", + "type": "object", + "properties": { + "fields": { + "description": "fields: object\nModule: caddy.logging.encoders.filter\nA map of field names to their filters. Note that this\nis not a module map; the keys are field names.\n\nNested fields can be referenced by representing a\nlayer of nesting with `\u003e`. In other words, for an\nobject like `{\"a\":{\"b\":0}}`, the inner field can\nbe referenced as `a\u003eb`.\n\nThe following fields are fundamental to the log and\ncannot be filtered because they are added by the\nunderlying logging library as special cases: ts,\nlevel, logger, and msg.\n", + "markdownDescription": "fields: `object` \nModule: `caddy.logging.encoders.filter` \nA map of field names to their filters. Note that this\nis not a module map; the keys are field names.\n\nNested fields can be referenced by representing a\nlayer of nesting with `\u003e`. In other words, for an\nobject like `{\"a\":{\"b\":0}}`, the inner field can\nbe referenced as `a\u003eb`.\n\nThe following fields are fundamental to the log and\ncannot be filtered because they are added by the\nunderlying logging library as special cases: ts,\nlevel, logger, and msg. \n", + "type": "object", + "additionalProperties": { + "required": [ + "filter" + ], + "allOf": [ + { + "if": { + "properties": { + "filter": { + "const": "rename" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter.rename" + } + }, + { + "if": { + "properties": { + "filter": { + "const": "replace" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter.replace" + } + }, + { + "if": { + "properties": { + "filter": { + "const": "cookie" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter.cookie" + } + }, + { + "if": { + "properties": { + "filter": { + "const": "delete" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter.delete" + } + }, + { + "if": { + "properties": { + "filter": { + "const": "hash" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter.hash" + } + }, + { + "if": { + "properties": { + "filter": { + "const": "ip_mask" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter.ip_mask" + } + }, + { + "if": { + "properties": { + "filter": { + "const": "query" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter.query" + } + }, + { + "if": { + "properties": { + "filter": { + "const": "regexp" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter.regexp" + } + }, + { + "properties": { + "filter": { + "description": "key to identify fields module.\nfilter: string\nModule: caddy.logging.encoders.filter", + "markdownDescription": "key to identify `fields` module. \nfilter: `string` \nModule: `caddy.logging.encoders.filter`", + "type": "string", + "enum": [ + "rename", + "replace", + "cookie", + "delete", + "hash", + "ip_mask", + "query", + "regexp" + ] + } + } + } + ] + } + }, + "wrap": { + "description": "wrap: object\nModule: caddy.logging.encoders\nThe underlying encoder that actually\nencodes the log entries. Required.\n", + "markdownDescription": "wrap: `object` \nModule: `caddy.logging.encoders` \nThe underlying encoder that actually\nencodes the log entries. Required. \n", + "type": "object", + "required": [ + "format" + ], + "allOf": [ + { + "if": { + "properties": { + "format": { + "const": "json" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.json" + } + }, + { + "if": { + "properties": { + "format": { + "const": "console" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.console" + } + }, + { + "if": { + "properties": { + "format": { + "const": "filter" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter" + } + }, + { + "properties": { + "format": { + "description": "key to identify wrap module.\nformat: string\nModule: caddy.logging.encoders", + "markdownDescription": "key to identify `wrap` module. \nformat: `string` \nModule: `caddy.logging.encoders`", + "type": "string", + "enum": [ + "json", + "console", + "filter" + ] + } + } + } + ] + } + } + }, + "caddy.logging.encoders.filter.cookie": { + "description": "cookie: object\nModule: caddy.logging.encoders.filter.cookie\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter", + "markdownDescription": "cookie: `object` \nModule: `caddy.logging.encoders.filter.cookie` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter)", + "type": "object", + "properties": { + "actions": { + "description": "actions: array\nModule: caddy.logging.encoders.filter.cookie\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter", + "markdownDescription": "actions: `array` \nModule: `caddy.logging.encoders.filter.cookie` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter)", + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "description": "name: string\nModule: caddy.logging.encoders.filter.cookie\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter", + "markdownDescription": "name: `string` \nModule: `caddy.logging.encoders.filter.cookie` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter)", + "type": "string" + }, + "type": { + "description": "type: string\nModule: caddy.logging.encoders.filter.cookie\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter", + "markdownDescription": "type: `string` \nModule: `caddy.logging.encoders.filter.cookie` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter)", + "type": "string" + }, + "value": { + "description": "value: string\nModule: caddy.logging.encoders.filter.cookie\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter", + "markdownDescription": "value: `string` \nModule: `caddy.logging.encoders.filter.cookie` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#CookieFilter)", + "type": "string" + } + } + } + } + } + }, + "caddy.logging.encoders.filter.delete": { + "description": "delete: object\nModule: caddy.logging.encoders.filter.delete\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#DeleteFilter", + "markdownDescription": "delete: `object` \nModule: `caddy.logging.encoders.filter.delete` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#DeleteFilter)", + "type": "object" + }, + "caddy.logging.encoders.filter.hash": { + "description": "hash: object\nModule: caddy.logging.encoders.filter.hash\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#HashFilter", + "markdownDescription": "hash: `object` \nModule: `caddy.logging.encoders.filter.hash` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#HashFilter)", + "type": "object" + }, + "caddy.logging.encoders.filter.ip_mask": { + "description": "ip_mask: object\nModule: caddy.logging.encoders.filter.ip_mask\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#IPMaskFilter", + "markdownDescription": "ip_mask: `object` \nModule: `caddy.logging.encoders.filter.ip_mask` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#IPMaskFilter)", + "type": "object", + "properties": { + "ipv4_cidr": { + "description": "ipv4_cidr: number\nModule: caddy.logging.encoders.filter.ip_mask\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#IPMaskFilter", + "markdownDescription": "ipv4_cidr: `number` \nModule: `caddy.logging.encoders.filter.ip_mask` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#IPMaskFilter)", + "type": "number" + }, + "ipv6_cidr": { + "description": "ipv6_cidr: number\nModule: caddy.logging.encoders.filter.ip_mask\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#IPMaskFilter", + "markdownDescription": "ipv6_cidr: `number` \nModule: `caddy.logging.encoders.filter.ip_mask` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#IPMaskFilter)", + "type": "number" + } + } + }, + "caddy.logging.encoders.filter.query": { + "description": "query: object\nModule: caddy.logging.encoders.filter.query\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter", + "markdownDescription": "query: `object` \nModule: `caddy.logging.encoders.filter.query` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter)", + "type": "object", + "properties": { + "actions": { + "description": "actions: array\nModule: caddy.logging.encoders.filter.query\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter", + "markdownDescription": "actions: `array` \nModule: `caddy.logging.encoders.filter.query` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter)", + "type": "array", + "items": { + "type": "object", + "properties": { + "parameter": { + "description": "parameter: string\nModule: caddy.logging.encoders.filter.query\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter", + "markdownDescription": "parameter: `string` \nModule: `caddy.logging.encoders.filter.query` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter)", + "type": "string" + }, + "type": { + "description": "type: string\nModule: caddy.logging.encoders.filter.query\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter", + "markdownDescription": "type: `string` \nModule: `caddy.logging.encoders.filter.query` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter)", + "type": "string" + }, + "value": { + "description": "value: string\nModule: caddy.logging.encoders.filter.query\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter", + "markdownDescription": "value: `string` \nModule: `caddy.logging.encoders.filter.query` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#QueryFilter)", + "type": "string" + } + } + } + } + } + }, + "caddy.logging.encoders.filter.regexp": { + "description": "regexp: object\nModule: caddy.logging.encoders.filter.regexp\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RegexpFilter", + "markdownDescription": "regexp: `object` \nModule: `caddy.logging.encoders.filter.regexp` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RegexpFilter)", + "type": "object", + "properties": { + "regexp": { + "description": "regexp: string\nModule: caddy.logging.encoders.filter.regexp\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RegexpFilter", + "markdownDescription": "regexp: `string` \nModule: `caddy.logging.encoders.filter.regexp` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RegexpFilter)", + "type": "string" + }, + "value": { + "description": "value: string\nModule: caddy.logging.encoders.filter.regexp\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RegexpFilter", + "markdownDescription": "value: `string` \nModule: `caddy.logging.encoders.filter.regexp` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RegexpFilter)", + "type": "string" + } + } + }, + "caddy.logging.encoders.filter.rename": { + "description": "rename: object\nModule: caddy.logging.encoders.filter.rename\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RenameFilter", + "markdownDescription": "rename: `object` \nModule: `caddy.logging.encoders.filter.rename` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RenameFilter)", + "type": "object", + "properties": { + "name": { + "description": "name: string\nModule: caddy.logging.encoders.filter.rename\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RenameFilter", + "markdownDescription": "name: `string` \nModule: `caddy.logging.encoders.filter.rename` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#RenameFilter)", + "type": "string" + } + } + }, + "caddy.logging.encoders.filter.replace": { + "description": "replace: object\nModule: caddy.logging.encoders.filter.replace\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#ReplaceFilter", + "markdownDescription": "replace: `object` \nModule: `caddy.logging.encoders.filter.replace` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#ReplaceFilter)", + "type": "object", + "properties": { + "value": { + "description": "value: string\nModule: caddy.logging.encoders.filter.replace\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#ReplaceFilter", + "markdownDescription": "value: `string` \nModule: `caddy.logging.encoders.filter.replace` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#ReplaceFilter)", + "type": "string" + } + } + }, + "caddy.logging.encoders.json": { + "description": "json: object\nModule: caddy.logging.encoders.json\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#JSONEncoder\nJSONEncoder encodes entries as JSON.\n\n", + "markdownDescription": "json: `object` \nModule: `caddy.logging.encoders.json` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#JSONEncoder) \nJSONEncoder encodes entries as JSON.\n \n", + "type": "object", + "properties": { + "caller_key": { + "description": "caller_key: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "caller_key: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + }, + "duration_format": { + "description": "duration_format: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "duration_format: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + }, + "level_format": { + "description": "level_format: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "level_format: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + }, + "level_key": { + "description": "level_key: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "level_key: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + }, + "line_ending": { + "description": "line_ending: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "line_ending: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + }, + "message_key": { + "description": "message_key: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "message_key: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + }, + "name_key": { + "description": "name_key: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "name_key: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + }, + "stacktrace_key": { + "description": "stacktrace_key: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "stacktrace_key: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + }, + "time_format": { + "description": "time_format: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "time_format: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + }, + "time_key": { + "description": "time_key: string\nModule: caddy.logging.encoders.json\n", + "markdownDescription": "time_key: `string` \nModule: `caddy.logging.encoders.json` \n", + "type": "string" + } + } + }, + "caddy.logging.writers.discard": { + "description": "discard: object\nModule: caddy.logging.writers.discard\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#DiscardWriter\nDiscardWriter discards all writes.\n\n", + "markdownDescription": "discard: `object` \nModule: `caddy.logging.writers.discard` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#DiscardWriter) \nDiscardWriter discards all writes.\n \n", + "type": "object" + }, + "caddy.logging.writers.file": { + "description": "file: object\nModule: caddy.logging.writers.file\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#FileWriter\nFileWriter can write logs to files. By default, log files\nare rotated (\"rolled\") when they get large, and old log\nfiles get deleted, to ensure that the process does not\nexhaust disk space.\n\n", + "markdownDescription": "file: `object` \nModule: `caddy.logging.writers.file` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#FileWriter) \nFileWriter can write logs to files. By default, log files\nare rotated (\"rolled\") when they get large, and old log\nfiles get deleted, to ensure that the process does not\nexhaust disk space.\n \n", + "type": "object", + "properties": { + "filename": { + "description": "filename: string\nModule: caddy.logging.writers.file\nFilename is the name of the file to write.\n", + "markdownDescription": "filename: `string` \nModule: `caddy.logging.writers.file` \nFilename is the name of the file to write. \n", + "type": "string" + }, + "roll": { + "description": "roll: boolean\nModule: caddy.logging.writers.file\nRoll toggles log rolling or rotation, which is\nenabled by default.\n", + "markdownDescription": "roll: `boolean` \nModule: `caddy.logging.writers.file` \nRoll toggles log rolling or rotation, which is\nenabled by default. \n", + "type": "boolean" + }, + "roll_gzip": { + "description": "roll_gzip: boolean\nModule: caddy.logging.writers.file\nWhether to compress rolled files. Default: true\n", + "markdownDescription": "roll_gzip: `boolean` \nModule: `caddy.logging.writers.file` \nWhether to compress rolled files. Default: true \n", + "type": "boolean" + }, + "roll_keep": { + "description": "roll_keep: number\nModule: caddy.logging.writers.file\nThe maximum number of rolled log files to keep.\nDefault: 10\n", + "markdownDescription": "roll_keep: `number` \nModule: `caddy.logging.writers.file` \nThe maximum number of rolled log files to keep.\nDefault: 10 \n", + "type": "number" + }, + "roll_keep_days": { + "description": "roll_keep_days: number\nModule: caddy.logging.writers.file\nHow many days to keep rolled log files. Default: 90\n", + "markdownDescription": "roll_keep_days: `number` \nModule: `caddy.logging.writers.file` \nHow many days to keep rolled log files. Default: 90 \n", + "type": "number" + }, + "roll_local_time": { + "description": "roll_local_time: boolean\nModule: caddy.logging.writers.file\nWhether to use local timestamps in rolled filenames.\nDefault: false\n", + "markdownDescription": "roll_local_time: `boolean` \nModule: `caddy.logging.writers.file` \nWhether to use local timestamps in rolled filenames.\nDefault: false \n", + "type": "boolean" + }, + "roll_size_mb": { + "description": "roll_size_mb: number\nModule: caddy.logging.writers.file\nWhen a log file reaches approximately this size,\nit will be rotated.\n", + "markdownDescription": "roll_size_mb: `number` \nModule: `caddy.logging.writers.file` \nWhen a log file reaches approximately this size,\nit will be rotated. \n", + "type": "number" + } + } + }, + "caddy.logging.writers.net": { + "description": "net: object\nModule: caddy.logging.writers.net\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#NetWriter\nNetWriter implements a log writer that outputs to a network socket. If\nthe socket goes down, it will dump logs to stderr while it attempts to\nreconnect.\n\n", + "markdownDescription": "net: `object` \nModule: `caddy.logging.writers.net` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/logging#NetWriter) \nNetWriter implements a log writer that outputs to a network socket. If\nthe socket goes down, it will dump logs to stderr while it attempts to\nreconnect.\n \n", + "type": "object", + "properties": { + "address": { + "description": "address: string\nModule: caddy.logging.writers.net\nThe address of the network socket to which to connect.\n", + "markdownDescription": "address: `string` \nModule: `caddy.logging.writers.net` \nThe address of the network socket to which to connect. \n", + "type": "string" + }, + "dial_timeout": { + "description": "dial_timeout: number\nModule: caddy.logging.writers.net\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nThe timeout to wait while connecting to the socket.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "dial_timeout: `number` \nModule: `caddy.logging.writers.net` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nThe timeout to wait while connecting to the socket.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + }, + "caddy.logging.writers.stderr": { + "description": "stderr: object\nModule: caddy.logging.writers.stderr\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#StderrWriter\nStderrWriter writes logs to standard error.\n\n", + "markdownDescription": "stderr: `object` \nModule: `caddy.logging.writers.stderr` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#StderrWriter) \nStderrWriter writes logs to standard error.\n \n", + "type": "object" + }, + "caddy.logging.writers.stdout": { + "description": "stdout: object\nModule: caddy.logging.writers.stdout\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#StdoutWriter\nStdoutWriter writes logs to standard out.\n\n", + "markdownDescription": "stdout: `object` \nModule: `caddy.logging.writers.stdout` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#StdoutWriter) \nStdoutWriter writes logs to standard out.\n \n", + "type": "object" + }, + "caddy.storage.consul": { + "description": "consul: object\nModule: caddy.storage.consul\nhttps://pkg.go.dev/github.com/pteich/caddy-tlsconsul#ConsulStorage\nConsulStorage allows to store certificates and other TLS resources\nin a shared cluster environment using Consul's key/value-store.\nIt uses distributed locks to ensure consistency.\n\n", + "markdownDescription": "consul: `object` \nModule: `caddy.storage.consul` \n[godoc](https://pkg.go.dev/github.com/pteich/caddy-tlsconsul#ConsulStorage) \nConsulStorage allows to store certificates and other TLS resources\nin a shared cluster environment using Consul's key/value-store.\nIt uses distributed locks to ensure consistency.\n \n", + "type": "object", + "properties": { + "address": { + "description": "address: string\nModule: caddy.storage.consul\n", + "markdownDescription": "address: `string` \nModule: `caddy.storage.consul` \n", + "type": "string" + }, + "aes_key": { + "description": "aes_key: array\nModule: caddy.storage.consul\n", + "markdownDescription": "aes_key: `array` \nModule: `caddy.storage.consul` \n", + "type": "array", + "items": { + "type": "number" + } + }, + "prefix": { + "description": "prefix: string\nModule: caddy.storage.consul\n", + "markdownDescription": "prefix: `string` \nModule: `caddy.storage.consul` \n", + "type": "string" + }, + "timeout": { + "description": "timeout: number\nModule: caddy.storage.consul\n", + "markdownDescription": "timeout: `number` \nModule: `caddy.storage.consul` \n", + "type": "number" + }, + "tls_enabled": { + "description": "tls_enabled: boolean\nModule: caddy.storage.consul\n", + "markdownDescription": "tls_enabled: `boolean` \nModule: `caddy.storage.consul` \n", + "type": "boolean" + }, + "tls_insecure": { + "description": "tls_insecure: boolean\nModule: caddy.storage.consul\n", + "markdownDescription": "tls_insecure: `boolean` \nModule: `caddy.storage.consul` \n", + "type": "boolean" + }, + "token": { + "description": "token: string\nModule: caddy.storage.consul\n", + "markdownDescription": "token: `string` \nModule: `caddy.storage.consul` \n", + "type": "string" + }, + "value_prefix": { + "description": "value_prefix: string\nModule: caddy.storage.consul\n", + "markdownDescription": "value_prefix: `string` \nModule: `caddy.storage.consul` \n", + "type": "string" + } + } + }, + "caddy.storage.file_system": { + "description": "file_system: object\nModule: caddy.storage.file_system\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/filestorage#FileStorage\nFileStorage is a certmagic.Storage wrapper for certmagic.FileStorage.\n\n", + "markdownDescription": "file_system: `object` \nModule: `caddy.storage.file_system` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/filestorage#FileStorage) \nFileStorage is a certmagic.Storage wrapper for certmagic.FileStorage.\n \n", + "type": "object", + "properties": { + "root": { + "description": "root: string\nModule: caddy.storage.file_system\nThe base path to the folder used for storage.\n", + "markdownDescription": "root: `string` \nModule: `caddy.storage.file_system` \nThe base path to the folder used for storage. \n", + "type": "string" + } + } + }, + "http": { + "description": "http: object\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#App\nApp is a robust, production-ready HTTP server.\n\nHTTPS is enabled by default if host matchers with qualifying names are used\nin any of routes; certificates are automatically provisioned and renewed.\nAdditionally, automatic HTTPS will also enable HTTPS for servers that listen\nonly on the HTTPS port but which do not have any TLS connection policies\ndefined by adding a good, default TLS connection policy.\n\nIn HTTP routes, additional placeholders are available (replace any `*`):\n\nPlaceholder | Description\n------------|---------------\n`{http.request.body}` | The request body (⚠️ inefficient; use only for debugging)\n`{http.request.cookie.*}` | HTTP request cookie\n`{http.request.duration}` | Time up to now spent handling the request (after decoding headers from client)\n`{http.request.duration_ms}` | Same as 'duration', but in milliseconds.\n`{http.request.uuid}` | The request unique identifier\n`{http.request.header.*}` | Specific request header field\n`{http.request.host.labels.*}` | Request host labels (0-based from right); e.g. for foo.example.com: 0=com, 1=example, 2=foo\n`{http.request.host}` | The host part of the request's Host header\n`{http.request.hostport}` | The host and port from the request's Host header\n`{http.request.method}` | The request method\n`{http.request.orig_method}` | The request's original method\n`{http.request.orig_uri.path.dir}` | The request's original directory\n`{http.request.orig_uri.path.file}` | The request's original filename\n`{http.request.orig_uri.path}` | The request's original path\n`{http.request.orig_uri.query}` | The request's original query string (without `?`)\n`{http.request.orig_uri}` | The request's original URI\n`{http.request.port}` | The port part of the request's Host header\n`{http.request.proto}` | The protocol of the request\n`{http.request.remote.host}` | The host part of the remote client's address\n`{http.request.remote.port}` | The port part of the remote client's address\n`{http.request.remote}` | The address of the remote client\n`{http.request.scheme}` | The request scheme\n`{http.request.tls.version}` | The TLS version name\n`{http.request.tls.cipher_suite}` | The TLS cipher suite\n`{http.request.tls.resumed}` | The TLS connection resumed a previous connection\n`{http.request.tls.proto}` | The negotiated next protocol\n`{http.request.tls.proto_mutual}` | The negotiated next protocol was advertised by the server\n`{http.request.tls.server_name}` | The server name requested by the client, if any\n`{http.request.tls.client.fingerprint}` | The SHA256 checksum of the client certificate\n`{http.request.tls.client.public_key}` | The public key of the client certificate.\n`{http.request.tls.client.public_key_sha256}` | The SHA256 checksum of the client's public key.\n`{http.request.tls.client.certificate_pem}` | The PEM-encoded value of the certificate.\n`{http.request.tls.client.certificate_der_base64}` | The base64-encoded value of the certificate.\n`{http.request.tls.client.issuer}` | The issuer DN of the client certificate\n`{http.request.tls.client.serial}` | The serial number of the client certificate\n`{http.request.tls.client.subject}` | The subject DN of the client certificate\n`{http.request.tls.client.san.dns_names.*}` | SAN DNS names(index optional)\n`{http.request.tls.client.san.emails.*}` | SAN email addresses (index optional)\n`{http.request.tls.client.san.ips.*}` | SAN IP addresses (index optional)\n`{http.request.tls.client.san.uris.*}` | SAN URIs (index optional)\n`{http.request.uri.path.*}` | Parts of the path, split by `/` (0-based from left)\n`{http.request.uri.path.dir}` | The directory, excluding leaf filename\n`{http.request.uri.path.file}` | The filename of the path, excluding directory\n`{http.request.uri.path}` | The path component of the request URI\n`{http.request.uri.query.*}` | Individual query string value\n`{http.request.uri.query}` | The query string (without `?`)\n`{http.request.uri}` | The full request URI\n`{http.response.header.*}` | Specific response header field\n`{http.vars.*}` | Custom variables in the HTTP handler chain\n\n", + "markdownDescription": "http: `object` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#App) \nApp is a robust, production-ready HTTP server.\n\nHTTPS is enabled by default if host matchers with qualifying names are used\nin any of routes; certificates are automatically provisioned and renewed.\nAdditionally, automatic HTTPS will also enable HTTPS for servers that listen\nonly on the HTTPS port but which do not have any TLS connection policies\ndefined by adding a good, default TLS connection policy.\n\nIn HTTP routes, additional placeholders are available (replace any `*`):\n\nPlaceholder | Description\n------------|---------------\n`{http.request.body}` | The request body (⚠️ inefficient; use only for debugging)\n`{http.request.cookie.*}` | HTTP request cookie\n`{http.request.duration}` | Time up to now spent handling the request (after decoding headers from client)\n`{http.request.duration_ms}` | Same as 'duration', but in milliseconds.\n`{http.request.uuid}` | The request unique identifier\n`{http.request.header.*}` | Specific request header field\n`{http.request.host.labels.*}` | Request host labels (0-based from right); e.g. for foo.example.com: 0=com, 1=example, 2=foo\n`{http.request.host}` | The host part of the request's Host header\n`{http.request.hostport}` | The host and port from the request's Host header\n`{http.request.method}` | The request method\n`{http.request.orig_method}` | The request's original method\n`{http.request.orig_uri.path.dir}` | The request's original directory\n`{http.request.orig_uri.path.file}` | The request's original filename\n`{http.request.orig_uri.path}` | The request's original path\n`{http.request.orig_uri.query}` | The request's original query string (without `?`)\n`{http.request.orig_uri}` | The request's original URI\n`{http.request.port}` | The port part of the request's Host header\n`{http.request.proto}` | The protocol of the request\n`{http.request.remote.host}` | The host part of the remote client's address\n`{http.request.remote.port}` | The port part of the remote client's address\n`{http.request.remote}` | The address of the remote client\n`{http.request.scheme}` | The request scheme\n`{http.request.tls.version}` | The TLS version name\n`{http.request.tls.cipher_suite}` | The TLS cipher suite\n`{http.request.tls.resumed}` | The TLS connection resumed a previous connection\n`{http.request.tls.proto}` | The negotiated next protocol\n`{http.request.tls.proto_mutual}` | The negotiated next protocol was advertised by the server\n`{http.request.tls.server_name}` | The server name requested by the client, if any\n`{http.request.tls.client.fingerprint}` | The SHA256 checksum of the client certificate\n`{http.request.tls.client.public_key}` | The public key of the client certificate.\n`{http.request.tls.client.public_key_sha256}` | The SHA256 checksum of the client's public key.\n`{http.request.tls.client.certificate_pem}` | The PEM-encoded value of the certificate.\n`{http.request.tls.client.certificate_der_base64}` | The base64-encoded value of the certificate.\n`{http.request.tls.client.issuer}` | The issuer DN of the client certificate\n`{http.request.tls.client.serial}` | The serial number of the client certificate\n`{http.request.tls.client.subject}` | The subject DN of the client certificate\n`{http.request.tls.client.san.dns_names.*}` | SAN DNS names(index optional)\n`{http.request.tls.client.san.emails.*}` | SAN email addresses (index optional)\n`{http.request.tls.client.san.ips.*}` | SAN IP addresses (index optional)\n`{http.request.tls.client.san.uris.*}` | SAN URIs (index optional)\n`{http.request.uri.path.*}` | Parts of the path, split by `/` (0-based from left)\n`{http.request.uri.path.dir}` | The directory, excluding leaf filename\n`{http.request.uri.path.file}` | The filename of the path, excluding directory\n`{http.request.uri.path}` | The path component of the request URI\n`{http.request.uri.query.*}` | Individual query string value\n`{http.request.uri.query}` | The query string (without `?`)\n`{http.request.uri}` | The full request URI\n`{http.response.header.*}` | Specific response header field\n`{http.vars.*}` | Custom variables in the HTTP handler chain\n \n", + "type": "object", + "properties": { + "grace_period": { + "description": "grace_period: number\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nGracePeriod is how long to wait for active connections when shutting\ndown the server. Once the grace period is over, connections will\nbe forcefully closed.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "grace_period: `number` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nGracePeriod is how long to wait for active connections when shutting\ndown the server. Once the grace period is over, connections will\nbe forcefully closed.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "http_port": { + "description": "http_port: number\nModule: http\nHTTPPort specifies the port to use for HTTP (as opposed to HTTPS),\nwhich is used when setting up HTTP-\u003eHTTPS redirects or ACME HTTP\nchallenge solvers. Default: 80.\n", + "markdownDescription": "http_port: `number` \nModule: `http` \nHTTPPort specifies the port to use for HTTP (as opposed to HTTPS),\nwhich is used when setting up HTTP-\u003eHTTPS redirects or ACME HTTP\nchallenge solvers. Default: 80. \n", + "type": "number" + }, + "https_port": { + "description": "https_port: number\nModule: http\nHTTPSPort specifies the port to use for HTTPS, which is used when\nsolving the ACME TLS-ALPN challenges, or whenever HTTPS is needed\nbut no specific port number is given. Default: 443.\n", + "markdownDescription": "https_port: `number` \nModule: `http` \nHTTPSPort specifies the port to use for HTTPS, which is used when\nsolving the ACME TLS-ALPN challenges, or whenever HTTPS is needed\nbut no specific port number is given. Default: 443. \n", + "type": "number" + }, + "servers": { + "description": "servers: object\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Server\nServers is the list of servers, keyed by arbitrary names chosen\nat your discretion for your own convenience; the keys do not\naffect functionality.\n\n\nServer describes an HTTP server.\n", + "markdownDescription": "servers: `object` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Server) \nServers is the list of servers, keyed by arbitrary names chosen\nat your discretion for your own convenience; the keys do not\naffect functionality.\n\n\nServer describes an HTTP server. \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Server\nServers is the list of servers, keyed by arbitrary names chosen\nat your discretion for your own convenience; the keys do not\naffect functionality.\n\n\nServer describes an HTTP server.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Server) \nServers is the list of servers, keyed by arbitrary names chosen\nat your discretion for your own convenience; the keys do not\naffect functionality.\n\n\nServer describes an HTTP server. \n", + "properties": { + "allow_h2c": { + "description": "allow_h2c: boolean\nModule: http\nEnables H2C (\"Cleartext HTTP/2\" or \"H2 over TCP\") support,\nwhich will serve HTTP/2 over plaintext TCP connections if\nthe client supports it. Because this is not implemented by the\nGo standard library, using H2C is incompatible with most\nof the other options for this server. Do not enable this\nonly to achieve maximum client compatibility. In practice,\nvery few clients implement H2C, and even fewer require it.\nThis setting applies only to unencrypted HTTP listeners.\n⚠️ Experimental feature; subject to change or removal.\n", + "markdownDescription": "allow_h2c: `boolean` \nModule: `http` \nEnables H2C (\"Cleartext HTTP/2\" or \"H2 over TCP\") support,\nwhich will serve HTTP/2 over plaintext TCP connections if\nthe client supports it. Because this is not implemented by the\nGo standard library, using H2C is incompatible with most\nof the other options for this server. Do not enable this\nonly to achieve maximum client compatibility. In practice,\nvery few clients implement H2C, and even fewer require it.\nThis setting applies only to unencrypted HTTP listeners.\n⚠️ Experimental feature; subject to change or removal. \n", + "type": "boolean" + }, + "automatic_https": { + "description": "automatic_https: object\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#AutoHTTPSConfig\nAutoHTTPS configures or disables automatic HTTPS within this server.\nHTTPS is enabled automatically and by default when qualifying names\nare present in a Host matcher and/or when the server is listening\nonly on the HTTPS port.\n\n\nAutoHTTPSConfig is used to disable automatic HTTPS\nor certain aspects of it for a specific server.\nHTTPS is enabled automatically and by default when\nqualifying hostnames are available from the config.\n", + "markdownDescription": "automatic_https: `object` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#AutoHTTPSConfig) \nAutoHTTPS configures or disables automatic HTTPS within this server.\nHTTPS is enabled automatically and by default when qualifying names\nare present in a Host matcher and/or when the server is listening\nonly on the HTTPS port.\n\n\nAutoHTTPSConfig is used to disable automatic HTTPS\nor certain aspects of it for a specific server.\nHTTPS is enabled automatically and by default when\nqualifying hostnames are available from the config. \n", + "type": "object", + "properties": { + "disable": { + "description": "disable: boolean\nModule: http\nIf true, automatic HTTPS will be entirely disabled,\nincluding certificate management and redirects.\n", + "markdownDescription": "disable: `boolean` \nModule: `http` \nIf true, automatic HTTPS will be entirely disabled,\nincluding certificate management and redirects. \n", + "type": "boolean" + }, + "disable_certificates": { + "description": "disable_certificates: boolean\nModule: http\nIf true, automatic certificate management will be\ndisabled, but other auto-HTTPS features will\nremain enabled.\n", + "markdownDescription": "disable_certificates: `boolean` \nModule: `http` \nIf true, automatic certificate management will be\ndisabled, but other auto-HTTPS features will\nremain enabled. \n", + "type": "boolean" + }, + "disable_redirects": { + "description": "disable_redirects: boolean\nModule: http\nIf true, only automatic HTTP-\u003eHTTPS redirects will\nbe disabled, but other auto-HTTPS features will\nremain enabled.\n", + "markdownDescription": "disable_redirects: `boolean` \nModule: `http` \nIf true, only automatic HTTP-\u003eHTTPS redirects will\nbe disabled, but other auto-HTTPS features will\nremain enabled. \n", + "type": "boolean" + }, + "ignore_loaded_certificates": { + "description": "ignore_loaded_certificates: boolean\nModule: http\nBy default, automatic HTTPS will obtain and renew\ncertificates for qualifying hostnames. However, if\na certificate with a matching SAN is already loaded\ninto the cache, certificate management will not be\nenabled. To force automated certificate management\nregardless of loaded certificates, set this to true.\n", + "markdownDescription": "ignore_loaded_certificates: `boolean` \nModule: `http` \nBy default, automatic HTTPS will obtain and renew\ncertificates for qualifying hostnames. However, if\na certificate with a matching SAN is already loaded\ninto the cache, certificate management will not be\nenabled. To force automated certificate management\nregardless of loaded certificates, set this to true. \n", + "type": "boolean" + }, + "skip": { + "description": "skip: array\nModule: http\nHosts/domain names listed here will not be included\nin automatic HTTPS (they will not have certificates\nloaded nor redirects applied).\n", + "markdownDescription": "skip: `array` \nModule: `http` \nHosts/domain names listed here will not be included\nin automatic HTTPS (they will not have certificates\nloaded nor redirects applied). \n", + "type": "array", + "items": { + "description": "Hosts/domain names listed here will not be included\nin automatic HTTPS (they will not have certificates\nloaded nor redirects applied).\n", + "markdownDescription": "Hosts/domain names listed here will not be included\nin automatic HTTPS (they will not have certificates\nloaded nor redirects applied). \n", + "type": "string" + } + }, + "skip_certificates": { + "description": "skip_certificates: array\nModule: http\nHosts/domain names listed here will still be enabled\nfor automatic HTTPS (unless in the Skip list), except\nthat certificates will not be provisioned and managed\nfor these names.\n", + "markdownDescription": "skip_certificates: `array` \nModule: `http` \nHosts/domain names listed here will still be enabled\nfor automatic HTTPS (unless in the Skip list), except\nthat certificates will not be provisioned and managed\nfor these names. \n", + "type": "array", + "items": { + "description": "Hosts/domain names listed here will still be enabled\nfor automatic HTTPS (unless in the Skip list), except\nthat certificates will not be provisioned and managed\nfor these names.\n", + "markdownDescription": "Hosts/domain names listed here will still be enabled\nfor automatic HTTPS (unless in the Skip list), except\nthat certificates will not be provisioned and managed\nfor these names. \n", + "type": "string" + } + } + } + }, + "errors": { + "description": "errors: object\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#HTTPErrorConfig\nErrors is how this server will handle errors returned from any\nof the handlers in the primary routes. If the primary handler\nchain returns an error, the error along with its recommended\nstatus code are bubbled back up to the HTTP server which\nexecutes a separate error route, specified using this property.\nThe error routes work exactly like the normal routes.\n\n\nHTTPErrorConfig determines how to handle errors\nfrom the HTTP handlers.\n", + "markdownDescription": "errors: `object` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#HTTPErrorConfig) \nErrors is how this server will handle errors returned from any\nof the handlers in the primary routes. If the primary handler\nchain returns an error, the error along with its recommended\nstatus code are bubbled back up to the HTTP server which\nexecutes a separate error route, specified using this property.\nThe error routes work exactly like the normal routes.\n\n\nHTTPErrorConfig determines how to handle errors\nfrom the HTTP handlers. \n", + "type": "object", + "properties": { + "routes": { + "description": "routes: array\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nThe routes to evaluate after the primary handler\nchain returns an error. In an error route, extra\nplaceholders are available:\n\nPlaceholder | Description\n------------|---------------\n`{http.error.status_code}` | The recommended HTTP status code\n`{http.error.status_text}` | The status text associated with the recommended status code\n`{http.error.message}` | The error message\n`{http.error.trace}` | The origin of the error\n`{http.error.id}` | An identifier for this occurrence of the error\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "routes: `array` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nThe routes to evaluate after the primary handler\nchain returns an error. In an error route, extra\nplaceholders are available:\n\nPlaceholder | Description\n------------|---------------\n`{http.error.status_code}` | The recommended HTTP status code\n`{http.error.status_text}` | The status text associated with the recommended status code\n`{http.error.message}` | The error message\n`{http.error.trace}` | The origin of the error\n`{http.error.id}` | An identifier for this occurrence of the error\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nThe routes to evaluate after the primary handler\nchain returns an error. In an error route, extra\nplaceholders are available:\n\nPlaceholder | Description\n------------|---------------\n`{http.error.status_code}` | The recommended HTTP status code\n`{http.error.status_text}` | The status text associated with the recommended status code\n`{http.error.message}` | The error message\n`{http.error.trace}` | The origin of the error\n`{http.error.id}` | An identifier for this occurrence of the error\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nThe routes to evaluate after the primary handler\nchain returns an error. In an error route, extra\nplaceholders are available:\n\nPlaceholder | Description\n------------|---------------\n`{http.error.status_code}` | The recommended HTTP status code\n`{http.error.status_text}` | The status text associated with the recommended status code\n`{http.error.message}` | The error message\n`{http.error.trace}` | The origin of the error\n`{http.error.id}` | An identifier for this occurrence of the error\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "object", + "properties": { + "group": { + "description": "group: string\nModule: http\nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed.\n", + "markdownDescription": "group: `string` \nModule: `http` \nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed. \n", + "type": "string" + }, + "handle": { + "description": "handle: array\nModule: http.handlers\nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "handle: `array` \nModule: `http.handlers` \nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "type": "array", + "items": { + "description": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "required": [ + "handler" + ], + "allOf": [ + { + "if": { + "properties": { + "handler": { + "const": "headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "metrics" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.metrics" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "request_body" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.request_body" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "rewrite" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.rewrite" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "subroute" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.subroute" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tracing" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.tracing" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "encode" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.encode" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "static_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.static_response" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "authentication" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.authentication" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response_headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response_headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "error" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.error" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "file_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.file_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "map" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.map" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "reverse_proxy" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.reverse_proxy" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "templates" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.templates" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "acme_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.acme_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "vars" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.vars" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "push" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.push" + } + }, + { + "properties": { + "handler": { + "description": "key to identify handle module.\nhandler: string\nModule: http.handlers", + "markdownDescription": "key to identify `handle` module. \nhandler: `string` \nModule: `http.handlers`", + "type": "string", + "enum": [ + "headers", + "metrics", + "request_body", + "rewrite", + "subroute", + "tracing", + "encode", + "static_response", + "authentication", + "copy_response", + "copy_response_headers", + "error", + "file_server", + "map", + "reverse_proxy", + "templates", + "acme_server", + "vars", + "push" + ] + } + } + } + ] + } + }, + "match": { + "description": "match: array\nModule: http.matchers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "match: `array` \nModule: `http.matchers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "properties": { + "expression": { + "$ref": "#/definitions/http.matchers.expression" + }, + "file": { + "$ref": "#/definitions/http.matchers.file" + }, + "header": { + "$ref": "#/definitions/http.matchers.header" + }, + "header_regexp": { + "$ref": "#/definitions/http.matchers.header_regexp" + }, + "host": { + "$ref": "#/definitions/http.matchers.host" + }, + "method": { + "$ref": "#/definitions/http.matchers.method" + }, + "not": { + "$ref": "#/definitions/http.matchers.not" + }, + "path": { + "$ref": "#/definitions/http.matchers.path" + }, + "path_regexp": { + "$ref": "#/definitions/http.matchers.path_regexp" + }, + "protocol": { + "$ref": "#/definitions/http.matchers.protocol" + }, + "query": { + "$ref": "#/definitions/http.matchers.query" + }, + "remote_ip": { + "$ref": "#/definitions/http.matchers.remote_ip" + }, + "vars": { + "$ref": "#/definitions/http.matchers.vars" + }, + "vars_regexp": { + "$ref": "#/definitions/http.matchers.vars_regexp" + } + } + } + }, + "terminal": { + "description": "terminal: boolean\nModule: http\nIf true, no more routes will be executed after this one.\n", + "markdownDescription": "terminal: `boolean` \nModule: `http` \nIf true, no more routes will be executed after this one. \n", + "type": "boolean" + } + } + } + } + } + }, + "experimental_http3": { + "description": "experimental_http3: boolean\nModule: http\nEnable experimental HTTP/3 support. Note that HTTP/3 is not a\nfinished standard and has extremely limited client support.\nThis field is not subject to compatibility promises.\n", + "markdownDescription": "experimental_http3: `boolean` \nModule: `http` \nEnable experimental HTTP/3 support. Note that HTTP/3 is not a\nfinished standard and has extremely limited client support.\nThis field is not subject to compatibility promises. \n", + "type": "boolean" + }, + "idle_timeout": { + "description": "idle_timeout: number\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nIdleTimeout is the maximum time to wait for the next request\nwhen keep-alives are enabled. If zero, a default timeout of\n5m is applied to help avoid resource exhaustion.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "idle_timeout: `number` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nIdleTimeout is the maximum time to wait for the next request\nwhen keep-alives are enabled. If zero, a default timeout of\n5m is applied to help avoid resource exhaustion.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "listen": { + "description": "listen: array\nModule: http\nSocket addresses to which to bind listeners. Accepts\n[network addresses](/docs/conventions#network-addresses)\nthat may include port ranges. Listener addresses must\nbe unique; they cannot be repeated across all defined\nservers.\n", + "markdownDescription": "listen: `array` \nModule: `http` \nSocket addresses to which to bind listeners. Accepts\n[network addresses](/docs/conventions#network-addresses)\nthat may include port ranges. Listener addresses must\nbe unique; they cannot be repeated across all defined\nservers. \n", + "type": "array", + "items": { + "description": "Socket addresses to which to bind listeners. Accepts\n[network addresses](/docs/conventions#network-addresses)\nthat may include port ranges. Listener addresses must\nbe unique; they cannot be repeated across all defined\nservers.\n", + "markdownDescription": "Socket addresses to which to bind listeners. Accepts\n[network addresses](/docs/conventions#network-addresses)\nthat may include port ranges. Listener addresses must\nbe unique; they cannot be repeated across all defined\nservers. \n", + "type": "string" + } + }, + "listener_wrappers": { + "description": "listener_wrappers: array\nModule: caddy.listeners\nA list of listener wrapper modules, which can modify the behavior\nof the base listener. They are applied in the given order.\n", + "markdownDescription": "listener_wrappers: `array` \nModule: `caddy.listeners` \nA list of listener wrapper modules, which can modify the behavior\nof the base listener. They are applied in the given order. \n", + "type": "array", + "items": { + "description": "A list of listener wrapper modules, which can modify the behavior\nof the base listener. They are applied in the given order.\n", + "markdownDescription": "A list of listener wrapper modules, which can modify the behavior\nof the base listener. They are applied in the given order. \n", + "required": [ + "wrapper" + ], + "allOf": [ + { + "if": { + "properties": { + "wrapper": { + "const": "http_redirect" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.listeners.http_redirect" + } + }, + { + "if": { + "properties": { + "wrapper": { + "const": "tls" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.listeners.tls" + } + }, + { + "properties": { + "wrapper": { + "description": "key to identify listener_wrappers module.\nwrapper: string\nModule: caddy.listeners", + "markdownDescription": "key to identify `listener_wrappers` module. \nwrapper: `string` \nModule: `caddy.listeners`", + "type": "string", + "enum": [ + "http_redirect", + "tls" + ] + } + } + } + ] + } + }, + "logs": { + "description": "logs: object\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ServerLogConfig\nEnables access logging and configures how access logs are handled\nin this server. To minimally enable access logs, simply set this\nto a non-null, empty struct.\n\n\nServerLogConfig describes a server's logging configuration. If\nenabled without customization, all requests to this server are\nlogged to the default logger; logger destinations may be\ncustomized per-request-host.\n", + "markdownDescription": "logs: `object` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ServerLogConfig) \nEnables access logging and configures how access logs are handled\nin this server. To minimally enable access logs, simply set this\nto a non-null, empty struct.\n\n\nServerLogConfig describes a server's logging configuration. If\nenabled without customization, all requests to this server are\nlogged to the default logger; logger destinations may be\ncustomized per-request-host. \n", + "type": "object", + "properties": { + "default_logger_name": { + "description": "default_logger_name: string\nModule: http\nThe default logger name for all logs emitted by this server for\nhostnames that are not in the LoggerNames (logger_names) map.\n", + "markdownDescription": "default_logger_name: `string` \nModule: `http` \nThe default logger name for all logs emitted by this server for\nhostnames that are not in the LoggerNames (logger_names) map. \n", + "type": "string" + }, + "logger_names": { + "description": "logger_names: object\nModule: http\nLoggerNames maps request hostnames to a custom logger name.\nFor example, a mapping of \"example.com\" to \"example\" would\ncause access logs from requests with a Host of example.com\nto be emitted by a logger named \"http.log.access.example\".\n", + "markdownDescription": "logger_names: `object` \nModule: `http` \nLoggerNames maps request hostnames to a custom logger name.\nFor example, a mapping of \"example.com\" to \"example\" would\ncause access logs from requests with a Host of example.com\nto be emitted by a logger named \"http.log.access.example\". \n", + "type": "object", + "additionalProperties": { + "description": "LoggerNames maps request hostnames to a custom logger name.\nFor example, a mapping of \"example.com\" to \"example\" would\ncause access logs from requests with a Host of example.com\nto be emitted by a logger named \"http.log.access.example\".\n", + "markdownDescription": "LoggerNames maps request hostnames to a custom logger name.\nFor example, a mapping of \"example.com\" to \"example\" would\ncause access logs from requests with a Host of example.com\nto be emitted by a logger named \"http.log.access.example\". \n" + } + }, + "should_log_credentials": { + "description": "should_log_credentials: boolean\nModule: http\nIf true, credentials that are otherwise omitted, will be logged.\nThe definition of credentials is defined by https://fetch.spec.whatwg.org/#credentials,\nand this includes some request and response headers, i.e `Cookie`,\n`Set-Cookie`, `Authorization`, and `Proxy-Authorization`.\n", + "markdownDescription": "should_log_credentials: `boolean` \nModule: `http` \nIf true, credentials that are otherwise omitted, will be logged.\nThe definition of credentials is defined by https://fetch.spec.whatwg.org/#credentials,\nand this includes some request and response headers, i.e `Cookie`,\n`Set-Cookie`, `Authorization`, and `Proxy-Authorization`. \n", + "type": "boolean" + }, + "skip_hosts": { + "description": "skip_hosts: array\nModule: http\nBy default, all requests to this server will be logged if\naccess logging is enabled. This field lists the request\nhosts for which access logging should be disabled.\n", + "markdownDescription": "skip_hosts: `array` \nModule: `http` \nBy default, all requests to this server will be logged if\naccess logging is enabled. This field lists the request\nhosts for which access logging should be disabled. \n", + "type": "array", + "items": { + "description": "By default, all requests to this server will be logged if\naccess logging is enabled. This field lists the request\nhosts for which access logging should be disabled.\n", + "markdownDescription": "By default, all requests to this server will be logged if\naccess logging is enabled. This field lists the request\nhosts for which access logging should be disabled. \n", + "type": "string" + } + }, + "skip_unmapped_hosts": { + "description": "skip_unmapped_hosts: boolean\nModule: http\nIf true, requests to any host not appearing in the\nLoggerNames (logger_names) map will not be logged.\n", + "markdownDescription": "skip_unmapped_hosts: `boolean` \nModule: `http` \nIf true, requests to any host not appearing in the\nLoggerNames (logger_names) map will not be logged. \n", + "type": "boolean" + } + } + }, + "max_header_bytes": { + "description": "max_header_bytes: number\nModule: http\nMaxHeaderBytes is the maximum size to parse from a client's\nHTTP request headers.\n", + "markdownDescription": "max_header_bytes: `number` \nModule: `http` \nMaxHeaderBytes is the maximum size to parse from a client's\nHTTP request headers. \n", + "type": "number" + }, + "read_header_timeout": { + "description": "read_header_timeout: number\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nReadHeaderTimeout is like ReadTimeout but for request headers.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "read_header_timeout: `number` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nReadHeaderTimeout is like ReadTimeout but for request headers.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "read_timeout": { + "description": "read_timeout: number\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to allow a read from a client's upload. Setting this\nto a short, non-zero value can mitigate slowloris attacks, but\nmay also affect legitimately slow clients.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "read_timeout: `number` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to allow a read from a client's upload. Setting this\nto a short, non-zero value can mitigate slowloris attacks, but\nmay also affect legitimately slow clients.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "routes": { + "description": "routes: array\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nRoutes describes how this server will handle requests.\nRoutes are executed sequentially. First a route's matchers\nare evaluated, then its grouping. If it matches and has\nnot been mutually-excluded by its grouping, then its\nhandlers are executed sequentially. The sequence of invoked\nhandlers comprises a compiled middleware chain that flows\nfrom each matching route and its handlers to the next.\n\nBy default, all unrouted requests receive a 200 OK response\nto indicate the server is working.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "routes: `array` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nRoutes describes how this server will handle requests.\nRoutes are executed sequentially. First a route's matchers\nare evaluated, then its grouping. If it matches and has\nnot been mutually-excluded by its grouping, then its\nhandlers are executed sequentially. The sequence of invoked\nhandlers comprises a compiled middleware chain that flows\nfrom each matching route and its handlers to the next.\n\nBy default, all unrouted requests receive a 200 OK response\nto indicate the server is working.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nRoutes describes how this server will handle requests.\nRoutes are executed sequentially. First a route's matchers\nare evaluated, then its grouping. If it matches and has\nnot been mutually-excluded by its grouping, then its\nhandlers are executed sequentially. The sequence of invoked\nhandlers comprises a compiled middleware chain that flows\nfrom each matching route and its handlers to the next.\n\nBy default, all unrouted requests receive a 200 OK response\nto indicate the server is working.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nRoutes describes how this server will handle requests.\nRoutes are executed sequentially. First a route's matchers\nare evaluated, then its grouping. If it matches and has\nnot been mutually-excluded by its grouping, then its\nhandlers are executed sequentially. The sequence of invoked\nhandlers comprises a compiled middleware chain that flows\nfrom each matching route and its handlers to the next.\n\nBy default, all unrouted requests receive a 200 OK response\nto indicate the server is working.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "object", + "properties": { + "group": { + "description": "group: string\nModule: http\nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed.\n", + "markdownDescription": "group: `string` \nModule: `http` \nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed. \n", + "type": "string" + }, + "handle": { + "description": "handle: array\nModule: http.handlers\nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "handle: `array` \nModule: `http.handlers` \nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "type": "array", + "items": { + "description": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "required": [ + "handler" + ], + "allOf": [ + { + "if": { + "properties": { + "handler": { + "const": "encode" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.encode" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "metrics" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.metrics" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "request_body" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.request_body" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "rewrite" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.rewrite" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "subroute" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.subroute" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tracing" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.tracing" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "authentication" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.authentication" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "static_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.static_response" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "acme_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.acme_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response_headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response_headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "error" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.error" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "file_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.file_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "map" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.map" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "reverse_proxy" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.reverse_proxy" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "templates" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.templates" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "push" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.push" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "vars" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.vars" + } + }, + { + "properties": { + "handler": { + "description": "key to identify handle module.\nhandler: string\nModule: http.handlers", + "markdownDescription": "key to identify `handle` module. \nhandler: `string` \nModule: `http.handlers`", + "type": "string", + "enum": [ + "encode", + "headers", + "metrics", + "request_body", + "rewrite", + "subroute", + "tracing", + "authentication", + "static_response", + "acme_server", + "copy_response", + "copy_response_headers", + "error", + "file_server", + "map", + "reverse_proxy", + "templates", + "push", + "vars" + ] + } + } + } + ] + } + }, + "match": { + "description": "match: array\nModule: http.matchers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "match: `array` \nModule: `http.matchers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "properties": { + "expression": { + "$ref": "#/definitions/http.matchers.expression" + }, + "file": { + "$ref": "#/definitions/http.matchers.file" + }, + "header": { + "$ref": "#/definitions/http.matchers.header" + }, + "header_regexp": { + "$ref": "#/definitions/http.matchers.header_regexp" + }, + "host": { + "$ref": "#/definitions/http.matchers.host" + }, + "method": { + "$ref": "#/definitions/http.matchers.method" + }, + "not": { + "$ref": "#/definitions/http.matchers.not" + }, + "path": { + "$ref": "#/definitions/http.matchers.path" + }, + "path_regexp": { + "$ref": "#/definitions/http.matchers.path_regexp" + }, + "protocol": { + "$ref": "#/definitions/http.matchers.protocol" + }, + "query": { + "$ref": "#/definitions/http.matchers.query" + }, + "remote_ip": { + "$ref": "#/definitions/http.matchers.remote_ip" + }, + "vars": { + "$ref": "#/definitions/http.matchers.vars" + }, + "vars_regexp": { + "$ref": "#/definitions/http.matchers.vars_regexp" + } + } + } + }, + "terminal": { + "description": "terminal: boolean\nModule: http\nIf true, no more routes will be executed after this one.\n", + "markdownDescription": "terminal: `boolean` \nModule: `http` \nIf true, no more routes will be executed after this one. \n", + "type": "boolean" + } + } + } + }, + "strict_sni_host": { + "description": "strict_sni_host: boolean\nModule: http\nIf true, will require that a request's Host header match\nthe value of the ServerName sent by the client's TLS\nClientHello; often a necessary safeguard when using TLS\nclient authentication.\n", + "markdownDescription": "strict_sni_host: `boolean` \nModule: `http` \nIf true, will require that a request's Host header match\nthe value of the ServerName sent by the client's TLS\nClientHello; often a necessary safeguard when using TLS\nclient authentication. \n", + "type": "boolean" + }, + "tls_connection_policies": { + "description": "tls_connection_policies: array\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ConnectionPolicy\nHow to handle TLS connections. At least one policy is\nrequired to enable HTTPS on this server if automatic\nHTTPS is disabled or does not apply.\n\n\nConnectionPolicy specifies the logic for handling a TLS handshake.\nAn empty policy is valid; safe and sensible defaults will be used.\n", + "markdownDescription": "tls_connection_policies: `array` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ConnectionPolicy) \nHow to handle TLS connections. At least one policy is\nrequired to enable HTTPS on this server if automatic\nHTTPS is disabled or does not apply.\n\n\nConnectionPolicy specifies the logic for handling a TLS handshake.\nAn empty policy is valid; safe and sensible defaults will be used. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ConnectionPolicy\nHow to handle TLS connections. At least one policy is\nrequired to enable HTTPS on this server if automatic\nHTTPS is disabled or does not apply.\n\n\nConnectionPolicy specifies the logic for handling a TLS handshake.\nAn empty policy is valid; safe and sensible defaults will be used.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ConnectionPolicy) \nHow to handle TLS connections. At least one policy is\nrequired to enable HTTPS on this server if automatic\nHTTPS is disabled or does not apply.\n\n\nConnectionPolicy specifies the logic for handling a TLS handshake.\nAn empty policy is valid; safe and sensible defaults will be used. \n", + "type": "object", + "properties": { + "alpn": { + "description": "alpn: array\nModule: http\nProtocols to use for Application-Layer Protocol\nNegotiation (ALPN) during the handshake.\n", + "markdownDescription": "alpn: `array` \nModule: `http` \nProtocols to use for Application-Layer Protocol\nNegotiation (ALPN) during the handshake. \n", + "type": "array", + "items": { + "description": "Protocols to use for Application-Layer Protocol\nNegotiation (ALPN) during the handshake.\n", + "markdownDescription": "Protocols to use for Application-Layer Protocol\nNegotiation (ALPN) during the handshake. \n", + "type": "string" + } + }, + "certificate_selection": { + "description": "certificate_selection: object\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CustomCertSelectionPolicy\nHow to choose a certificate if more than one matched\nthe given ServerName (SNI) value.\n\n\nCustomCertSelectionPolicy represents a policy for selecting the certificate\nused to complete a handshake when there may be multiple options. All fields\nspecified must match the candidate certificate for it to be chosen.\nThis was needed to solve https://github.com/caddyserver/caddy/issues/2588.\n", + "markdownDescription": "certificate_selection: `object` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CustomCertSelectionPolicy) \nHow to choose a certificate if more than one matched\nthe given ServerName (SNI) value.\n\n\nCustomCertSelectionPolicy represents a policy for selecting the certificate\nused to complete a handshake when there may be multiple options. All fields\nspecified must match the candidate certificate for it to be chosen.\nThis was needed to solve https://github.com/caddyserver/caddy/issues/2588. \n", + "type": "object", + "properties": { + "all_tags": { + "description": "all_tags: array\nModule: http\nThe certificate must have all of the tags in the list.\n", + "markdownDescription": "all_tags: `array` \nModule: `http` \nThe certificate must have all of the tags in the list. \n", + "type": "array", + "items": { + "description": "The certificate must have all of the tags in the list.\n", + "markdownDescription": "The certificate must have all of the tags in the list. \n", + "type": "string" + } + }, + "any_tag": { + "description": "any_tag: array\nModule: http\nThe certificate must have at least one of the tags in the list.\n", + "markdownDescription": "any_tag: `array` \nModule: `http` \nThe certificate must have at least one of the tags in the list. \n", + "type": "array", + "items": { + "description": "The certificate must have at least one of the tags in the list.\n", + "markdownDescription": "The certificate must have at least one of the tags in the list. \n", + "type": "string" + } + }, + "public_key_algorithm": { + "description": "public_key_algorithm: number\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#PublicKeyAlgorithm\nThe certificate must use this public key algorithm.\n\n\nPublicKeyAlgorithm is a JSON-unmarshalable wrapper type.\n", + "markdownDescription": "public_key_algorithm: `number` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#PublicKeyAlgorithm) \nThe certificate must use this public key algorithm.\n\n\nPublicKeyAlgorithm is a JSON-unmarshalable wrapper type. \n", + "type": "number" + }, + "serial_number": { + "description": "serial_number: array\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#bigInt\nThe certificate must have one of these serial numbers.\n\n\nbigInt is a big.Int type that interops with JSON encodings as a string.\n", + "markdownDescription": "serial_number: `array` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#bigInt) \nThe certificate must have one of these serial numbers.\n\n\nbigInt is a big.Int type that interops with JSON encodings as a string. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#bigInt\nThe certificate must have one of these serial numbers.\n\n\nbigInt is a big.Int type that interops with JSON encodings as a string.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#bigInt) \nThe certificate must have one of these serial numbers.\n\n\nbigInt is a big.Int type that interops with JSON encodings as a string. \n", + "type": "object" + } + }, + "subject_organization": { + "description": "subject_organization: array\nModule: http\nThe certificate must have one of these organization names.\n", + "markdownDescription": "subject_organization: `array` \nModule: `http` \nThe certificate must have one of these organization names. \n", + "type": "array", + "items": { + "description": "The certificate must have one of these organization names.\n", + "markdownDescription": "The certificate must have one of these organization names. \n", + "type": "string" + } + } + } + }, + "cipher_suites": { + "description": "cipher_suites: array\nModule: http\nThe list of cipher suites to support. Caddy's\ndefaults are modern and secure.\n", + "markdownDescription": "cipher_suites: `array` \nModule: `http` \nThe list of cipher suites to support. Caddy's\ndefaults are modern and secure. \n", + "type": "array", + "items": { + "description": "The list of cipher suites to support. Caddy's\ndefaults are modern and secure.\n", + "markdownDescription": "The list of cipher suites to support. Caddy's\ndefaults are modern and secure. \n", + "type": "string" + } + }, + "client_authentication": { + "description": "client_authentication: object\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ClientAuthentication\nEnables and configures TLS client authentication.\n\n\nClientAuthentication configures TLS client auth.\n", + "markdownDescription": "client_authentication: `object` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ClientAuthentication) \nEnables and configures TLS client authentication.\n\n\nClientAuthentication configures TLS client auth. \n", + "type": "object", + "properties": { + "mode": { + "description": "mode: string\nModule: http\nThe mode for authenticating the client. Allowed values are:\n\nMode | Description\n-----|---------------\n`request` | Ask clients for a certificate, but allow even if there isn't one; do not verify it\n`require` | Require clients to present a certificate, but do not verify it\n`verify_if_given` | Ask clients for a certificate; allow even if there isn't one, but verify it if there is\n`require_and_verify` | Require clients to present a valid certificate that is verified\n\nThe default mode is `require_and_verify` if any\nTrustedCACerts or TrustedCACertPEMFiles or TrustedLeafCerts\nare provided; otherwise, the default mode is `require`.\n", + "markdownDescription": "mode: `string` \nModule: `http` \nThe mode for authenticating the client. Allowed values are:\n\nMode | Description\n-----|---------------\n`request` | Ask clients for a certificate, but allow even if there isn't one; do not verify it\n`require` | Require clients to present a certificate, but do not verify it\n`verify_if_given` | Ask clients for a certificate; allow even if there isn't one, but verify it if there is\n`require_and_verify` | Require clients to present a valid certificate that is verified\n\nThe default mode is `require_and_verify` if any\nTrustedCACerts or TrustedCACertPEMFiles or TrustedLeafCerts\nare provided; otherwise, the default mode is `require`. \n", + "type": "string" + }, + "trusted_ca_certs": { + "description": "trusted_ca_certs: array\nModule: http\nA list of base64 DER-encoded CA certificates\nagainst which to validate client certificates.\nClient certs which are not signed by any of\nthese CAs will be rejected.\n", + "markdownDescription": "trusted_ca_certs: `array` \nModule: `http` \nA list of base64 DER-encoded CA certificates\nagainst which to validate client certificates.\nClient certs which are not signed by any of\nthese CAs will be rejected. \n", + "type": "array", + "items": { + "description": "A list of base64 DER-encoded CA certificates\nagainst which to validate client certificates.\nClient certs which are not signed by any of\nthese CAs will be rejected.\n", + "markdownDescription": "A list of base64 DER-encoded CA certificates\nagainst which to validate client certificates.\nClient certs which are not signed by any of\nthese CAs will be rejected. \n", + "type": "string" + } + }, + "trusted_ca_certs_pem_files": { + "description": "trusted_ca_certs_pem_files: array\nModule: http\nTrustedCACertPEMFiles is a list of PEM file names\nfrom which to load certificates of trusted CAs.\nClient certificates which are not signed by any of\nthese CA certificates will be rejected.\n", + "markdownDescription": "trusted_ca_certs_pem_files: `array` \nModule: `http` \nTrustedCACertPEMFiles is a list of PEM file names\nfrom which to load certificates of trusted CAs.\nClient certificates which are not signed by any of\nthese CA certificates will be rejected. \n", + "type": "array", + "items": { + "description": "TrustedCACertPEMFiles is a list of PEM file names\nfrom which to load certificates of trusted CAs.\nClient certificates which are not signed by any of\nthese CA certificates will be rejected.\n", + "markdownDescription": "TrustedCACertPEMFiles is a list of PEM file names\nfrom which to load certificates of trusted CAs.\nClient certificates which are not signed by any of\nthese CA certificates will be rejected. \n", + "type": "string" + } + }, + "trusted_leaf_certs": { + "description": "trusted_leaf_certs: array\nModule: http\nA list of base64 DER-encoded client leaf certs\nto accept. If this list is not empty, client certs\nwhich are not in this list will be rejected.\n", + "markdownDescription": "trusted_leaf_certs: `array` \nModule: `http` \nA list of base64 DER-encoded client leaf certs\nto accept. If this list is not empty, client certs\nwhich are not in this list will be rejected. \n", + "type": "array", + "items": { + "description": "A list of base64 DER-encoded client leaf certs\nto accept. If this list is not empty, client certs\nwhich are not in this list will be rejected.\n", + "markdownDescription": "A list of base64 DER-encoded client leaf certs\nto accept. If this list is not empty, client certs\nwhich are not in this list will be rejected. \n", + "type": "string" + } + }, + "verifiers": { + "description": "verifiers: array\nModule: tls.client_auth", + "markdownDescription": "verifiers: `array` \nModule: `tls.client_auth`", + "type": "array", + "items": { + "required": [ + "verifier" + ], + "allOf": [ + { + "if": { + "properties": { + "verifier": { + "const": "leaf" + } + } + }, + "then": { + "$ref": "#/definitions/tls.client_auth.leaf" + } + }, + { + "properties": { + "verifier": { + "description": "key to identify verifiers module.\nverifier: string\nModule: tls.client_auth", + "markdownDescription": "key to identify `verifiers` module. \nverifier: `string` \nModule: `tls.client_auth`", + "type": "string", + "enum": [ + "leaf" + ] + } + } + } + ] + } + } + } + }, + "curves": { + "description": "curves: array\nModule: http\nThe list of elliptic curves to support. Caddy's\ndefaults are modern and secure.\n", + "markdownDescription": "curves: `array` \nModule: `http` \nThe list of elliptic curves to support. Caddy's\ndefaults are modern and secure. \n", + "type": "array", + "items": { + "description": "The list of elliptic curves to support. Caddy's\ndefaults are modern and secure.\n", + "markdownDescription": "The list of elliptic curves to support. Caddy's\ndefaults are modern and secure. \n", + "type": "string" + } + }, + "default_sni": { + "description": "default_sni: string\nModule: http\nDefaultSNI becomes the ServerName in a ClientHello if there\nis no policy configured for the empty SNI value.\n", + "markdownDescription": "default_sni: `string` \nModule: `http` \nDefaultSNI becomes the ServerName in a ClientHello if there\nis no policy configured for the empty SNI value. \n", + "type": "string" + }, + "match": { + "description": "match: object\nModule: tls.handshake_match\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nHow to match this policy with a TLS ClientHello. If\nthis policy is the first to match, it will be used.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "match: `object` \nModule: `tls.handshake_match` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nHow to match this policy with a TLS ClientHello. If\nthis policy is the first to match, it will be used.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "object", + "properties": { + "alpn": { + "$ref": "#/definitions/tls.handshake_match.alpn" + }, + "remote_ip": { + "$ref": "#/definitions/tls.handshake_match.remote_ip" + }, + "sni": { + "$ref": "#/definitions/tls.handshake_match.sni" + } + } + }, + "protocol_max": { + "description": "protocol_max: string\nModule: http\nMaximum TLS protocol version to allow. Default: `tls1.3`\n", + "markdownDescription": "protocol_max: `string` \nModule: `http` \nMaximum TLS protocol version to allow. Default: `tls1.3` \n", + "type": "string" + }, + "protocol_min": { + "description": "protocol_min: string\nModule: http\nMinimum TLS protocol version to allow. Default: `tls1.2`\n", + "markdownDescription": "protocol_min: `string` \nModule: `http` \nMinimum TLS protocol version to allow. Default: `tls1.2` \n", + "type": "string" + } + } + } + }, + "write_timeout": { + "description": "write_timeout: number\nModule: http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nWriteTimeout is how long to allow a write to a client. Note\nthat setting this to a small value when serving large files\nmay negatively affect legitimately slow clients.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "write_timeout: `number` \nModule: `http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nWriteTimeout is how long to allow a write to a client. Note\nthat setting this to a small value when serving large files\nmay negatively affect legitimately slow clients.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + } + } + } + }, + "http.authentication.hashes.bcrypt": { + "description": "bcrypt: object\nModule: http.authentication.hashes.bcrypt\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#BcryptHash", + "markdownDescription": "bcrypt: `object` \nModule: `http.authentication.hashes.bcrypt` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#BcryptHash)", + "type": "object" + }, + "http.authentication.hashes.scrypt": { + "description": "scrypt: object\nModule: http.authentication.hashes.scrypt\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash", + "markdownDescription": "scrypt: `object` \nModule: `http.authentication.hashes.scrypt` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash)", + "type": "object", + "properties": { + "N": { + "description": "N: number\nModule: http.authentication.hashes.scrypt\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash", + "markdownDescription": "N: `number` \nModule: `http.authentication.hashes.scrypt` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash)", + "type": "number" + }, + "key_length": { + "description": "key_length: number\nModule: http.authentication.hashes.scrypt\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash", + "markdownDescription": "key_length: `number` \nModule: `http.authentication.hashes.scrypt` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash)", + "type": "number" + }, + "p": { + "description": "p: number\nModule: http.authentication.hashes.scrypt\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash", + "markdownDescription": "p: `number` \nModule: `http.authentication.hashes.scrypt` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash)", + "type": "number" + }, + "r": { + "description": "r: number\nModule: http.authentication.hashes.scrypt\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash", + "markdownDescription": "r: `number` \nModule: `http.authentication.hashes.scrypt` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#ScryptHash)", + "type": "number" + } + } + }, + "http.authentication.providers.http_basic": { + "description": "http_basic: object\nModule: http.authentication.providers.http_basic\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth", + "markdownDescription": "http_basic: `object` \nModule: `http.authentication.providers.http_basic` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth)", + "type": "object", + "properties": { + "accounts": { + "description": "accounts: array\nModule: http.authentication.providers.http_basic\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth", + "markdownDescription": "accounts: `array` \nModule: `http.authentication.providers.http_basic` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth)", + "type": "array", + "items": { + "type": "object", + "properties": { + "password": { + "description": "password: string\nModule: http.authentication.providers.http_basic\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth", + "markdownDescription": "password: `string` \nModule: `http.authentication.providers.http_basic` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth)", + "type": "string" + }, + "salt": { + "description": "salt: string\nModule: http.authentication.providers.http_basic\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth", + "markdownDescription": "salt: `string` \nModule: `http.authentication.providers.http_basic` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth)", + "type": "string" + }, + "username": { + "description": "username: string\nModule: http.authentication.providers.http_basic\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth", + "markdownDescription": "username: `string` \nModule: `http.authentication.providers.http_basic` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth)", + "type": "string" + } + } + } + }, + "hash": { + "description": "hash: object\nModule: http.authentication.hashes", + "markdownDescription": "hash: `object` \nModule: `http.authentication.hashes`", + "type": "object", + "required": [ + "algorithm" + ], + "allOf": [ + { + "if": { + "properties": { + "algorithm": { + "const": "bcrypt" + } + } + }, + "then": { + "$ref": "#/definitions/http.authentication.hashes.bcrypt" + } + }, + { + "if": { + "properties": { + "algorithm": { + "const": "scrypt" + } + } + }, + "then": { + "$ref": "#/definitions/http.authentication.hashes.scrypt" + } + }, + { + "properties": { + "algorithm": { + "description": "key to identify hash module.\nalgorithm: string\nModule: http.authentication.hashes", + "markdownDescription": "key to identify `hash` module. \nalgorithm: `string` \nModule: `http.authentication.hashes`", + "type": "string", + "enum": [ + "bcrypt", + "scrypt" + ] + } + } + } + ] + }, + "hash_cache": { + "description": "hash_cache: object\nModule: http.authentication.providers.http_basic\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth", + "markdownDescription": "hash_cache: `object` \nModule: `http.authentication.providers.http_basic` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth)", + "type": "object" + }, + "realm": { + "description": "realm: string\nModule: http.authentication.providers.http_basic\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth", + "markdownDescription": "realm: `string` \nModule: `http.authentication.providers.http_basic` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#HTTPBasicAuth)", + "type": "string" + } + } + }, + "http.encoders.gzip": { + "description": "gzip: object\nModule: http.encoders.gzip\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/gzip#Gzip", + "markdownDescription": "gzip: `object` \nModule: `http.encoders.gzip` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/gzip#Gzip)", + "type": "object", + "properties": { + "level": { + "description": "level: number\nModule: http.encoders.gzip\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/gzip#Gzip", + "markdownDescription": "level: `number` \nModule: `http.encoders.gzip` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/gzip#Gzip)", + "type": "number" + } + } + }, + "http.encoders.zstd": { + "description": "zstd: object\nModule: http.encoders.zstd\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/zstd#Zstd", + "markdownDescription": "zstd: `object` \nModule: `http.encoders.zstd` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/zstd#Zstd)", + "type": "object" + }, + "http.handlers.acme_server": { + "description": "acme_server: object\nModule: http.handlers.acme_server\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki/acmeserver#Handler\nHandler is an ACME server handler.\n\n", + "markdownDescription": "acme_server: `object` \nModule: `http.handlers.acme_server` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki/acmeserver#Handler) \nHandler is an ACME server handler.\n \n", + "type": "object", + "properties": { + "ca": { + "description": "ca: string\nModule: http.handlers.acme_server\nThe ID of the CA to use for signing. This refers to\nthe ID given to the CA in the `pki` app. If omitted,\nthe default ID is \"local\".\n", + "markdownDescription": "ca: `string` \nModule: `http.handlers.acme_server` \nThe ID of the CA to use for signing. This refers to\nthe ID given to the CA in the `pki` app. If omitted,\nthe default ID is \"local\". \n", + "type": "string" + }, + "host": { + "description": "host: string\nModule: http.handlers.acme_server\nThe hostname or IP address by which ACME clients\nwill access the server. This is used to populate\nthe ACME directory endpoint. If not set, the Host\nheader of the request will be used.\nCOMPATIBILITY NOTE / TODO: This property may go away in the\nfuture. Do not rely on this property long-term; check release notes.\n", + "markdownDescription": "host: `string` \nModule: `http.handlers.acme_server` \nThe hostname or IP address by which ACME clients\nwill access the server. This is used to populate\nthe ACME directory endpoint. If not set, the Host\nheader of the request will be used.\nCOMPATIBILITY NOTE / TODO: This property may go away in the\nfuture. Do not rely on this property long-term; check release notes. \n", + "type": "string" + }, + "path_prefix": { + "description": "path_prefix: string\nModule: http.handlers.acme_server\nThe path prefix under which to serve all ACME\nendpoints. All other requests will not be served\nby this handler and will be passed through to\nthe next one. Default: \"/acme/\".\nCOMPATIBILITY NOTE / TODO: This property may go away in the\nfuture, as it is currently only required due to\nlimitations in the underlying library. Do not rely\non this property long-term; check release notes.\n", + "markdownDescription": "path_prefix: `string` \nModule: `http.handlers.acme_server` \nThe path prefix under which to serve all ACME\nendpoints. All other requests will not be served\nby this handler and will be passed through to\nthe next one. Default: \"/acme/\".\nCOMPATIBILITY NOTE / TODO: This property may go away in the\nfuture, as it is currently only required due to\nlimitations in the underlying library. Do not rely\non this property long-term; check release notes. \n", + "type": "string" + }, + "sign_with_root": { + "description": "sign_with_root: boolean\nModule: http.handlers.acme_server\nIf true, the CA's root will be the issuer instead of\nthe intermediate. This is NOT recommended and should\nonly be used when devices/clients do not properly\nvalidate certificate chains. EXPERIMENTAL: Might be\nchanged or removed in the future.\n", + "markdownDescription": "sign_with_root: `boolean` \nModule: `http.handlers.acme_server` \nIf true, the CA's root will be the issuer instead of\nthe intermediate. This is NOT recommended and should\nonly be used when devices/clients do not properly\nvalidate certificate chains. EXPERIMENTAL: Might be\nchanged or removed in the future. \n", + "type": "boolean" + } + } + }, + "http.handlers.authentication": { + "description": "authentication: object\nModule: http.handlers.authentication\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#Authentication\nAuthentication is a middleware which provides user authentication.\nRejects requests with HTTP 401 if the request is not authenticated.\n\nAfter a successful authentication, the placeholder\n`{http.auth.user.id}` will be set to the username, and also\n`{http.auth.user.*}` placeholders may be set for any authentication\nmodules that provide user metadata.\n\nIts API is still experimental and may be subject to change.\n\n", + "markdownDescription": "authentication: `object` \nModule: `http.handlers.authentication` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth#Authentication) \nAuthentication is a middleware which provides user authentication.\nRejects requests with HTTP 401 if the request is not authenticated.\n\nAfter a successful authentication, the placeholder\n`{http.auth.user.id}` will be set to the username, and also\n`{http.auth.user.*}` placeholders may be set for any authentication\nmodules that provide user metadata.\n\nIts API is still experimental and may be subject to change.\n \n", + "type": "object", + "properties": { + "providers": { + "description": "providers: object\nModule: http.authentication.providers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nA set of authentication providers. If none are specified,\nall requests will always be unauthenticated.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "providers: `object` \nModule: `http.authentication.providers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nA set of authentication providers. If none are specified,\nall requests will always be unauthenticated.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "object", + "properties": { + "http_basic": { + "$ref": "#/definitions/http.authentication.providers.http_basic" + } + } + } + } + }, + "http.handlers.copy_response": { + "description": "copy_response: object\nModule: http.handlers.copy_response\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CopyResponseHandler\nCopyResponseHandler is a special HTTP handler which may\nonly be used within reverse_proxy's handle_response routes,\nto copy the proxy response. EXPERIMENTAL, subject to change.\n\n", + "markdownDescription": "copy_response: `object` \nModule: `http.handlers.copy_response` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CopyResponseHandler) \nCopyResponseHandler is a special HTTP handler which may\nonly be used within reverse_proxy's handle_response routes,\nto copy the proxy response. EXPERIMENTAL, subject to change.\n \n", + "type": "object", + "properties": { + "status_code": { + "description": "status_code: string\nModule: http.handlers.copy_response\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString\nTo write the upstream response's body but with a different\nstatus code, set this field to the desired status code.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned.\n", + "markdownDescription": "status_code: `string` \nModule: `http.handlers.copy_response` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString) \nTo write the upstream response's body but with a different\nstatus code, set this field to the desired status code.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned. \n", + "type": "string" + } + } + }, + "http.handlers.copy_response_headers": { + "description": "copy_response_headers: object\nModule: http.handlers.copy_response_headers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CopyResponseHeadersHandler\nCopyResponseHeadersHandler is a special HTTP handler which may\nonly be used within reverse_proxy's handle_response routes,\nto copy headers from the proxy response. EXPERIMENTAL;\nsubject to change.\n\n", + "markdownDescription": "copy_response_headers: `object` \nModule: `http.handlers.copy_response_headers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CopyResponseHeadersHandler) \nCopyResponseHeadersHandler is a special HTTP handler which may\nonly be used within reverse_proxy's handle_response routes,\nto copy headers from the proxy response. EXPERIMENTAL;\nsubject to change.\n \n", + "type": "object", + "properties": { + "exclude": { + "description": "exclude: array\nModule: http.handlers.copy_response_headers\nA list of header fields to skip copying from the response.\nCannot be defined at the same time as Include.\n", + "markdownDescription": "exclude: `array` \nModule: `http.handlers.copy_response_headers` \nA list of header fields to skip copying from the response.\nCannot be defined at the same time as Include. \n", + "type": "array", + "items": { + "description": "A list of header fields to skip copying from the response.\nCannot be defined at the same time as Include.\n", + "markdownDescription": "A list of header fields to skip copying from the response.\nCannot be defined at the same time as Include. \n", + "type": "string" + } + }, + "include": { + "description": "include: array\nModule: http.handlers.copy_response_headers\nA list of header fields to copy from the response.\nCannot be defined at the same time as Exclude.\n", + "markdownDescription": "include: `array` \nModule: `http.handlers.copy_response_headers` \nA list of header fields to copy from the response.\nCannot be defined at the same time as Exclude. \n", + "type": "array", + "items": { + "description": "A list of header fields to copy from the response.\nCannot be defined at the same time as Exclude.\n", + "markdownDescription": "A list of header fields to copy from the response.\nCannot be defined at the same time as Exclude. \n", + "type": "string" + } + } + } + }, + "http.handlers.encode": { + "description": "encode: object\nModule: http.handlers.encode\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode#Encode\nEncode is a middleware which can encode responses.\n\n", + "markdownDescription": "encode: `object` \nModule: `http.handlers.encode` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode#Encode) \nEncode is a middleware which can encode responses.\n \n", + "type": "object", + "properties": { + "encodings": { + "description": "encodings: object\nModule: http.encoders\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nSelection of compression algorithms to choose from. The best one\nwill be chosen based on the client's Accept-Encoding header.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "encodings: `object` \nModule: `http.encoders` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nSelection of compression algorithms to choose from. The best one\nwill be chosen based on the client's Accept-Encoding header.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "object", + "properties": { + "gzip": { + "$ref": "#/definitions/http.encoders.gzip" + }, + "zstd": { + "$ref": "#/definitions/http.encoders.zstd" + } + } + }, + "match": { + "description": "match: object\nModule: http.handlers.encode\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseMatcher\nOnly encode responses that match against this ResponseMmatcher.\nThe default is a collection of text-based Content-Type headers.\n\n\nResponseMatcher is a type which can determine if an\nHTTP response matches some criteria.\n", + "markdownDescription": "match: `object` \nModule: `http.handlers.encode` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseMatcher) \nOnly encode responses that match against this ResponseMmatcher.\nThe default is a collection of text-based Content-Type headers.\n\n\nResponseMatcher is a type which can determine if an\nHTTP response matches some criteria. \n", + "type": "object", + "properties": { + "headers": { + "description": "headers: object\nModule: http.handlers.encode\nIf set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/).\n", + "markdownDescription": "headers: `object` \nModule: `http.handlers.encode` \nIf set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/). \n", + "type": "object", + "additionalProperties": { + "description": "If set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/).\n", + "markdownDescription": "If set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/). \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "status_code": { + "description": "status_code: array\nModule: http.handlers.encode\nIf set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes).\n", + "markdownDescription": "status_code: `array` \nModule: `http.handlers.encode` \nIf set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes). \n", + "type": "array", + "items": { + "description": "If set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes).\n", + "markdownDescription": "If set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes). \n", + "type": "number" + } + } + } + }, + "minimum_length": { + "description": "minimum_length: number\nModule: http.handlers.encode\nOnly encode responses that are at least this many bytes long.\n", + "markdownDescription": "minimum_length: `number` \nModule: `http.handlers.encode` \nOnly encode responses that are at least this many bytes long. \n", + "type": "number" + }, + "prefer": { + "description": "prefer: array\nModule: http.handlers.encode\nIf the client has no strong preference, choose these encodings in order.\n", + "markdownDescription": "prefer: `array` \nModule: `http.handlers.encode` \nIf the client has no strong preference, choose these encodings in order. \n", + "type": "array", + "items": { + "description": "If the client has no strong preference, choose these encodings in order.\n", + "markdownDescription": "If the client has no strong preference, choose these encodings in order. \n", + "type": "string" + } + } + } + }, + "http.handlers.error": { + "description": "error: object\nModule: http.handlers.error\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#StaticError\nStaticError implements a simple handler that returns an error.\nThis handler returns an error value, but does not write a response.\nThis is useful when you want the server to act as if an error\noccurred; for example, to invoke your custom error handling logic.\n\nSince this handler does not write a response, the error information\nis for use by the server to know how to handle the error.\n\n", + "markdownDescription": "error: `object` \nModule: `http.handlers.error` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#StaticError) \nStaticError implements a simple handler that returns an error.\nThis handler returns an error value, but does not write a response.\nThis is useful when you want the server to act as if an error\noccurred; for example, to invoke your custom error handling logic.\n\nSince this handler does not write a response, the error information\nis for use by the server to know how to handle the error.\n \n", + "type": "object", + "properties": { + "error": { + "description": "error: string\nModule: http.handlers.error\nThe error message. Optional. Default is no error message.\n", + "markdownDescription": "error: `string` \nModule: `http.handlers.error` \nThe error message. Optional. Default is no error message. \n", + "type": "string" + }, + "status_code": { + "description": "status_code: string\nModule: http.handlers.error\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString\nThe recommended HTTP status code. Can be either an integer or a\nstring if placeholders are needed. Optional. Default is 500.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned.\n", + "markdownDescription": "status_code: `string` \nModule: `http.handlers.error` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString) \nThe recommended HTTP status code. Can be either an integer or a\nstring if placeholders are needed. Optional. Default is 500.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned. \n", + "type": "string" + } + } + }, + "http.handlers.file_server": { + "description": "file_server: object\nModule: http.handlers.file_server\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/fileserver#FileServer\nFileServer implements a static file server responder for Caddy.\n\n", + "markdownDescription": "file_server: `object` \nModule: `http.handlers.file_server` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/fileserver#FileServer) \nFileServer implements a static file server responder for Caddy.\n \n", + "type": "object", + "properties": { + "browse": { + "description": "browse: object\nModule: http.handlers.file_server\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/fileserver#Browse\nEnables file listings if a directory was requested and no index\nfile is present.\n\n\nBrowse configures directory browsing.\n", + "markdownDescription": "browse: `object` \nModule: `http.handlers.file_server` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/fileserver#Browse) \nEnables file listings if a directory was requested and no index\nfile is present.\n\n\nBrowse configures directory browsing. \n", + "type": "object", + "properties": { + "template_file": { + "description": "template_file: string\nModule: http.handlers.file_server\nUse this template file instead of the default browse template.\n", + "markdownDescription": "template_file: `string` \nModule: `http.handlers.file_server` \nUse this template file instead of the default browse template. \n", + "type": "string" + } + } + }, + "canonical_uris": { + "description": "canonical_uris: boolean\nModule: http.handlers.file_server\nUse redirects to enforce trailing slashes for directories, or to\nremove trailing slash from URIs for files. Default is true.\n\nCanonicalization will not happen if the last element of the request's\npath (the filename) is changed in an internal rewrite, to avoid\nclobbering the explicit rewrite with implicit behavior.\n", + "markdownDescription": "canonical_uris: `boolean` \nModule: `http.handlers.file_server` \nUse redirects to enforce trailing slashes for directories, or to\nremove trailing slash from URIs for files. Default is true.\n\nCanonicalization will not happen if the last element of the request's\npath (the filename) is changed in an internal rewrite, to avoid\nclobbering the explicit rewrite with implicit behavior. \n", + "type": "boolean" + }, + "hide": { + "description": "hide: array\nModule: http.handlers.file_server\nA list of files or folders to hide; the file server will pretend as if\nthey don't exist. Accepts globular patterns like `*.ext` or `/foo/*/bar`\nas well as placeholders. Because site roots can be dynamic, this list\nuses file system paths, not request paths. To clarify, the base of\nrelative paths is the current working directory, NOT the site root.\n\nEntries without a path separator (`/` or `\\` depending on OS) will match\nany file or directory of that name regardless of its path. To hide only a\nspecific file with a name that may not be unique, always use a path\nseparator. For example, to hide all files or folder trees named \"hidden\",\nput \"hidden\" in the list. To hide only ./hidden, put \"./hidden\" in the list.\n\nWhen possible, all paths are resolved to their absolute form before\ncomparisons are made. For maximum clarity and explictness, use complete,\nabsolute paths; or, for greater portability, use relative paths instead.\n", + "markdownDescription": "hide: `array` \nModule: `http.handlers.file_server` \nA list of files or folders to hide; the file server will pretend as if\nthey don't exist. Accepts globular patterns like `*.ext` or `/foo/*/bar`\nas well as placeholders. Because site roots can be dynamic, this list\nuses file system paths, not request paths. To clarify, the base of\nrelative paths is the current working directory, NOT the site root.\n\nEntries without a path separator (`/` or `\\` depending on OS) will match\nany file or directory of that name regardless of its path. To hide only a\nspecific file with a name that may not be unique, always use a path\nseparator. For example, to hide all files or folder trees named \"hidden\",\nput \"hidden\" in the list. To hide only ./hidden, put \"./hidden\" in the list.\n\nWhen possible, all paths are resolved to their absolute form before\ncomparisons are made. For maximum clarity and explictness, use complete,\nabsolute paths; or, for greater portability, use relative paths instead. \n", + "type": "array", + "items": { + "description": "A list of files or folders to hide; the file server will pretend as if\nthey don't exist. Accepts globular patterns like `*.ext` or `/foo/*/bar`\nas well as placeholders. Because site roots can be dynamic, this list\nuses file system paths, not request paths. To clarify, the base of\nrelative paths is the current working directory, NOT the site root.\n\nEntries without a path separator (`/` or `\\` depending on OS) will match\nany file or directory of that name regardless of its path. To hide only a\nspecific file with a name that may not be unique, always use a path\nseparator. For example, to hide all files or folder trees named \"hidden\",\nput \"hidden\" in the list. To hide only ./hidden, put \"./hidden\" in the list.\n\nWhen possible, all paths are resolved to their absolute form before\ncomparisons are made. For maximum clarity and explictness, use complete,\nabsolute paths; or, for greater portability, use relative paths instead.\n", + "markdownDescription": "A list of files or folders to hide; the file server will pretend as if\nthey don't exist. Accepts globular patterns like `*.ext` or `/foo/*/bar`\nas well as placeholders. Because site roots can be dynamic, this list\nuses file system paths, not request paths. To clarify, the base of\nrelative paths is the current working directory, NOT the site root.\n\nEntries without a path separator (`/` or `\\` depending on OS) will match\nany file or directory of that name regardless of its path. To hide only a\nspecific file with a name that may not be unique, always use a path\nseparator. For example, to hide all files or folder trees named \"hidden\",\nput \"hidden\" in the list. To hide only ./hidden, put \"./hidden\" in the list.\n\nWhen possible, all paths are resolved to their absolute form before\ncomparisons are made. For maximum clarity and explictness, use complete,\nabsolute paths; or, for greater portability, use relative paths instead. \n", + "type": "string" + } + }, + "index_names": { + "description": "index_names: array\nModule: http.handlers.file_server\nThe names of files to try as index files if a folder is requested.\n", + "markdownDescription": "index_names: `array` \nModule: `http.handlers.file_server` \nThe names of files to try as index files if a folder is requested. \n", + "type": "array", + "items": { + "description": "The names of files to try as index files if a folder is requested.\n", + "markdownDescription": "The names of files to try as index files if a folder is requested. \n", + "type": "string" + } + }, + "pass_thru": { + "description": "pass_thru: boolean\nModule: http.handlers.file_server\nIf pass-thru mode is enabled and a requested file is not found,\nit will invoke the next handler in the chain instead of returning\na 404 error. By default, this is false (disabled).\n", + "markdownDescription": "pass_thru: `boolean` \nModule: `http.handlers.file_server` \nIf pass-thru mode is enabled and a requested file is not found,\nit will invoke the next handler in the chain instead of returning\na 404 error. By default, this is false (disabled). \n", + "type": "boolean" + }, + "precompressed": { + "description": "precompressed: object\nModule: http.precompressed\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nSelection of encoders to use to check for precompressed files.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "precompressed: `object` \nModule: `http.precompressed` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nSelection of encoders to use to check for precompressed files.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "object", + "properties": { + "br": { + "$ref": "#/definitions/http.precompressed.br" + }, + "gzip": { + "$ref": "#/definitions/http.precompressed.gzip" + }, + "zstd": { + "$ref": "#/definitions/http.precompressed.zstd" + } + } + }, + "precompressed_order": { + "description": "precompressed_order: array\nModule: http.handlers.file_server\nIf the client has no strong preference (q-factor), choose these encodings in order.\nIf no order specified here, the first encoding from the Accept-Encoding header\nthat both client and server support is used\n", + "markdownDescription": "precompressed_order: `array` \nModule: `http.handlers.file_server` \nIf the client has no strong preference (q-factor), choose these encodings in order.\nIf no order specified here, the first encoding from the Accept-Encoding header\nthat both client and server support is used \n", + "type": "array", + "items": { + "description": "If the client has no strong preference (q-factor), choose these encodings in order.\nIf no order specified here, the first encoding from the Accept-Encoding header\nthat both client and server support is used\n", + "markdownDescription": "If the client has no strong preference (q-factor), choose these encodings in order.\nIf no order specified here, the first encoding from the Accept-Encoding header\nthat both client and server support is used \n", + "type": "string" + } + }, + "root": { + "description": "root: string\nModule: http.handlers.file_server\nThe path to the root of the site. Default is `{http.vars.root}` if set,\nor current working directory otherwise.\n", + "markdownDescription": "root: `string` \nModule: `http.handlers.file_server` \nThe path to the root of the site. Default is `{http.vars.root}` if set,\nor current working directory otherwise. \n", + "type": "string" + }, + "status_code": { + "description": "status_code: string\nModule: http.handlers.file_server\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString\nOverride the status code written when successfully serving a file.\nParticularly useful when explicitly serving a file as display for\nan error, like a 404 page. A placeholder may be used. By default,\nthe status code will typically be 200, or 206 for partial content.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned.\n", + "markdownDescription": "status_code: `string` \nModule: `http.handlers.file_server` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString) \nOverride the status code written when successfully serving a file.\nParticularly useful when explicitly serving a file as display for\nan error, like a 404 page. A placeholder may be used. By default,\nthe status code will typically be 200, or 206 for partial content.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned. \n", + "type": "string" + } + } + }, + "http.handlers.headers": { + "description": "headers: object\nModule: http.handlers.headers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Handler\nHandler is a middleware which modifies request and response headers.\n\nChanges to headers are applied immediately, except for the response\nheaders when Deferred is true or when Required is set. In those cases,\nthe changes are applied when the headers are written to the response.\nNote that deferred changes do not take effect if an error occurs later\nin the middleware chain.\n\nProperties in this module accept placeholders.\n\nResponse header operations can be conditioned upon response status code\nand/or other header values.\n\n", + "markdownDescription": "headers: `object` \nModule: `http.handlers.headers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Handler) \nHandler is a middleware which modifies request and response headers.\n\nChanges to headers are applied immediately, except for the response\nheaders when Deferred is true or when Required is set. In those cases,\nthe changes are applied when the headers are written to the response.\nNote that deferred changes do not take effect if an error occurs later\nin the middleware chain.\n\nProperties in this module accept placeholders.\n\nResponse header operations can be conditioned upon response status code\nand/or other header values.\n \n", + "type": "object", + "properties": { + "request": { + "description": "request: object\nModule: http.handlers.headers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#HeaderOps\nHeaderOps defines manipulations for HTTP headers.\n\n", + "markdownDescription": "request: `object` \nModule: `http.handlers.headers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#HeaderOps) \nHeaderOps defines manipulations for HTTP headers.\n \n", + "type": "object", + "properties": { + "add": { + "description": "add: object\nModule: http.handlers.headers\nAdds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "add: `object` \nModule: `http.handlers.headers` \nAdds HTTP headers; does not replace any existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Adds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "Adds HTTP headers; does not replace any existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "delete": { + "description": "delete: array\nModule: http.handlers.headers\nNames of HTTP header fields to delete.\n", + "markdownDescription": "delete: `array` \nModule: `http.handlers.headers` \nNames of HTTP header fields to delete. \n", + "type": "array", + "items": { + "description": "Names of HTTP header fields to delete.\n", + "markdownDescription": "Names of HTTP header fields to delete. \n", + "type": "string" + } + }, + "replace": { + "description": "replace: object\nModule: http.handlers.headers\nPerforms substring replacements of HTTP headers in-situ.\n", + "markdownDescription": "replace: `object` \nModule: `http.handlers.headers` \nPerforms substring replacements of HTTP headers in-situ. \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "object", + "properties": { + "replace": { + "description": "replace: string\nModule: http.handlers.headers\nThe string with which to replace matches.\n", + "markdownDescription": "replace: `string` \nModule: `http.handlers.headers` \nThe string with which to replace matches. \n", + "type": "string" + }, + "search": { + "description": "search: string\nModule: http.handlers.headers\nThe substring to search for.\n", + "markdownDescription": "search: `string` \nModule: `http.handlers.headers` \nThe substring to search for. \n", + "type": "string" + }, + "search_regexp": { + "description": "search_regexp: string\nModule: http.handlers.headers\nThe regular expression to search with.\n", + "markdownDescription": "search_regexp: `string` \nModule: `http.handlers.headers` \nThe regular expression to search with. \n", + "type": "string" + } + } + } + } + }, + "set": { + "description": "set: object\nModule: http.handlers.headers\nSets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "set: `object` \nModule: `http.handlers.headers` \nSets HTTP headers; replaces existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Sets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "Sets HTTP headers; replaces existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + } + } + }, + "response": { + "description": "response: object\nModule: http.handlers.headers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#RespHeaderOps\nRespHeaderOps defines manipulations for response headers.\n\n", + "markdownDescription": "response: `object` \nModule: `http.handlers.headers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#RespHeaderOps) \nRespHeaderOps defines manipulations for response headers.\n \n", + "type": "object", + "properties": { + "add": { + "description": "add: object\nModule: http.handlers.headers\nAdds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "add: `object` \nModule: `http.handlers.headers` \nAdds HTTP headers; does not replace any existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Adds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "Adds HTTP headers; does not replace any existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "deferred": { + "description": "deferred: boolean\nModule: http.handlers.headers\nIf true, header operations will be deferred until\nthey are written out. Superceded if Require is set.\nUsually you will need to set this to true if any\nfields are being deleted.\n", + "markdownDescription": "deferred: `boolean` \nModule: `http.handlers.headers` \nIf true, header operations will be deferred until\nthey are written out. Superceded if Require is set.\nUsually you will need to set this to true if any\nfields are being deleted. \n", + "type": "boolean" + }, + "delete": { + "description": "delete: array\nModule: http.handlers.headers\nNames of HTTP header fields to delete.\n", + "markdownDescription": "delete: `array` \nModule: `http.handlers.headers` \nNames of HTTP header fields to delete. \n", + "type": "array", + "items": { + "description": "Names of HTTP header fields to delete.\n", + "markdownDescription": "Names of HTTP header fields to delete. \n", + "type": "string" + } + }, + "replace": { + "description": "replace: object\nModule: http.handlers.headers\nPerforms substring replacements of HTTP headers in-situ.\n", + "markdownDescription": "replace: `object` \nModule: `http.handlers.headers` \nPerforms substring replacements of HTTP headers in-situ. \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "object", + "properties": { + "replace": { + "description": "replace: string\nModule: http.handlers.headers\nThe string with which to replace matches.\n", + "markdownDescription": "replace: `string` \nModule: `http.handlers.headers` \nThe string with which to replace matches. \n", + "type": "string" + }, + "search": { + "description": "search: string\nModule: http.handlers.headers\nThe substring to search for.\n", + "markdownDescription": "search: `string` \nModule: `http.handlers.headers` \nThe substring to search for. \n", + "type": "string" + }, + "search_regexp": { + "description": "search_regexp: string\nModule: http.handlers.headers\nThe regular expression to search with.\n", + "markdownDescription": "search_regexp: `string` \nModule: `http.handlers.headers` \nThe regular expression to search with. \n", + "type": "string" + } + } + } + } + }, + "require": { + "description": "require: object\nModule: http.handlers.headers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseMatcher\nIf set, header operations will be deferred until\nthey are written out and only performed if the\nresponse matches these criteria.\n\n\nResponseMatcher is a type which can determine if an\nHTTP response matches some criteria.\n", + "markdownDescription": "require: `object` \nModule: `http.handlers.headers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseMatcher) \nIf set, header operations will be deferred until\nthey are written out and only performed if the\nresponse matches these criteria.\n\n\nResponseMatcher is a type which can determine if an\nHTTP response matches some criteria. \n", + "type": "object", + "properties": { + "headers": { + "description": "headers: object\nModule: http.handlers.headers\nIf set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/).\n", + "markdownDescription": "headers: `object` \nModule: `http.handlers.headers` \nIf set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/). \n", + "type": "object", + "additionalProperties": { + "description": "If set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/).\n", + "markdownDescription": "If set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/). \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "status_code": { + "description": "status_code: array\nModule: http.handlers.headers\nIf set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes).\n", + "markdownDescription": "status_code: `array` \nModule: `http.handlers.headers` \nIf set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes). \n", + "type": "array", + "items": { + "description": "If set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes).\n", + "markdownDescription": "If set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes). \n", + "type": "number" + } + } + } + }, + "set": { + "description": "set: object\nModule: http.handlers.headers\nSets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "set: `object` \nModule: `http.handlers.headers` \nSets HTTP headers; replaces existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Sets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "Sets HTTP headers; replaces existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + } + } + } + } + }, + "http.handlers.map": { + "description": "map: object\nModule: http.handlers.map\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/map#Handler\nHandler implements a middleware that maps inputs to outputs. Specifically, it\ncompares a source value against the map inputs, and for one that matches, it\napplies the output values to each destination. Destinations become placeholder\nnames.\n\nMapped placeholders are not evaluated until they are used, so even for very\nlarge mappings, this handler is quite efficient.\n\n", + "markdownDescription": "map: `object` \nModule: `http.handlers.map` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/map#Handler) \nHandler implements a middleware that maps inputs to outputs. Specifically, it\ncompares a source value against the map inputs, and for one that matches, it\napplies the output values to each destination. Destinations become placeholder\nnames.\n\nMapped placeholders are not evaluated until they are used, so even for very\nlarge mappings, this handler is quite efficient.\n \n", + "type": "object", + "properties": { + "defaults": { + "description": "defaults: array\nModule: http.handlers.map\nIf no mappings match or if the mapped output is null/nil, the associated\ndefault output will be applied (optional).\n", + "markdownDescription": "defaults: `array` \nModule: `http.handlers.map` \nIf no mappings match or if the mapped output is null/nil, the associated\ndefault output will be applied (optional). \n", + "type": "array", + "items": { + "description": "If no mappings match or if the mapped output is null/nil, the associated\ndefault output will be applied (optional).\n", + "markdownDescription": "If no mappings match or if the mapped output is null/nil, the associated\ndefault output will be applied (optional). \n", + "type": "string" + } + }, + "destinations": { + "description": "destinations: array\nModule: http.handlers.map\nDestinations are the names of placeholders in which to store the outputs.\n", + "markdownDescription": "destinations: `array` \nModule: `http.handlers.map` \nDestinations are the names of placeholders in which to store the outputs. \n", + "type": "array", + "items": { + "description": "Destinations are the names of placeholders in which to store the outputs.\n", + "markdownDescription": "Destinations are the names of placeholders in which to store the outputs. \n", + "type": "string" + } + }, + "mappings": { + "description": "mappings: array\nModule: http.handlers.map\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/map#Mapping\nMappings from source values (inputs) to destination values (outputs).\nThe first matching, non-nil mapping will be applied.\n\n\nMapping describes a mapping from input to outputs.\n", + "markdownDescription": "mappings: `array` \nModule: `http.handlers.map` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/map#Mapping) \nMappings from source values (inputs) to destination values (outputs).\nThe first matching, non-nil mapping will be applied.\n\n\nMapping describes a mapping from input to outputs. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/map#Mapping\nMappings from source values (inputs) to destination values (outputs).\nThe first matching, non-nil mapping will be applied.\n\n\nMapping describes a mapping from input to outputs.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/map#Mapping) \nMappings from source values (inputs) to destination values (outputs).\nThe first matching, non-nil mapping will be applied.\n\n\nMapping describes a mapping from input to outputs. \n", + "type": "object", + "properties": { + "input": { + "description": "input: string\nModule: http.handlers.map\nThe input value to match. Must be distinct from other mappings.\nMutually exclusive to input_regexp.\n", + "markdownDescription": "input: `string` \nModule: `http.handlers.map` \nThe input value to match. Must be distinct from other mappings.\nMutually exclusive to input_regexp. \n", + "type": "string" + }, + "input_regexp": { + "description": "input_regexp: string\nModule: http.handlers.map\nThe input regular expression to match. Mutually exclusive to input.\n", + "markdownDescription": "input_regexp: `string` \nModule: `http.handlers.map` \nThe input regular expression to match. Mutually exclusive to input. \n", + "type": "string" + }, + "outputs": { + "description": "outputs: array\nModule: http.handlers.map\nUpon a match with the input, each output is positionally correlated\nwith each destination of the parent handler. An output that is null\n(nil) will be treated as if it was not mapped at all.\n", + "markdownDescription": "outputs: `array` \nModule: `http.handlers.map` \nUpon a match with the input, each output is positionally correlated\nwith each destination of the parent handler. An output that is null\n(nil) will be treated as if it was not mapped at all. \n", + "type": "array", + "items": { + "type": [ + "string", + "null" + ], + "description": "Upon a match with the input, each output is positionally correlated\nwith each destination of the parent handler. An output that is null\n(nil) will be treated as if it was not mapped at all.\n", + "markdownDescription": "Upon a match with the input, each output is positionally correlated\nwith each destination of the parent handler. An output that is null\n(nil) will be treated as if it was not mapped at all. \n" + } + } + } + } + }, + "source": { + "description": "source: string\nModule: http.handlers.map\nSource is the placeholder from which to get the input value.\n", + "markdownDescription": "source: `string` \nModule: `http.handlers.map` \nSource is the placeholder from which to get the input value. \n", + "type": "string" + } + } + }, + "http.handlers.metrics": { + "description": "metrics: object\nModule: http.handlers.metrics\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/metrics#Metrics\nMetrics is a module that serves a /metrics endpoint so that any gathered\nmetrics can be exposed for scraping. This module is configurable by end-users\nunlike AdminMetrics.\n\n", + "markdownDescription": "metrics: `object` \nModule: `http.handlers.metrics` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/metrics#Metrics) \nMetrics is a module that serves a /metrics endpoint so that any gathered\nmetrics can be exposed for scraping. This module is configurable by end-users\nunlike AdminMetrics.\n \n", + "type": "object", + "properties": { + "disable_openmetrics": { + "description": "disable_openmetrics: boolean\nModule: http.handlers.metrics\nDisable OpenMetrics negotiation, enabled by default. May be necessary if\nthe produced metrics cannot be parsed by the service scraping metrics.\n", + "markdownDescription": "disable_openmetrics: `boolean` \nModule: `http.handlers.metrics` \nDisable OpenMetrics negotiation, enabled by default. May be necessary if\nthe produced metrics cannot be parsed by the service scraping metrics. \n", + "type": "boolean" + } + } + }, + "http.handlers.push": { + "description": "push: object\nModule: http.handlers.push\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/push#Handler\nHandler is a middleware for manipulating the request body.\n\n", + "markdownDescription": "push: `object` \nModule: `http.handlers.push` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/push#Handler) \nHandler is a middleware for manipulating the request body.\n \n", + "type": "object", + "properties": { + "headers": { + "description": "headers: object\nModule: http.handlers.push\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/push#HeaderConfig\nHeaderConfig configures headers for synthetic push requests.\n\n", + "markdownDescription": "headers: `object` \nModule: `http.handlers.push` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/push#HeaderConfig) \nHeaderConfig configures headers for synthetic push requests.\n \n", + "type": "object", + "properties": { + "add": { + "description": "add: object\nModule: http.handlers.push\nAdds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "add: `object` \nModule: `http.handlers.push` \nAdds HTTP headers; does not replace any existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Adds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "Adds HTTP headers; does not replace any existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "delete": { + "description": "delete: array\nModule: http.handlers.push\nNames of HTTP header fields to delete.\n", + "markdownDescription": "delete: `array` \nModule: `http.handlers.push` \nNames of HTTP header fields to delete. \n", + "type": "array", + "items": { + "description": "Names of HTTP header fields to delete.\n", + "markdownDescription": "Names of HTTP header fields to delete. \n", + "type": "string" + } + }, + "replace": { + "description": "replace: object\nModule: http.handlers.push\nPerforms substring replacements of HTTP headers in-situ.\n", + "markdownDescription": "replace: `object` \nModule: `http.handlers.push` \nPerforms substring replacements of HTTP headers in-situ. \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "object", + "properties": { + "replace": { + "description": "replace: string\nModule: http.handlers.push\nThe string with which to replace matches.\n", + "markdownDescription": "replace: `string` \nModule: `http.handlers.push` \nThe string with which to replace matches. \n", + "type": "string" + }, + "search": { + "description": "search: string\nModule: http.handlers.push\nThe substring to search for.\n", + "markdownDescription": "search: `string` \nModule: `http.handlers.push` \nThe substring to search for. \n", + "type": "string" + }, + "search_regexp": { + "description": "search_regexp: string\nModule: http.handlers.push\nThe regular expression to search with.\n", + "markdownDescription": "search_regexp: `string` \nModule: `http.handlers.push` \nThe regular expression to search with. \n", + "type": "string" + } + } + } + } + }, + "set": { + "description": "set: object\nModule: http.handlers.push\nSets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "set: `object` \nModule: `http.handlers.push` \nSets HTTP headers; replaces existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Sets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "Sets HTTP headers; replaces existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + } + } + }, + "resources": { + "description": "resources: array\nModule: http.handlers.push\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/push#Resource\nResource represents a request for a resource to push.\n\n", + "markdownDescription": "resources: `array` \nModule: `http.handlers.push` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/push#Resource) \nResource represents a request for a resource to push.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/push#Resource\nResource represents a request for a resource to push.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/push#Resource) \nResource represents a request for a resource to push.\n \n", + "type": "object", + "properties": { + "method": { + "description": "method: string\nModule: http.handlers.push\nMethod is the request method, which must be GET or HEAD.\nDefault is GET.\n", + "markdownDescription": "method: `string` \nModule: `http.handlers.push` \nMethod is the request method, which must be GET or HEAD.\nDefault is GET. \n", + "type": "string" + }, + "target": { + "description": "target: string\nModule: http.handlers.push\nTarget is the path to the resource being pushed.\n", + "markdownDescription": "target: `string` \nModule: `http.handlers.push` \nTarget is the path to the resource being pushed. \n", + "type": "string" + } + } + } + } + } + }, + "http.handlers.request_body": { + "description": "request_body: object\nModule: http.handlers.request_body\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/requestbody#RequestBody\nRequestBody is a middleware for manipulating the request body.\n\n", + "markdownDescription": "request_body: `object` \nModule: `http.handlers.request_body` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/requestbody#RequestBody) \nRequestBody is a middleware for manipulating the request body.\n \n", + "type": "object", + "properties": { + "max_size": { + "description": "max_size: number\nModule: http.handlers.request_body\nThe maximum number of bytes to allow reading from the body by a later handler.\nIf more bytes are read, an error with HTTP status 413 is returned.\n", + "markdownDescription": "max_size: `number` \nModule: `http.handlers.request_body` \nThe maximum number of bytes to allow reading from the body by a later handler.\nIf more bytes are read, an error with HTTP status 413 is returned. \n", + "type": "number" + } + } + }, + "http.handlers.reverse_proxy": { + "description": "reverse_proxy: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#Handler\nHandler implements a highly configurable and production-ready reverse proxy.\n\nUpon proxying, this module sets the following placeholders (which can be used\nboth within and after this handler; for example, in response headers):\n\nPlaceholder | Description\n------------|-------------\n`{http.reverse_proxy.upstream.address}` | The full address to the upstream as given in the config\n`{http.reverse_proxy.upstream.hostport}` | The host:port of the upstream\n`{http.reverse_proxy.upstream.host}` | The host of the upstream\n`{http.reverse_proxy.upstream.port}` | The port of the upstream\n`{http.reverse_proxy.upstream.requests}` | The approximate current number of requests to the upstream\n`{http.reverse_proxy.upstream.max_requests}` | The maximum approximate number of requests allowed to the upstream\n`{http.reverse_proxy.upstream.fails}` | The number of recent failed requests to the upstream\n`{http.reverse_proxy.upstream.latency}` | How long it took the proxy upstream to write the response header.\n`{http.reverse_proxy.upstream.latency_ms}` | Same as 'latency', but in milliseconds.\n`{http.reverse_proxy.upstream.duration}` | Time spent proxying to the upstream, including writing response body to client.\n`{http.reverse_proxy.upstream.duration_ms}` | Same as 'upstream.duration', but in milliseconds.\n`{http.reverse_proxy.duration}` | Total time spent proxying, including selecting an upstream, retries, and writing response.\n`{http.reverse_proxy.duration_ms}` | Same as 'duration', but in milliseconds.\n\n", + "markdownDescription": "reverse_proxy: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#Handler) \nHandler implements a highly configurable and production-ready reverse proxy.\n\nUpon proxying, this module sets the following placeholders (which can be used\nboth within and after this handler; for example, in response headers):\n\nPlaceholder | Description\n------------|-------------\n`{http.reverse_proxy.upstream.address}` | The full address to the upstream as given in the config\n`{http.reverse_proxy.upstream.hostport}` | The host:port of the upstream\n`{http.reverse_proxy.upstream.host}` | The host of the upstream\n`{http.reverse_proxy.upstream.port}` | The port of the upstream\n`{http.reverse_proxy.upstream.requests}` | The approximate current number of requests to the upstream\n`{http.reverse_proxy.upstream.max_requests}` | The maximum approximate number of requests allowed to the upstream\n`{http.reverse_proxy.upstream.fails}` | The number of recent failed requests to the upstream\n`{http.reverse_proxy.upstream.latency}` | How long it took the proxy upstream to write the response header.\n`{http.reverse_proxy.upstream.latency_ms}` | Same as 'latency', but in milliseconds.\n`{http.reverse_proxy.upstream.duration}` | Time spent proxying to the upstream, including writing response body to client.\n`{http.reverse_proxy.upstream.duration_ms}` | Same as 'upstream.duration', but in milliseconds.\n`{http.reverse_proxy.duration}` | Total time spent proxying, including selecting an upstream, retries, and writing response.\n`{http.reverse_proxy.duration_ms}` | Same as 'duration', but in milliseconds.\n \n", + "type": "object", + "properties": { + "buffer_requests": { + "description": "buffer_requests: boolean\nModule: http.handlers.reverse_proxy\nIf true, the entire request body will be read and buffered\nin memory before being proxied to the backend. This should\nbe avoided if at all possible for performance reasons, but\ncould be useful if the backend is intolerant of read latency.\n", + "markdownDescription": "buffer_requests: `boolean` \nModule: `http.handlers.reverse_proxy` \nIf true, the entire request body will be read and buffered\nin memory before being proxied to the backend. This should\nbe avoided if at all possible for performance reasons, but\ncould be useful if the backend is intolerant of read latency. \n", + "type": "boolean" + }, + "buffer_responses": { + "description": "buffer_responses: boolean\nModule: http.handlers.reverse_proxy\nIf true, the entire response body will be read and buffered\nin memory before being proxied to the client. This should\nbe avoided if at all possible for performance reasons, but\ncould be useful if the backend has tighter memory constraints.\n", + "markdownDescription": "buffer_responses: `boolean` \nModule: `http.handlers.reverse_proxy` \nIf true, the entire response body will be read and buffered\nin memory before being proxied to the client. This should\nbe avoided if at all possible for performance reasons, but\ncould be useful if the backend has tighter memory constraints. \n", + "type": "boolean" + }, + "circuit_breaker": { + "description": "circuit_breaker: any\nModule: http.reverse_proxy.circuit_breakers\nA circuit breaker may be used to relieve pressure on a backend\nthat is beginning to exhibit symptoms of stress or latency.\nBy default, there is no circuit breaker.\n", + "markdownDescription": "circuit_breaker: `any` \nModule: `http.reverse_proxy.circuit_breakers` \nA circuit breaker may be used to relieve pressure on a backend\nthat is beginning to exhibit symptoms of stress or latency.\nBy default, there is no circuit breaker. \n" + }, + "dynamic_upstreams": { + "description": "dynamic_upstreams: object\nModule: http.reverse_proxy.upstreams\nA module for retrieving the list of upstreams dynamically. Dynamic\nupstreams are retrieved at every iteration of the proxy loop for\neach request (i.e. before every proxy attempt within every request).\nActive health checks do not work on dynamic upstreams, and passive\nhealth checks are only effective on dynamic upstreams if the proxy\nserver is busy enough that concurrent requests to the same backends\nare continuous. Instead of health checks for dynamic upstreams, it\nis recommended that the dynamic upstream module only return available\nbackends in the first place.\n", + "markdownDescription": "dynamic_upstreams: `object` \nModule: `http.reverse_proxy.upstreams` \nA module for retrieving the list of upstreams dynamically. Dynamic\nupstreams are retrieved at every iteration of the proxy loop for\neach request (i.e. before every proxy attempt within every request).\nActive health checks do not work on dynamic upstreams, and passive\nhealth checks are only effective on dynamic upstreams if the proxy\nserver is busy enough that concurrent requests to the same backends\nare continuous. Instead of health checks for dynamic upstreams, it\nis recommended that the dynamic upstream module only return available\nbackends in the first place. \n", + "type": "object", + "required": [ + "source" + ], + "allOf": [ + { + "if": { + "properties": { + "source": { + "const": "a" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.upstreams.a" + } + }, + { + "if": { + "properties": { + "source": { + "const": "srv" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.upstreams.srv" + } + }, + { + "properties": { + "source": { + "description": "key to identify dynamic_upstreams module.\nsource: string\nModule: http.reverse_proxy.upstreams", + "markdownDescription": "key to identify `dynamic_upstreams` module. \nsource: `string` \nModule: `http.reverse_proxy.upstreams`", + "type": "string", + "enum": [ + "a", + "srv" + ] + } + } + } + ] + }, + "flush_interval": { + "description": "flush_interval: number\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nAdjusts how often to flush the response buffer. By default,\nno periodic flushing is done. A negative value disables\nresponse buffering, and flushes immediately after each\nwrite to the client. This option is ignored when the upstream's\nresponse is recognized as a streaming response, or if its\ncontent length is -1; for such responses, writes are flushed\nto the client immediately.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "flush_interval: `number` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nAdjusts how often to flush the response buffer. By default,\nno periodic flushing is done. A negative value disables\nresponse buffering, and flushes immediately after each\nwrite to the client. This option is ignored when the upstream's\nresponse is recognized as a streaming response, or if its\ncontent length is -1; for such responses, writes are flushed\nto the client immediately.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "handle_response": { + "description": "handle_response: array\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseHandler\nList of handlers and their associated matchers to evaluate\nafter successful roundtrips. The first handler that matches\nthe response from a backend will be invoked. The response\nbody from the backend will not be written to the client;\nit is up to the handler to finish handling the response.\nIf passive health checks are enabled, any errors from the\nhandler chain will not affect the health status of the\nbackend.\n\nThree new placeholders are available in this handler chain:\n- `{http.reverse_proxy.status_code}` The status code from the response\n- `{http.reverse_proxy.status_text}` The status text from the response\n- `{http.reverse_proxy.header.*}` The headers from the response\n\n\nResponseHandler pairs a response matcher with custom handling\nlogic. Either the status code can be changed to something else\nwhile using the original response body, or, if a status code\nis not set, it can execute a custom route list; this is useful\nfor executing handler routes based on the properties of an HTTP\nresponse that has not been written out to the client yet.\n\nTo use this type, provision it at module load time, then when\nready to use, match the response against its matcher; if it\nmatches (or doesn't have a matcher), change the status code on\nthe response if configured; otherwise invoke the routes by\ncalling `rh.Routes.Compile(next).ServeHTTP(rw, req)` (or similar).\n", + "markdownDescription": "handle_response: `array` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseHandler) \nList of handlers and their associated matchers to evaluate\nafter successful roundtrips. The first handler that matches\nthe response from a backend will be invoked. The response\nbody from the backend will not be written to the client;\nit is up to the handler to finish handling the response.\nIf passive health checks are enabled, any errors from the\nhandler chain will not affect the health status of the\nbackend.\n\nThree new placeholders are available in this handler chain:\n- `{http.reverse_proxy.status_code}` The status code from the response\n- `{http.reverse_proxy.status_text}` The status text from the response\n- `{http.reverse_proxy.header.*}` The headers from the response\n\n\nResponseHandler pairs a response matcher with custom handling\nlogic. Either the status code can be changed to something else\nwhile using the original response body, or, if a status code\nis not set, it can execute a custom route list; this is useful\nfor executing handler routes based on the properties of an HTTP\nresponse that has not been written out to the client yet.\n\nTo use this type, provision it at module load time, then when\nready to use, match the response against its matcher; if it\nmatches (or doesn't have a matcher), change the status code on\nthe response if configured; otherwise invoke the routes by\ncalling `rh.Routes.Compile(next).ServeHTTP(rw, req)` (or similar). \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseHandler\nList of handlers and their associated matchers to evaluate\nafter successful roundtrips. The first handler that matches\nthe response from a backend will be invoked. The response\nbody from the backend will not be written to the client;\nit is up to the handler to finish handling the response.\nIf passive health checks are enabled, any errors from the\nhandler chain will not affect the health status of the\nbackend.\n\nThree new placeholders are available in this handler chain:\n- `{http.reverse_proxy.status_code}` The status code from the response\n- `{http.reverse_proxy.status_text}` The status text from the response\n- `{http.reverse_proxy.header.*}` The headers from the response\n\n\nResponseHandler pairs a response matcher with custom handling\nlogic. Either the status code can be changed to something else\nwhile using the original response body, or, if a status code\nis not set, it can execute a custom route list; this is useful\nfor executing handler routes based on the properties of an HTTP\nresponse that has not been written out to the client yet.\n\nTo use this type, provision it at module load time, then when\nready to use, match the response against its matcher; if it\nmatches (or doesn't have a matcher), change the status code on\nthe response if configured; otherwise invoke the routes by\ncalling `rh.Routes.Compile(next).ServeHTTP(rw, req)` (or similar).\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseHandler) \nList of handlers and their associated matchers to evaluate\nafter successful roundtrips. The first handler that matches\nthe response from a backend will be invoked. The response\nbody from the backend will not be written to the client;\nit is up to the handler to finish handling the response.\nIf passive health checks are enabled, any errors from the\nhandler chain will not affect the health status of the\nbackend.\n\nThree new placeholders are available in this handler chain:\n- `{http.reverse_proxy.status_code}` The status code from the response\n- `{http.reverse_proxy.status_text}` The status text from the response\n- `{http.reverse_proxy.header.*}` The headers from the response\n\n\nResponseHandler pairs a response matcher with custom handling\nlogic. Either the status code can be changed to something else\nwhile using the original response body, or, if a status code\nis not set, it can execute a custom route list; this is useful\nfor executing handler routes based on the properties of an HTTP\nresponse that has not been written out to the client yet.\n\nTo use this type, provision it at module load time, then when\nready to use, match the response against its matcher; if it\nmatches (or doesn't have a matcher), change the status code on\nthe response if configured; otherwise invoke the routes by\ncalling `rh.Routes.Compile(next).ServeHTTP(rw, req)` (or similar). \n", + "type": "object", + "properties": { + "match": { + "description": "match: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseMatcher\nThe response matcher for this handler. If empty/nil,\nit always matches.\n\n\nResponseMatcher is a type which can determine if an\nHTTP response matches some criteria.\n", + "markdownDescription": "match: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseMatcher) \nThe response matcher for this handler. If empty/nil,\nit always matches.\n\n\nResponseMatcher is a type which can determine if an\nHTTP response matches some criteria. \n", + "type": "object", + "properties": { + "headers": { + "description": "headers: object\nModule: http.handlers.reverse_proxy\nIf set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/).\n", + "markdownDescription": "headers: `object` \nModule: `http.handlers.reverse_proxy` \nIf set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/). \n", + "type": "object", + "additionalProperties": { + "description": "If set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/).\n", + "markdownDescription": "If set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/). \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "status_code": { + "description": "status_code: array\nModule: http.handlers.reverse_proxy\nIf set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes).\n", + "markdownDescription": "status_code: `array` \nModule: `http.handlers.reverse_proxy` \nIf set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes). \n", + "type": "array", + "items": { + "description": "If set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes).\n", + "markdownDescription": "If set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes). \n", + "type": "number" + } + } + } + }, + "routes": { + "description": "routes: array\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nThe list of HTTP routes to execute if no status code is\nspecified. If evaluated, the original response body\nwill not be written.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "routes: `array` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nThe list of HTTP routes to execute if no status code is\nspecified. If evaluated, the original response body\nwill not be written.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nThe list of HTTP routes to execute if no status code is\nspecified. If evaluated, the original response body\nwill not be written.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nThe list of HTTP routes to execute if no status code is\nspecified. If evaluated, the original response body\nwill not be written.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "object", + "properties": { + "group": { + "description": "group: string\nModule: http.handlers.reverse_proxy\nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed.\n", + "markdownDescription": "group: `string` \nModule: `http.handlers.reverse_proxy` \nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed. \n", + "type": "string" + }, + "handle": { + "description": "handle: array\nModule: http.handlers\nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "handle: `array` \nModule: `http.handlers` \nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "type": "array", + "items": { + "description": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "required": [ + "handler" + ], + "allOf": [ + { + "if": { + "properties": { + "handler": { + "const": "static_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.static_response" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "authentication" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.authentication" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response_headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response_headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "error" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.error" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "file_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.file_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "map" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.map" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "reverse_proxy" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.reverse_proxy" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "templates" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.templates" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "acme_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.acme_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "vars" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.vars" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "push" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.push" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "metrics" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.metrics" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "request_body" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.request_body" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "rewrite" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.rewrite" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "subroute" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.subroute" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tracing" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.tracing" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "encode" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.encode" + } + }, + { + "properties": { + "handler": { + "description": "key to identify handle module.\nhandler: string\nModule: http.handlers", + "markdownDescription": "key to identify `handle` module. \nhandler: `string` \nModule: `http.handlers`", + "type": "string", + "enum": [ + "static_response", + "authentication", + "copy_response", + "copy_response_headers", + "error", + "file_server", + "map", + "reverse_proxy", + "templates", + "acme_server", + "vars", + "push", + "headers", + "metrics", + "request_body", + "rewrite", + "subroute", + "tracing", + "encode" + ] + } + } + } + ] + } + }, + "match": { + "description": "match: array\nModule: http.matchers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "match: `array` \nModule: `http.matchers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "properties": { + "expression": { + "$ref": "#/definitions/http.matchers.expression" + }, + "file": { + "$ref": "#/definitions/http.matchers.file" + }, + "header": { + "$ref": "#/definitions/http.matchers.header" + }, + "header_regexp": { + "$ref": "#/definitions/http.matchers.header_regexp" + }, + "host": { + "$ref": "#/definitions/http.matchers.host" + }, + "method": { + "$ref": "#/definitions/http.matchers.method" + }, + "not": { + "$ref": "#/definitions/http.matchers.not" + }, + "path": { + "$ref": "#/definitions/http.matchers.path" + }, + "path_regexp": { + "$ref": "#/definitions/http.matchers.path_regexp" + }, + "protocol": { + "$ref": "#/definitions/http.matchers.protocol" + }, + "query": { + "$ref": "#/definitions/http.matchers.query" + }, + "remote_ip": { + "$ref": "#/definitions/http.matchers.remote_ip" + }, + "vars": { + "$ref": "#/definitions/http.matchers.vars" + }, + "vars_regexp": { + "$ref": "#/definitions/http.matchers.vars_regexp" + } + } + } + }, + "terminal": { + "description": "terminal: boolean\nModule: http.handlers.reverse_proxy\nIf true, no more routes will be executed after this one.\n", + "markdownDescription": "terminal: `boolean` \nModule: `http.handlers.reverse_proxy` \nIf true, no more routes will be executed after this one. \n", + "type": "boolean" + } + } + } + }, + "status_code": { + "description": "status_code: string\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString\nTo write the original response body but with a different\nstatus code, set this field to the desired status code.\nIf set, this takes priority over routes.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned.\n", + "markdownDescription": "status_code: `string` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString) \nTo write the original response body but with a different\nstatus code, set this field to the desired status code.\nIf set, this takes priority over routes.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned. \n", + "type": "string" + } + } + } + }, + "headers": { + "description": "headers: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Handler\nHeaders manipulates headers between Caddy and the backend.\nBy default, all headers are passed-thru without changes,\nwith the exceptions of special hop-by-hop headers.\n\nX-Forwarded-For, X-Forwarded-Proto and X-Forwarded-Host\nare also set implicitly.\n\n\nHandler is a middleware which modifies request and response headers.\n\nChanges to headers are applied immediately, except for the response\nheaders when Deferred is true or when Required is set. In those cases,\nthe changes are applied when the headers are written to the response.\nNote that deferred changes do not take effect if an error occurs later\nin the middleware chain.\n\nProperties in this module accept placeholders.\n\nResponse header operations can be conditioned upon response status code\nand/or other header values.\n", + "markdownDescription": "headers: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Handler) \nHeaders manipulates headers between Caddy and the backend.\nBy default, all headers are passed-thru without changes,\nwith the exceptions of special hop-by-hop headers.\n\nX-Forwarded-For, X-Forwarded-Proto and X-Forwarded-Host\nare also set implicitly.\n\n\nHandler is a middleware which modifies request and response headers.\n\nChanges to headers are applied immediately, except for the response\nheaders when Deferred is true or when Required is set. In those cases,\nthe changes are applied when the headers are written to the response.\nNote that deferred changes do not take effect if an error occurs later\nin the middleware chain.\n\nProperties in this module accept placeholders.\n\nResponse header operations can be conditioned upon response status code\nand/or other header values. \n", + "type": "object", + "properties": { + "request": { + "description": "request: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#HeaderOps\nHeaderOps defines manipulations for HTTP headers.\n\n", + "markdownDescription": "request: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#HeaderOps) \nHeaderOps defines manipulations for HTTP headers.\n \n", + "type": "object", + "properties": { + "add": { + "description": "add: object\nModule: http.handlers.reverse_proxy\nAdds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "add: `object` \nModule: `http.handlers.reverse_proxy` \nAdds HTTP headers; does not replace any existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Adds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "Adds HTTP headers; does not replace any existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "delete": { + "description": "delete: array\nModule: http.handlers.reverse_proxy\nNames of HTTP header fields to delete.\n", + "markdownDescription": "delete: `array` \nModule: `http.handlers.reverse_proxy` \nNames of HTTP header fields to delete. \n", + "type": "array", + "items": { + "description": "Names of HTTP header fields to delete.\n", + "markdownDescription": "Names of HTTP header fields to delete. \n", + "type": "string" + } + }, + "replace": { + "description": "replace: object\nModule: http.handlers.reverse_proxy\nPerforms substring replacements of HTTP headers in-situ.\n", + "markdownDescription": "replace: `object` \nModule: `http.handlers.reverse_proxy` \nPerforms substring replacements of HTTP headers in-situ. \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "object", + "properties": { + "replace": { + "description": "replace: string\nModule: http.handlers.reverse_proxy\nThe string with which to replace matches.\n", + "markdownDescription": "replace: `string` \nModule: `http.handlers.reverse_proxy` \nThe string with which to replace matches. \n", + "type": "string" + }, + "search": { + "description": "search: string\nModule: http.handlers.reverse_proxy\nThe substring to search for.\n", + "markdownDescription": "search: `string` \nModule: `http.handlers.reverse_proxy` \nThe substring to search for. \n", + "type": "string" + }, + "search_regexp": { + "description": "search_regexp: string\nModule: http.handlers.reverse_proxy\nThe regular expression to search with.\n", + "markdownDescription": "search_regexp: `string` \nModule: `http.handlers.reverse_proxy` \nThe regular expression to search with. \n", + "type": "string" + } + } + } + } + }, + "set": { + "description": "set: object\nModule: http.handlers.reverse_proxy\nSets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "set: `object` \nModule: `http.handlers.reverse_proxy` \nSets HTTP headers; replaces existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Sets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "Sets HTTP headers; replaces existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + } + } + }, + "response": { + "description": "response: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#RespHeaderOps\nRespHeaderOps defines manipulations for response headers.\n\n", + "markdownDescription": "response: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#RespHeaderOps) \nRespHeaderOps defines manipulations for response headers.\n \n", + "type": "object", + "properties": { + "add": { + "description": "add: object\nModule: http.handlers.reverse_proxy\nAdds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "add: `object` \nModule: `http.handlers.reverse_proxy` \nAdds HTTP headers; does not replace any existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Adds HTTP headers; does not replace any existing header fields.\n", + "markdownDescription": "Adds HTTP headers; does not replace any existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "deferred": { + "description": "deferred: boolean\nModule: http.handlers.reverse_proxy\nIf true, header operations will be deferred until\nthey are written out. Superceded if Require is set.\nUsually you will need to set this to true if any\nfields are being deleted.\n", + "markdownDescription": "deferred: `boolean` \nModule: `http.handlers.reverse_proxy` \nIf true, header operations will be deferred until\nthey are written out. Superceded if Require is set.\nUsually you will need to set this to true if any\nfields are being deleted. \n", + "type": "boolean" + }, + "delete": { + "description": "delete: array\nModule: http.handlers.reverse_proxy\nNames of HTTP header fields to delete.\n", + "markdownDescription": "delete: `array` \nModule: `http.handlers.reverse_proxy` \nNames of HTTP header fields to delete. \n", + "type": "array", + "items": { + "description": "Names of HTTP header fields to delete.\n", + "markdownDescription": "Names of HTTP header fields to delete. \n", + "type": "string" + } + }, + "replace": { + "description": "replace: object\nModule: http.handlers.reverse_proxy\nPerforms substring replacements of HTTP headers in-situ.\n", + "markdownDescription": "replace: `object` \nModule: `http.handlers.reverse_proxy` \nPerforms substring replacements of HTTP headers in-situ. \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement\nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/headers#Replacement) \nReplacement describes a string replacement,\neither a simple and fast substring search\nor a slower but more powerful regex search.\n \n", + "type": "object", + "properties": { + "replace": { + "description": "replace: string\nModule: http.handlers.reverse_proxy\nThe string with which to replace matches.\n", + "markdownDescription": "replace: `string` \nModule: `http.handlers.reverse_proxy` \nThe string with which to replace matches. \n", + "type": "string" + }, + "search": { + "description": "search: string\nModule: http.handlers.reverse_proxy\nThe substring to search for.\n", + "markdownDescription": "search: `string` \nModule: `http.handlers.reverse_proxy` \nThe substring to search for. \n", + "type": "string" + }, + "search_regexp": { + "description": "search_regexp: string\nModule: http.handlers.reverse_proxy\nThe regular expression to search with.\n", + "markdownDescription": "search_regexp: `string` \nModule: `http.handlers.reverse_proxy` \nThe regular expression to search with. \n", + "type": "string" + } + } + } + } + }, + "require": { + "description": "require: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseMatcher\nIf set, header operations will be deferred until\nthey are written out and only performed if the\nresponse matches these criteria.\n\n\nResponseMatcher is a type which can determine if an\nHTTP response matches some criteria.\n", + "markdownDescription": "require: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#ResponseMatcher) \nIf set, header operations will be deferred until\nthey are written out and only performed if the\nresponse matches these criteria.\n\n\nResponseMatcher is a type which can determine if an\nHTTP response matches some criteria. \n", + "type": "object", + "properties": { + "headers": { + "description": "headers: object\nModule: http.handlers.reverse_proxy\nIf set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/).\n", + "markdownDescription": "headers: `object` \nModule: `http.handlers.reverse_proxy` \nIf set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/). \n", + "type": "object", + "additionalProperties": { + "description": "If set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/).\n", + "markdownDescription": "If set, each header specified must be one of the\nspecified values, with the same logic used by the\n[request header matcher](/docs/json/apps/http/servers/routes/match/header/). \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "status_code": { + "description": "status_code: array\nModule: http.handlers.reverse_proxy\nIf set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes).\n", + "markdownDescription": "status_code: `array` \nModule: `http.handlers.reverse_proxy` \nIf set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes). \n", + "type": "array", + "items": { + "description": "If set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes).\n", + "markdownDescription": "If set, one of these status codes would be required.\nA one-digit status can be used to represent all codes\nin that class (e.g. 3 for all 3xx codes). \n", + "type": "number" + } + } + } + }, + "set": { + "description": "set: object\nModule: http.handlers.reverse_proxy\nSets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "set: `object` \nModule: `http.handlers.reverse_proxy` \nSets HTTP headers; replaces existing header fields. \n", + "type": "object", + "additionalProperties": { + "description": "Sets HTTP headers; replaces existing header fields.\n", + "markdownDescription": "Sets HTTP headers; replaces existing header fields. \n", + "type": "array", + "items": { + "type": "string" + } + } + } + } + } + } + }, + "health_checks": { + "description": "health_checks: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HealthChecks\nHealth checks update the status of backends, whether they are\nup or down. Down backends will not be proxied to.\n\n\nHealthChecks configures active and passive health checks.\n", + "markdownDescription": "health_checks: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HealthChecks) \nHealth checks update the status of backends, whether they are\nup or down. Down backends will not be proxied to.\n\n\nHealthChecks configures active and passive health checks. \n", + "type": "object", + "properties": { + "active": { + "description": "active: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#ActiveHealthChecks\nActive health checks run in the background on a timer. To\nminimally enable active health checks, set either path or\nport (or both). Note that active health check status\n(healthy/unhealthy) is stored per-proxy-handler, not\nglobally; this allows different handlers to use different\ncriteria to decide what defines a healthy backend.\n\nActive health checks do not run for dynamic upstreams.\n\n\nActiveHealthChecks holds configuration related to active\nhealth checks (that is, health checks which occur in a\nbackground goroutine independently).\n", + "markdownDescription": "active: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#ActiveHealthChecks) \nActive health checks run in the background on a timer. To\nminimally enable active health checks, set either path or\nport (or both). Note that active health check status\n(healthy/unhealthy) is stored per-proxy-handler, not\nglobally; this allows different handlers to use different\ncriteria to decide what defines a healthy backend.\n\nActive health checks do not run for dynamic upstreams.\n\n\nActiveHealthChecks holds configuration related to active\nhealth checks (that is, health checks which occur in a\nbackground goroutine independently). \n", + "type": "object", + "properties": { + "expect_body": { + "description": "expect_body: string\nModule: http.handlers.reverse_proxy\nA regular expression against which to match the response\nbody of a healthy backend.\n", + "markdownDescription": "expect_body: `string` \nModule: `http.handlers.reverse_proxy` \nA regular expression against which to match the response\nbody of a healthy backend. \n", + "type": "string" + }, + "expect_status": { + "description": "expect_status: number\nModule: http.handlers.reverse_proxy\nThe HTTP status code to expect from a healthy backend.\n", + "markdownDescription": "expect_status: `number` \nModule: `http.handlers.reverse_proxy` \nThe HTTP status code to expect from a healthy backend. \n", + "type": "number" + }, + "headers": { + "description": "headers: object\nModule: http.handlers.reverse_proxy\nHTTP headers to set on health check requests.\n", + "markdownDescription": "headers: `object` \nModule: `http.handlers.reverse_proxy` \nHTTP headers to set on health check requests. \n", + "type": "object", + "additionalProperties": { + "description": "HTTP headers to set on health check requests.\n", + "markdownDescription": "HTTP headers to set on health check requests. \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "interval": { + "description": "interval: number\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow frequently to perform active health checks (default 30s).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "interval: `number` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow frequently to perform active health checks (default 30s).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "max_size": { + "description": "max_size: number\nModule: http.handlers.reverse_proxy\nThe maximum response body to download from the backend\nduring a health check.\n", + "markdownDescription": "max_size: `number` \nModule: `http.handlers.reverse_proxy` \nThe maximum response body to download from the backend\nduring a health check. \n", + "type": "number" + }, + "path": { + "description": "path: string\nModule: http.handlers.reverse_proxy\nDEPRECATED: Use 'uri' instead. This field will be removed. TODO: remove this field\n", + "markdownDescription": "path: `string` \nModule: `http.handlers.reverse_proxy` \nDEPRECATED: Use 'uri' instead. This field will be removed. TODO: remove this field \n", + "type": "string" + }, + "port": { + "description": "port: number\nModule: http.handlers.reverse_proxy\nThe port to use (if different from the upstream's dial\naddress) for health checks.\n", + "markdownDescription": "port: `number` \nModule: `http.handlers.reverse_proxy` \nThe port to use (if different from the upstream's dial\naddress) for health checks. \n", + "type": "number" + }, + "timeout": { + "description": "timeout: number\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to wait for a response from a backend before\nconsidering it unhealthy (default 5s).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "timeout: `number` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to wait for a response from a backend before\nconsidering it unhealthy (default 5s).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "uri": { + "description": "uri: string\nModule: http.handlers.reverse_proxy\nThe URI (path and query) to use for health checks\n", + "markdownDescription": "uri: `string` \nModule: `http.handlers.reverse_proxy` \nThe URI (path and query) to use for health checks \n", + "type": "string" + } + } + }, + "passive": { + "description": "passive: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#PassiveHealthChecks\nPassive health checks monitor proxied requests for errors or timeouts.\nTo minimally enable passive health checks, specify at least an empty\nconfig object. Passive health check state is shared (stored globally),\nso a failure from one handler will be counted by all handlers; but\nthe tolerances or standards for what defines healthy/unhealthy backends\nis configured per-proxy-handler.\n\nPassive health checks technically do operate on dynamic upstreams,\nbut are only effective for very busy proxies where the list of\nupstreams is mostly stable. This is because the shared/global\nstate of upstreams is cleaned up when the upstreams are no longer\nused. Since dynamic upstreams are allocated dynamically at each\nrequest (specifically, each iteration of the proxy loop per request),\nthey are also cleaned up after every request. Thus, if there is a\nmoment when no requests are actively referring to a particular\nupstream host, the passive health check state will be reset because\nit will be garbage-collected. It is usually better for the dynamic\nupstream module to only return healthy, available backends instead.\n\n\nPassiveHealthChecks holds configuration related to passive\nhealth checks (that is, health checks which occur during\nthe normal flow of request proxying).\n", + "markdownDescription": "passive: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#PassiveHealthChecks) \nPassive health checks monitor proxied requests for errors or timeouts.\nTo minimally enable passive health checks, specify at least an empty\nconfig object. Passive health check state is shared (stored globally),\nso a failure from one handler will be counted by all handlers; but\nthe tolerances or standards for what defines healthy/unhealthy backends\nis configured per-proxy-handler.\n\nPassive health checks technically do operate on dynamic upstreams,\nbut are only effective for very busy proxies where the list of\nupstreams is mostly stable. This is because the shared/global\nstate of upstreams is cleaned up when the upstreams are no longer\nused. Since dynamic upstreams are allocated dynamically at each\nrequest (specifically, each iteration of the proxy loop per request),\nthey are also cleaned up after every request. Thus, if there is a\nmoment when no requests are actively referring to a particular\nupstream host, the passive health check state will be reset because\nit will be garbage-collected. It is usually better for the dynamic\nupstream module to only return healthy, available backends instead.\n\n\nPassiveHealthChecks holds configuration related to passive\nhealth checks (that is, health checks which occur during\nthe normal flow of request proxying). \n", + "type": "object", + "properties": { + "fail_duration": { + "description": "fail_duration: number\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to remember a failed request to a backend. A duration \u003e 0\nenables passive health checking. Default is 0.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "fail_duration: `number` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to remember a failed request to a backend. A duration \u003e 0\nenables passive health checking. Default is 0.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "max_fails": { + "description": "max_fails: number\nModule: http.handlers.reverse_proxy\nThe number of failed requests within the FailDuration window to\nconsider a backend as \"down\". Must be \u003e= 1; default is 1. Requires\nthat FailDuration be \u003e 0.\n", + "markdownDescription": "max_fails: `number` \nModule: `http.handlers.reverse_proxy` \nThe number of failed requests within the FailDuration window to\nconsider a backend as \"down\". Must be \u003e= 1; default is 1. Requires\nthat FailDuration be \u003e 0. \n", + "type": "number" + }, + "unhealthy_latency": { + "description": "unhealthy_latency: number\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nCount the request as failed if the response takes at least this\nlong to receive.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "unhealthy_latency: `number` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nCount the request as failed if the response takes at least this\nlong to receive.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "unhealthy_request_count": { + "description": "unhealthy_request_count: number\nModule: http.handlers.reverse_proxy\nLimits the number of simultaneous requests to a backend by\nmarking the backend as \"down\" if it has this many concurrent\nrequests or more.\n", + "markdownDescription": "unhealthy_request_count: `number` \nModule: `http.handlers.reverse_proxy` \nLimits the number of simultaneous requests to a backend by\nmarking the backend as \"down\" if it has this many concurrent\nrequests or more. \n", + "type": "number" + }, + "unhealthy_status": { + "description": "unhealthy_status: array\nModule: http.handlers.reverse_proxy\nCount the request as failed if the response comes back with\none of these status codes.\n", + "markdownDescription": "unhealthy_status: `array` \nModule: `http.handlers.reverse_proxy` \nCount the request as failed if the response comes back with\none of these status codes. \n", + "type": "array", + "items": { + "description": "Count the request as failed if the response comes back with\none of these status codes.\n", + "markdownDescription": "Count the request as failed if the response comes back with\none of these status codes. \n", + "type": "number" + } + } + } + } + } + }, + "load_balancing": { + "description": "load_balancing: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#LoadBalancing\nLoad balancing distributes load/requests between backends.\n\n\nLoadBalancing has parameters related to load balancing.\n", + "markdownDescription": "load_balancing: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#LoadBalancing) \nLoad balancing distributes load/requests between backends.\n\n\nLoadBalancing has parameters related to load balancing. \n", + "type": "object", + "properties": { + "retry_match": { + "description": "retry_match: array\nModule: http.matchers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nA list of matcher sets that restricts with which requests retries are\nallowed. A request must match any of the given matcher sets in order\nto be retried if the connection to the upstream succeeded but the\nsubsequent round-trip failed. If the connection to the upstream failed,\na retry is always allowed. If unspecified, only GET requests will be\nallowed to be retried. Note that a retry is done with the next available\nhost according to the load balancing policy.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "retry_match: `array` \nModule: `http.matchers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nA list of matcher sets that restricts with which requests retries are\nallowed. A request must match any of the given matcher sets in order\nto be retried if the connection to the upstream succeeded but the\nsubsequent round-trip failed. If the connection to the upstream failed,\na retry is always allowed. If unspecified, only GET requests will be\nallowed to be retried. Note that a retry is done with the next available\nhost according to the load balancing policy.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nA list of matcher sets that restricts with which requests retries are\nallowed. A request must match any of the given matcher sets in order\nto be retried if the connection to the upstream succeeded but the\nsubsequent round-trip failed. If the connection to the upstream failed,\na retry is always allowed. If unspecified, only GET requests will be\nallowed to be retried. Note that a retry is done with the next available\nhost according to the load balancing policy.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nA list of matcher sets that restricts with which requests retries are\nallowed. A request must match any of the given matcher sets in order\nto be retried if the connection to the upstream succeeded but the\nsubsequent round-trip failed. If the connection to the upstream failed,\na retry is always allowed. If unspecified, only GET requests will be\nallowed to be retried. Note that a retry is done with the next available\nhost according to the load balancing policy.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "properties": { + "expression": { + "$ref": "#/definitions/http.matchers.expression" + }, + "file": { + "$ref": "#/definitions/http.matchers.file" + }, + "header": { + "$ref": "#/definitions/http.matchers.header" + }, + "header_regexp": { + "$ref": "#/definitions/http.matchers.header_regexp" + }, + "host": { + "$ref": "#/definitions/http.matchers.host" + }, + "method": { + "$ref": "#/definitions/http.matchers.method" + }, + "not": { + "$ref": "#/definitions/http.matchers.not" + }, + "path": { + "$ref": "#/definitions/http.matchers.path" + }, + "path_regexp": { + "$ref": "#/definitions/http.matchers.path_regexp" + }, + "protocol": { + "$ref": "#/definitions/http.matchers.protocol" + }, + "query": { + "$ref": "#/definitions/http.matchers.query" + }, + "remote_ip": { + "$ref": "#/definitions/http.matchers.remote_ip" + }, + "vars": { + "$ref": "#/definitions/http.matchers.vars" + }, + "vars_regexp": { + "$ref": "#/definitions/http.matchers.vars_regexp" + } + } + } + }, + "selection_policy": { + "description": "selection_policy: object\nModule: http.reverse_proxy.selection_policies\nA selection policy is how to choose an available backend.\nThe default policy is random selection.\n", + "markdownDescription": "selection_policy: `object` \nModule: `http.reverse_proxy.selection_policies` \nA selection policy is how to choose an available backend.\nThe default policy is random selection. \n", + "type": "object", + "required": [ + "policy" + ], + "allOf": [ + { + "if": { + "properties": { + "policy": { + "const": "first" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.selection_policies.first" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "ip_hash" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.selection_policies.ip_hash" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "uri_hash" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.selection_policies.uri_hash" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "cookie" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.selection_policies.cookie" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "header" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.selection_policies.header" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "least_conn" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.selection_policies.least_conn" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "random" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.selection_policies.random" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "random_choose" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.selection_policies.random_choose" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "round_robin" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.selection_policies.round_robin" + } + }, + { + "properties": { + "policy": { + "description": "key to identify selection_policy module.\npolicy: string\nModule: http.reverse_proxy.selection_policies", + "markdownDescription": "key to identify `selection_policy` module. \npolicy: `string` \nModule: `http.reverse_proxy.selection_policies`", + "type": "string", + "enum": [ + "first", + "ip_hash", + "uri_hash", + "cookie", + "header", + "least_conn", + "random", + "random_choose", + "round_robin" + ] + } + } + } + ] + }, + "try_duration": { + "description": "try_duration: number\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to try selecting available backends for each request\nif the next available host is down. By default, this retry is\ndisabled. Clients will wait for up to this long while the load\nbalancer tries to find an available upstream host.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "try_duration: `number` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to try selecting available backends for each request\nif the next available host is down. By default, this retry is\ndisabled. Clients will wait for up to this long while the load\nbalancer tries to find an available upstream host.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "try_interval": { + "description": "try_interval: number\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to wait between selecting the next host from the pool. Default\nis 250ms. Only relevant when a request to an upstream host fails. Be\naware that setting this to 0 with a non-zero try_duration can cause the\nCPU to spin if all backends are down and latency is very low.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "try_interval: `number` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to wait between selecting the next host from the pool. Default\nis 250ms. Only relevant when a request to an upstream host fails. Be\naware that setting this to 0 with a non-zero try_duration can cause the\nCPU to spin if all backends are down and latency is very low.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + }, + "max_buffer_size": { + "description": "max_buffer_size: number\nModule: http.handlers.reverse_proxy\nIf body buffering is enabled, the maximum size of the buffers\nused for the requests and responses (in bytes).\n", + "markdownDescription": "max_buffer_size: `number` \nModule: `http.handlers.reverse_proxy` \nIf body buffering is enabled, the maximum size of the buffers\nused for the requests and responses (in bytes). \n", + "type": "number" + }, + "rewrite": { + "description": "rewrite: object\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#Rewrite\nIf configured, rewrites the copy of the upstream request.\nAllows changing the request method and URI (path and query).\nSince the rewrite is applied to the copy, it does not persist\npast the reverse proxy handler.\nIf the method is changed to `GET` or `HEAD`, the request body\nwill not be copied to the backend. This allows a later request\nhandler -- either in a `handle_response` route, or after -- to\nread the body.\nBy default, no rewrite is performed, and the method and URI\nfrom the incoming request is used as-is for proxying.\n\n\nRewrite is a middleware which can rewrite HTTP requests.\n\nThe Method and URI properties are \"setters\": the request URI\nwill be set to the given values. Other properties are \"modifiers\":\nthey modify existing files but do not explicitly specify what the\nresult will be. It is atypical to combine the use of setters and\nmodifiers in a single rewrite.\n", + "markdownDescription": "rewrite: `object` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#Rewrite) \nIf configured, rewrites the copy of the upstream request.\nAllows changing the request method and URI (path and query).\nSince the rewrite is applied to the copy, it does not persist\npast the reverse proxy handler.\nIf the method is changed to `GET` or `HEAD`, the request body\nwill not be copied to the backend. This allows a later request\nhandler -- either in a `handle_response` route, or after -- to\nread the body.\nBy default, no rewrite is performed, and the method and URI\nfrom the incoming request is used as-is for proxying.\n\n\nRewrite is a middleware which can rewrite HTTP requests.\n\nThe Method and URI properties are \"setters\": the request URI\nwill be set to the given values. Other properties are \"modifiers\":\nthey modify existing files but do not explicitly specify what the\nresult will be. It is atypical to combine the use of setters and\nmodifiers in a single rewrite. \n", + "type": "object", + "properties": { + "method": { + "description": "method: string\nModule: http.handlers.reverse_proxy\nChanges the request's HTTP verb.\n", + "markdownDescription": "method: `string` \nModule: `http.handlers.reverse_proxy` \nChanges the request's HTTP verb. \n", + "type": "string" + }, + "path_regexp": { + "description": "path_regexp: array\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#regexReplacer\nPerforms regular expression replacements on the URI path.\n\n\nregexReplacer describes a replacement using a regular expression.\n", + "markdownDescription": "path_regexp: `array` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#regexReplacer) \nPerforms regular expression replacements on the URI path.\n\n\nregexReplacer describes a replacement using a regular expression. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#regexReplacer\nPerforms regular expression replacements on the URI path.\n\n\nregexReplacer describes a replacement using a regular expression.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#regexReplacer) \nPerforms regular expression replacements on the URI path.\n\n\nregexReplacer describes a replacement using a regular expression. \n", + "type": "object", + "properties": { + "find": { + "description": "find: string\nModule: http.handlers.reverse_proxy\nThe regular expression to find.\n", + "markdownDescription": "find: `string` \nModule: `http.handlers.reverse_proxy` \nThe regular expression to find. \n", + "type": "string" + }, + "replace": { + "description": "replace: string\nModule: http.handlers.reverse_proxy\nThe substring to replace with. Supports placeholders and\nregular expression capture groups.\n", + "markdownDescription": "replace: `string` \nModule: `http.handlers.reverse_proxy` \nThe substring to replace with. Supports placeholders and\nregular expression capture groups. \n", + "type": "string" + } + } + } + }, + "strip_path_prefix": { + "description": "strip_path_prefix: string\nModule: http.handlers.reverse_proxy\nStrips the given prefix from the beginning of the URI path.\n", + "markdownDescription": "strip_path_prefix: `string` \nModule: `http.handlers.reverse_proxy` \nStrips the given prefix from the beginning of the URI path. \n", + "type": "string" + }, + "strip_path_suffix": { + "description": "strip_path_suffix: string\nModule: http.handlers.reverse_proxy\nStrips the given suffix from the end of the URI path.\n", + "markdownDescription": "strip_path_suffix: `string` \nModule: `http.handlers.reverse_proxy` \nStrips the given suffix from the end of the URI path. \n", + "type": "string" + }, + "uri": { + "description": "uri: string\nModule: http.handlers.reverse_proxy\nChanges the request's URI, which consists of path and query string.\nOnly components of the URI that are specified will be changed.\nFor example, a value of \"/foo.html\" or \"foo.html\" will only change\nthe path and will preserve any existing query string. Similarly, a\nvalue of \"?a=b\" will only change the query string and will not affect\nthe path. Both can also be changed: \"/foo?a=b\" - this sets both the\npath and query string at the same time.\n\nYou can also use placeholders. For example, to preserve the existing\nquery string, you might use: \"?{http.request.uri.query}\u0026a=b\". Any\nkey-value pairs you add to the query string will not overwrite\nexisting values (individual pairs are append-only).\n\nTo clear the query string, explicitly set an empty one: \"?\"\n", + "markdownDescription": "uri: `string` \nModule: `http.handlers.reverse_proxy` \nChanges the request's URI, which consists of path and query string.\nOnly components of the URI that are specified will be changed.\nFor example, a value of \"/foo.html\" or \"foo.html\" will only change\nthe path and will preserve any existing query string. Similarly, a\nvalue of \"?a=b\" will only change the query string and will not affect\nthe path. Both can also be changed: \"/foo?a=b\" - this sets both the\npath and query string at the same time.\n\nYou can also use placeholders. For example, to preserve the existing\nquery string, you might use: \"?{http.request.uri.query}\u0026a=b\". Any\nkey-value pairs you add to the query string will not overwrite\nexisting values (individual pairs are append-only).\n\nTo clear the query string, explicitly set an empty one: \"?\" \n", + "type": "string" + }, + "uri_substring": { + "description": "uri_substring: array\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#substrReplacer\nPerforms substring replacements on the URI.\n\n\nsubstrReplacer describes either a simple and fast substring replacement.\n", + "markdownDescription": "uri_substring: `array` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#substrReplacer) \nPerforms substring replacements on the URI.\n\n\nsubstrReplacer describes either a simple and fast substring replacement. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#substrReplacer\nPerforms substring replacements on the URI.\n\n\nsubstrReplacer describes either a simple and fast substring replacement.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#substrReplacer) \nPerforms substring replacements on the URI.\n\n\nsubstrReplacer describes either a simple and fast substring replacement. \n", + "type": "object", + "properties": { + "find": { + "description": "find: string\nModule: http.handlers.reverse_proxy\nA substring to find. Supports placeholders.\n", + "markdownDescription": "find: `string` \nModule: `http.handlers.reverse_proxy` \nA substring to find. Supports placeholders. \n", + "type": "string" + }, + "limit": { + "description": "limit: number\nModule: http.handlers.reverse_proxy\nMaximum number of replacements per string.\nSet to \u003c= 0 for no limit (default).\n", + "markdownDescription": "limit: `number` \nModule: `http.handlers.reverse_proxy` \nMaximum number of replacements per string.\nSet to \u003c= 0 for no limit (default). \n", + "type": "number" + }, + "replace": { + "description": "replace: string\nModule: http.handlers.reverse_proxy\nThe substring to replace with. Supports placeholders.\n", + "markdownDescription": "replace: `string` \nModule: `http.handlers.reverse_proxy` \nThe substring to replace with. Supports placeholders. \n", + "type": "string" + } + } + } + } + } + }, + "transport": { + "description": "transport: object\nModule: http.reverse_proxy.transport\nConfigures the method of transport for the proxy. A transport\nis what performs the actual \"round trip\" to the backend.\nThe default transport is plaintext HTTP.\n", + "markdownDescription": "transport: `object` \nModule: `http.reverse_proxy.transport` \nConfigures the method of transport for the proxy. A transport\nis what performs the actual \"round trip\" to the backend.\nThe default transport is plaintext HTTP. \n", + "type": "object", + "required": [ + "protocol" + ], + "allOf": [ + { + "if": { + "properties": { + "protocol": { + "const": "fastcgi" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.transport.fastcgi" + } + }, + { + "if": { + "properties": { + "protocol": { + "const": "http" + } + } + }, + "then": { + "$ref": "#/definitions/http.reverse_proxy.transport.http" + } + }, + { + "properties": { + "protocol": { + "description": "key to identify transport module.\nprotocol: string\nModule: http.reverse_proxy.transport", + "markdownDescription": "key to identify `transport` module. \nprotocol: `string` \nModule: `http.reverse_proxy.transport`", + "type": "string", + "enum": [ + "fastcgi", + "http" + ] + } + } + } + ] + }, + "trusted_proxies": { + "description": "trusted_proxies: array\nModule: http.handlers.reverse_proxy\nA list of IP ranges (supports CIDR notation) from which\nX-Forwarded-* header values should be trusted. By default,\nno proxies are trusted, so existing values will be ignored\nwhen setting these headers. If the proxy is trusted, then\nexisting values will be used when constructing the final\nheader values.\n", + "markdownDescription": "trusted_proxies: `array` \nModule: `http.handlers.reverse_proxy` \nA list of IP ranges (supports CIDR notation) from which\nX-Forwarded-* header values should be trusted. By default,\nno proxies are trusted, so existing values will be ignored\nwhen setting these headers. If the proxy is trusted, then\nexisting values will be used when constructing the final\nheader values. \n", + "type": "array", + "items": { + "description": "A list of IP ranges (supports CIDR notation) from which\nX-Forwarded-* header values should be trusted. By default,\nno proxies are trusted, so existing values will be ignored\nwhen setting these headers. If the proxy is trusted, then\nexisting values will be used when constructing the final\nheader values.\n", + "markdownDescription": "A list of IP ranges (supports CIDR notation) from which\nX-Forwarded-* header values should be trusted. By default,\nno proxies are trusted, so existing values will be ignored\nwhen setting these headers. If the proxy is trusted, then\nexisting values will be used when constructing the final\nheader values. \n", + "type": "string" + } + }, + "upstreams": { + "description": "upstreams: array\nModule: http.handlers.reverse_proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#Upstream\nUpstreams is the static list of backends to proxy to.\n\n\nUpstream bridges this proxy's configuration to the\nstate of the backend host it is correlated with.\nUpstream values must not be copied.\n", + "markdownDescription": "upstreams: `array` \nModule: `http.handlers.reverse_proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#Upstream) \nUpstreams is the static list of backends to proxy to.\n\n\nUpstream bridges this proxy's configuration to the\nstate of the backend host it is correlated with.\nUpstream values must not be copied. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#Upstream\nUpstreams is the static list of backends to proxy to.\n\n\nUpstream bridges this proxy's configuration to the\nstate of the backend host it is correlated with.\nUpstream values must not be copied.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#Upstream) \nUpstreams is the static list of backends to proxy to.\n\n\nUpstream bridges this proxy's configuration to the\nstate of the backend host it is correlated with.\nUpstream values must not be copied. \n", + "type": "object", + "properties": { + "dial": { + "description": "dial: string\nModule: http.handlers.reverse_proxy\nThe [network address](/docs/conventions#network-addresses)\nto dial to connect to the upstream. Must represent precisely\none socket (i.e. no port ranges). A valid network address\neither has a host and port or is a unix socket address.\n\nPlaceholders may be used to make the upstream dynamic, but be\naware of the health check implications of this: a single\nupstream that represents numerous (perhaps arbitrary) backends\ncan be considered down if one or enough of the arbitrary\nbackends is down. Also be aware of open proxy vulnerabilities.\n", + "markdownDescription": "dial: `string` \nModule: `http.handlers.reverse_proxy` \nThe [network address](/docs/conventions#network-addresses)\nto dial to connect to the upstream. Must represent precisely\none socket (i.e. no port ranges). A valid network address\neither has a host and port or is a unix socket address.\n\nPlaceholders may be used to make the upstream dynamic, but be\naware of the health check implications of this: a single\nupstream that represents numerous (perhaps arbitrary) backends\ncan be considered down if one or enough of the arbitrary\nbackends is down. Also be aware of open proxy vulnerabilities. \n", + "type": "string" + }, + "lookup_srv": { + "description": "lookup_srv: string\nModule: http.handlers.reverse_proxy\nDEPRECATED: Use the SRVUpstreams module instead\n(http.reverse_proxy.upstreams.srv). This field will be\nremoved in a future version of Caddy. TODO: Remove this field.\n\nIf DNS SRV records are used for service discovery with this\nupstream, specify the DNS name for which to look up SRV\nrecords here, instead of specifying a dial address.\n", + "markdownDescription": "lookup_srv: `string` \nModule: `http.handlers.reverse_proxy` \nDEPRECATED: Use the SRVUpstreams module instead\n(http.reverse_proxy.upstreams.srv). This field will be\nremoved in a future version of Caddy. TODO: Remove this field.\n\nIf DNS SRV records are used for service discovery with this\nupstream, specify the DNS name for which to look up SRV\nrecords here, instead of specifying a dial address. \n", + "type": "string" + }, + "max_requests": { + "description": "max_requests: number\nModule: http.handlers.reverse_proxy\nThe maximum number of simultaneous requests to allow to\nthis upstream. If set, overrides the global passive health\ncheck UnhealthyRequestCount value.\n", + "markdownDescription": "max_requests: `number` \nModule: `http.handlers.reverse_proxy` \nThe maximum number of simultaneous requests to allow to\nthis upstream. If set, overrides the global passive health\ncheck UnhealthyRequestCount value. \n", + "type": "number" + } + } + } + } + } + }, + "http.handlers.rewrite": { + "description": "rewrite: object\nModule: http.handlers.rewrite\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#Rewrite\nRewrite is a middleware which can rewrite HTTP requests.\n\nThe Method and URI properties are \"setters\": the request URI\nwill be set to the given values. Other properties are \"modifiers\":\nthey modify existing files but do not explicitly specify what the\nresult will be. It is atypical to combine the use of setters and\nmodifiers in a single rewrite.\n\n", + "markdownDescription": "rewrite: `object` \nModule: `http.handlers.rewrite` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#Rewrite) \nRewrite is a middleware which can rewrite HTTP requests.\n\nThe Method and URI properties are \"setters\": the request URI\nwill be set to the given values. Other properties are \"modifiers\":\nthey modify existing files but do not explicitly specify what the\nresult will be. It is atypical to combine the use of setters and\nmodifiers in a single rewrite.\n \n", + "type": "object", + "properties": { + "method": { + "description": "method: string\nModule: http.handlers.rewrite\nChanges the request's HTTP verb.\n", + "markdownDescription": "method: `string` \nModule: `http.handlers.rewrite` \nChanges the request's HTTP verb. \n", + "type": "string" + }, + "path_regexp": { + "description": "path_regexp: array\nModule: http.handlers.rewrite\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#regexReplacer\nPerforms regular expression replacements on the URI path.\n\n\nregexReplacer describes a replacement using a regular expression.\n", + "markdownDescription": "path_regexp: `array` \nModule: `http.handlers.rewrite` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#regexReplacer) \nPerforms regular expression replacements on the URI path.\n\n\nregexReplacer describes a replacement using a regular expression. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#regexReplacer\nPerforms regular expression replacements on the URI path.\n\n\nregexReplacer describes a replacement using a regular expression.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#regexReplacer) \nPerforms regular expression replacements on the URI path.\n\n\nregexReplacer describes a replacement using a regular expression. \n", + "type": "object", + "properties": { + "find": { + "description": "find: string\nModule: http.handlers.rewrite\nThe regular expression to find.\n", + "markdownDescription": "find: `string` \nModule: `http.handlers.rewrite` \nThe regular expression to find. \n", + "type": "string" + }, + "replace": { + "description": "replace: string\nModule: http.handlers.rewrite\nThe substring to replace with. Supports placeholders and\nregular expression capture groups.\n", + "markdownDescription": "replace: `string` \nModule: `http.handlers.rewrite` \nThe substring to replace with. Supports placeholders and\nregular expression capture groups. \n", + "type": "string" + } + } + } + }, + "strip_path_prefix": { + "description": "strip_path_prefix: string\nModule: http.handlers.rewrite\nStrips the given prefix from the beginning of the URI path.\n", + "markdownDescription": "strip_path_prefix: `string` \nModule: `http.handlers.rewrite` \nStrips the given prefix from the beginning of the URI path. \n", + "type": "string" + }, + "strip_path_suffix": { + "description": "strip_path_suffix: string\nModule: http.handlers.rewrite\nStrips the given suffix from the end of the URI path.\n", + "markdownDescription": "strip_path_suffix: `string` \nModule: `http.handlers.rewrite` \nStrips the given suffix from the end of the URI path. \n", + "type": "string" + }, + "uri": { + "description": "uri: string\nModule: http.handlers.rewrite\nChanges the request's URI, which consists of path and query string.\nOnly components of the URI that are specified will be changed.\nFor example, a value of \"/foo.html\" or \"foo.html\" will only change\nthe path and will preserve any existing query string. Similarly, a\nvalue of \"?a=b\" will only change the query string and will not affect\nthe path. Both can also be changed: \"/foo?a=b\" - this sets both the\npath and query string at the same time.\n\nYou can also use placeholders. For example, to preserve the existing\nquery string, you might use: \"?{http.request.uri.query}\u0026a=b\". Any\nkey-value pairs you add to the query string will not overwrite\nexisting values (individual pairs are append-only).\n\nTo clear the query string, explicitly set an empty one: \"?\"\n", + "markdownDescription": "uri: `string` \nModule: `http.handlers.rewrite` \nChanges the request's URI, which consists of path and query string.\nOnly components of the URI that are specified will be changed.\nFor example, a value of \"/foo.html\" or \"foo.html\" will only change\nthe path and will preserve any existing query string. Similarly, a\nvalue of \"?a=b\" will only change the query string and will not affect\nthe path. Both can also be changed: \"/foo?a=b\" - this sets both the\npath and query string at the same time.\n\nYou can also use placeholders. For example, to preserve the existing\nquery string, you might use: \"?{http.request.uri.query}\u0026a=b\". Any\nkey-value pairs you add to the query string will not overwrite\nexisting values (individual pairs are append-only).\n\nTo clear the query string, explicitly set an empty one: \"?\" \n", + "type": "string" + }, + "uri_substring": { + "description": "uri_substring: array\nModule: http.handlers.rewrite\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#substrReplacer\nPerforms substring replacements on the URI.\n\n\nsubstrReplacer describes either a simple and fast substring replacement.\n", + "markdownDescription": "uri_substring: `array` \nModule: `http.handlers.rewrite` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#substrReplacer) \nPerforms substring replacements on the URI.\n\n\nsubstrReplacer describes either a simple and fast substring replacement. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#substrReplacer\nPerforms substring replacements on the URI.\n\n\nsubstrReplacer describes either a simple and fast substring replacement.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite#substrReplacer) \nPerforms substring replacements on the URI.\n\n\nsubstrReplacer describes either a simple and fast substring replacement. \n", + "type": "object", + "properties": { + "find": { + "description": "find: string\nModule: http.handlers.rewrite\nA substring to find. Supports placeholders.\n", + "markdownDescription": "find: `string` \nModule: `http.handlers.rewrite` \nA substring to find. Supports placeholders. \n", + "type": "string" + }, + "limit": { + "description": "limit: number\nModule: http.handlers.rewrite\nMaximum number of replacements per string.\nSet to \u003c= 0 for no limit (default).\n", + "markdownDescription": "limit: `number` \nModule: `http.handlers.rewrite` \nMaximum number of replacements per string.\nSet to \u003c= 0 for no limit (default). \n", + "type": "number" + }, + "replace": { + "description": "replace: string\nModule: http.handlers.rewrite\nThe substring to replace with. Supports placeholders.\n", + "markdownDescription": "replace: `string` \nModule: `http.handlers.rewrite` \nThe substring to replace with. Supports placeholders. \n", + "type": "string" + } + } + } + } + } + }, + "http.handlers.static_response": { + "description": "static_response: object\nModule: http.handlers.static_response\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#StaticResponse\nStaticResponse implements a simple responder for static responses.\n\n", + "markdownDescription": "static_response: `object` \nModule: `http.handlers.static_response` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#StaticResponse) \nStaticResponse implements a simple responder for static responses.\n \n", + "type": "object", + "properties": { + "abort": { + "description": "abort: boolean\nModule: http.handlers.static_response\nImmediately and forcefully closes the connection without\nwriting a response. Interrupts any other HTTP streams on\nthe same connection.\n", + "markdownDescription": "abort: `boolean` \nModule: `http.handlers.static_response` \nImmediately and forcefully closes the connection without\nwriting a response. Interrupts any other HTTP streams on\nthe same connection. \n", + "type": "boolean" + }, + "body": { + "description": "body: string\nModule: http.handlers.static_response\nThe response body.\n", + "markdownDescription": "body: `string` \nModule: `http.handlers.static_response` \nThe response body. \n", + "type": "string" + }, + "close": { + "description": "close: boolean\nModule: http.handlers.static_response\nIf true, the server will close the client's connection\nafter writing the response.\n", + "markdownDescription": "close: `boolean` \nModule: `http.handlers.static_response` \nIf true, the server will close the client's connection\nafter writing the response. \n", + "type": "boolean" + }, + "headers": { + "description": "headers: object\nModule: http.handlers.static_response\nHeader fields to set on the response.\n", + "markdownDescription": "headers: `object` \nModule: `http.handlers.static_response` \nHeader fields to set on the response. \n", + "type": "object", + "additionalProperties": { + "description": "Header fields to set on the response.\n", + "markdownDescription": "Header fields to set on the response. \n", + "type": "array", + "items": { + "type": "string" + } + } + }, + "status_code": { + "description": "status_code: string\nModule: http.handlers.static_response\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString\nThe HTTP status code to respond with. Can be an integer or,\nif needing to use a placeholder, a string.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned.\n", + "markdownDescription": "status_code: `string` \nModule: `http.handlers.static_response` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#WeakString) \nThe HTTP status code to respond with. Can be an integer or,\nif needing to use a placeholder, a string.\n\n\nWeakString is a type that unmarshals any JSON value\nas a string literal, with the following exceptions:\n\n1. actual string values are decoded as strings; and\n2. null is decoded as empty string;\n\nand provides methods for getting the value as various\nprimitive types. However, using this type removes any\ntype safety as far as deserializing JSON is concerned. \n", + "type": "string" + } + } + }, + "http.handlers.subroute": { + "description": "subroute: object\nModule: http.handlers.subroute\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Subroute\nSubroute implements a handler that compiles and executes routes.\nThis is useful for a batch of routes that all inherit the same\nmatchers, or for multiple routes that should be treated as a\nsingle route.\n\nYou can also use subroutes to handle errors from its handlers.\nFirst the primary routes will be executed, and if they return an\nerror, the errors routes will be executed; in that case, an error\nis only returned to the entry point at the server if there is an\nadditional error returned from the errors routes.\n\n", + "markdownDescription": "subroute: `object` \nModule: `http.handlers.subroute` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Subroute) \nSubroute implements a handler that compiles and executes routes.\nThis is useful for a batch of routes that all inherit the same\nmatchers, or for multiple routes that should be treated as a\nsingle route.\n\nYou can also use subroutes to handle errors from its handlers.\nFirst the primary routes will be executed, and if they return an\nerror, the errors routes will be executed; in that case, an error\nis only returned to the entry point at the server if there is an\nadditional error returned from the errors routes.\n \n", + "type": "object", + "properties": { + "errors": { + "description": "errors: object\nModule: http.handlers.subroute\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#HTTPErrorConfig\nIf the primary routes return an error, error handling\ncan be promoted to this configuration instead.\n\n\nHTTPErrorConfig determines how to handle errors\nfrom the HTTP handlers.\n", + "markdownDescription": "errors: `object` \nModule: `http.handlers.subroute` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#HTTPErrorConfig) \nIf the primary routes return an error, error handling\ncan be promoted to this configuration instead.\n\n\nHTTPErrorConfig determines how to handle errors\nfrom the HTTP handlers. \n", + "type": "object", + "properties": { + "routes": { + "description": "routes: array\nModule: http.handlers.subroute\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nThe routes to evaluate after the primary handler\nchain returns an error. In an error route, extra\nplaceholders are available:\n\nPlaceholder | Description\n------------|---------------\n`{http.error.status_code}` | The recommended HTTP status code\n`{http.error.status_text}` | The status text associated with the recommended status code\n`{http.error.message}` | The error message\n`{http.error.trace}` | The origin of the error\n`{http.error.id}` | An identifier for this occurrence of the error\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "routes: `array` \nModule: `http.handlers.subroute` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nThe routes to evaluate after the primary handler\nchain returns an error. In an error route, extra\nplaceholders are available:\n\nPlaceholder | Description\n------------|---------------\n`{http.error.status_code}` | The recommended HTTP status code\n`{http.error.status_text}` | The status text associated with the recommended status code\n`{http.error.message}` | The error message\n`{http.error.trace}` | The origin of the error\n`{http.error.id}` | An identifier for this occurrence of the error\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nThe routes to evaluate after the primary handler\nchain returns an error. In an error route, extra\nplaceholders are available:\n\nPlaceholder | Description\n------------|---------------\n`{http.error.status_code}` | The recommended HTTP status code\n`{http.error.status_text}` | The status text associated with the recommended status code\n`{http.error.message}` | The error message\n`{http.error.trace}` | The origin of the error\n`{http.error.id}` | An identifier for this occurrence of the error\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nThe routes to evaluate after the primary handler\nchain returns an error. In an error route, extra\nplaceholders are available:\n\nPlaceholder | Description\n------------|---------------\n`{http.error.status_code}` | The recommended HTTP status code\n`{http.error.status_text}` | The status text associated with the recommended status code\n`{http.error.message}` | The error message\n`{http.error.trace}` | The origin of the error\n`{http.error.id}` | An identifier for this occurrence of the error\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "object", + "properties": { + "group": { + "description": "group: string\nModule: http.handlers.subroute\nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed.\n", + "markdownDescription": "group: `string` \nModule: `http.handlers.subroute` \nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed. \n", + "type": "string" + }, + "handle": { + "description": "handle: array\nModule: http.handlers\nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "handle: `array` \nModule: `http.handlers` \nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "type": "array", + "items": { + "description": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "required": [ + "handler" + ], + "allOf": [ + { + "if": { + "properties": { + "handler": { + "const": "authentication" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.authentication" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "static_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.static_response" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "file_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.file_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "map" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.map" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "reverse_proxy" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.reverse_proxy" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "templates" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.templates" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "acme_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.acme_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response_headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response_headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "error" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.error" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "push" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.push" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "vars" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.vars" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "rewrite" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.rewrite" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "subroute" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.subroute" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tracing" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.tracing" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "encode" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.encode" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "metrics" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.metrics" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "request_body" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.request_body" + } + }, + { + "properties": { + "handler": { + "description": "key to identify handle module.\nhandler: string\nModule: http.handlers", + "markdownDescription": "key to identify `handle` module. \nhandler: `string` \nModule: `http.handlers`", + "type": "string", + "enum": [ + "authentication", + "static_response", + "file_server", + "map", + "reverse_proxy", + "templates", + "acme_server", + "copy_response", + "copy_response_headers", + "error", + "push", + "vars", + "rewrite", + "subroute", + "tracing", + "encode", + "headers", + "metrics", + "request_body" + ] + } + } + } + ] + } + }, + "match": { + "description": "match: array\nModule: http.matchers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "match: `array` \nModule: `http.matchers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "properties": { + "expression": { + "$ref": "#/definitions/http.matchers.expression" + }, + "file": { + "$ref": "#/definitions/http.matchers.file" + }, + "header": { + "$ref": "#/definitions/http.matchers.header" + }, + "header_regexp": { + "$ref": "#/definitions/http.matchers.header_regexp" + }, + "host": { + "$ref": "#/definitions/http.matchers.host" + }, + "method": { + "$ref": "#/definitions/http.matchers.method" + }, + "not": { + "$ref": "#/definitions/http.matchers.not" + }, + "path": { + "$ref": "#/definitions/http.matchers.path" + }, + "path_regexp": { + "$ref": "#/definitions/http.matchers.path_regexp" + }, + "protocol": { + "$ref": "#/definitions/http.matchers.protocol" + }, + "query": { + "$ref": "#/definitions/http.matchers.query" + }, + "remote_ip": { + "$ref": "#/definitions/http.matchers.remote_ip" + }, + "vars": { + "$ref": "#/definitions/http.matchers.vars" + }, + "vars_regexp": { + "$ref": "#/definitions/http.matchers.vars_regexp" + } + } + } + }, + "terminal": { + "description": "terminal: boolean\nModule: http.handlers.subroute\nIf true, no more routes will be executed after this one.\n", + "markdownDescription": "terminal: `boolean` \nModule: `http.handlers.subroute` \nIf true, no more routes will be executed after this one. \n", + "type": "boolean" + } + } + } + } + } + }, + "routes": { + "description": "routes: array\nModule: http.handlers.subroute\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nThe primary list of routes to compile and execute.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "routes: `array` \nModule: `http.handlers.subroute` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nThe primary list of routes to compile and execute.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route\nThe primary list of routes to compile and execute.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#Route) \nThe primary list of routes to compile and execute.\n\n\nRoute consists of a set of rules for matching HTTP requests,\na list of handlers to execute, and optional flow control\nparameters which customize the handling of HTTP requests\nin a highly flexible and performant manner. \n", + "type": "object", + "properties": { + "group": { + "description": "group: string\nModule: http.handlers.subroute\nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed.\n", + "markdownDescription": "group: `string` \nModule: `http.handlers.subroute` \nGroup is an optional name for a group to which this\nroute belongs. Grouping a route makes it mutually\nexclusive with others in its group; if a route belongs\nto a group, only the first matching route in that group\nwill be executed. \n", + "type": "string" + }, + "handle": { + "description": "handle: array\nModule: http.handlers\nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "handle: `array` \nModule: `http.handlers` \nThe list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "type": "array", + "items": { + "description": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes.\n", + "markdownDescription": "The list of handlers for this route. Upon matching a request, they are chained\ntogether in a middleware fashion: requests flow from the first handler to the last\n(top of the list to the bottom), with the possibility that any handler could stop\nthe chain and/or return an error. Responses flow back through the chain (bottom of\nthe list to the top) as they are written out to the client.\n\nNot all handlers call the next handler in the chain. For example, the reverse_proxy\nhandler always sends a request upstream or returns an error. Thus, configuring\nhandlers after reverse_proxy in the same route is illogical, since they would never\nbe executed. You will want to put handlers which originate the response at the very\nend of your route(s). The documentation for a module should state whether it invokes\nthe next handler, but sometimes it is common sense.\n\nSome handlers manipulate the response. Remember that requests flow down the list, and\nresponses flow up the list.\n\nFor example, if you wanted to use both `templates` and `encode` handlers, you would\nneed to put `templates` after `encode` in your route, because responses flow up.\nThus, `templates` will be able to parse and execute the plain-text response as a\ntemplate, and then return it up to the `encode` handler which will then compress it\ninto a binary format.\n\nIf `templates` came before `encode`, then `encode` would write a compressed,\nbinary-encoded response to `templates` which would not be able to parse the response\nproperly.\n\nThe correct order, then, is this:\n\n [\n {\"handler\": \"encode\"},\n {\"handler\": \"templates\"},\n {\"handler\": \"file_server\"}\n ]\n\nThe request flows ⬇️ DOWN (`encode` -\u003e `templates` -\u003e `file_server`).\n\n1. First, `encode` will choose how to `encode` the response and wrap the response.\n2. Then, `templates` will wrap the response with a buffer.\n3. Finally, `file_server` will originate the content from a file.\n\nThe response flows ⬆️ UP (`file_server` -\u003e `templates` -\u003e `encode`):\n\n1. First, `file_server` will write the file to the response.\n2. That write will be buffered and then executed by `templates`.\n3. Lastly, the write from `templates` will flow into `encode` which will compress the stream.\n\nIf you think of routes in this way, it will be easy and even fun to solve the puzzle of writing correct routes. \n", + "required": [ + "handler" + ], + "allOf": [ + { + "if": { + "properties": { + "handler": { + "const": "reverse_proxy" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.reverse_proxy" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "templates" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.templates" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "acme_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.acme_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "copy_response_headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.copy_response_headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "error" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.error" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "file_server" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.file_server" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "map" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.map" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "push" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.push" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "vars" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.vars" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tracing" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.tracing" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "encode" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.encode" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "headers" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.headers" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "metrics" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.metrics" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "request_body" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.request_body" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "rewrite" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.rewrite" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "subroute" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.subroute" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "authentication" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.authentication" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "static_response" + } + } + }, + "then": { + "$ref": "#/definitions/http.handlers.static_response" + } + }, + { + "properties": { + "handler": { + "description": "key to identify handle module.\nhandler: string\nModule: http.handlers", + "markdownDescription": "key to identify `handle` module. \nhandler: `string` \nModule: `http.handlers`", + "type": "string", + "enum": [ + "reverse_proxy", + "templates", + "acme_server", + "copy_response", + "copy_response_headers", + "error", + "file_server", + "map", + "push", + "vars", + "tracing", + "encode", + "headers", + "metrics", + "request_body", + "rewrite", + "subroute", + "authentication", + "static_response" + ] + } + } + } + ] + } + }, + "match": { + "description": "match: array\nModule: http.matchers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "match: `array` \nModule: `http.matchers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nThe matcher sets which will be used to qualify this\nroute for a request (essentially the \"if\" statement\nof this route). Each matcher set is OR'ed, but matchers\nwithin a set are AND'ed together.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "properties": { + "expression": { + "$ref": "#/definitions/http.matchers.expression" + }, + "file": { + "$ref": "#/definitions/http.matchers.file" + }, + "header": { + "$ref": "#/definitions/http.matchers.header" + }, + "header_regexp": { + "$ref": "#/definitions/http.matchers.header_regexp" + }, + "host": { + "$ref": "#/definitions/http.matchers.host" + }, + "method": { + "$ref": "#/definitions/http.matchers.method" + }, + "not": { + "$ref": "#/definitions/http.matchers.not" + }, + "path": { + "$ref": "#/definitions/http.matchers.path" + }, + "path_regexp": { + "$ref": "#/definitions/http.matchers.path_regexp" + }, + "protocol": { + "$ref": "#/definitions/http.matchers.protocol" + }, + "query": { + "$ref": "#/definitions/http.matchers.query" + }, + "remote_ip": { + "$ref": "#/definitions/http.matchers.remote_ip" + }, + "vars": { + "$ref": "#/definitions/http.matchers.vars" + }, + "vars_regexp": { + "$ref": "#/definitions/http.matchers.vars_regexp" + } + } + } + }, + "terminal": { + "description": "terminal: boolean\nModule: http.handlers.subroute\nIf true, no more routes will be executed after this one.\n", + "markdownDescription": "terminal: `boolean` \nModule: `http.handlers.subroute` \nIf true, no more routes will be executed after this one. \n", + "type": "boolean" + } + } + } + } + } + }, + "http.handlers.templates": { + "description": "templates: object\nModule: http.handlers.templates\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/templates#Templates\nTemplates is a middleware which executes response bodies as Go templates.\nThe syntax is documented in the Go standard library's\n[text/template package](https://golang.org/pkg/text/template/).\n\n⚠️ Template functions/actions are still experimental, so they are subject to change.\n\nCustom template functions can be registered by creating a plugin module under the `http.handlers.templates.functions.*` namespace that implements the `CustomFunctions` interface.\n\n[All Sprig functions](https://masterminds.github.io/sprig/) are supported.\n\nIn addition to the standard functions and the Sprig library, Caddy adds\nextra functions and data that are available to a template:\n\n##### `.Args`\n\nA slice of arguments passed to this page/context, for example as the result of a `include`.\n\n```\n{{index .Args 0}} // first argument\n```\n\n##### `.Cookie`\n\nGets the value of a cookie by name.\n\n```\n{{.Cookie \"cookiename\"}}\n```\n\n##### `env`\n\nGets an environment variable.\n\n```\n{{env \"VAR_NAME\"}}\n```\n\n##### `placeholder`\n\nGets an [placeholder variable](/docs/conventions#placeholders).\nThe braces (`{}`) have to be omitted.\n\n```\n{{placeholder \"http.request.uri.path\"}}\n{{placeholder \"http.error.status_code\"}}\n```\n\n##### `.Host`\n\nReturns the hostname portion (no port) of the Host header of the HTTP request.\n\n```\n{{.Host}}\n```\n\n##### `httpInclude`\n\nIncludes the contents of another file by making a virtual HTTP request (also known as a sub-request). The URI path must exist on the same virtual server because the request does not use sockets; instead, the request is crafted in memory and the handler is invoked directly for increased efficiency.\n\n```\n{{httpInclude \"/foo/bar?q=val\"}}\n```\n\n##### `import`\n\nImports the contents of another file and adds any template definitions to the template stack. If there are no defitions, the filepath will be the defition name. Any {{ define }} blocks will be accessible by {{ template }} or {{ block }}. Imports must happen before the template or block action is called\n\n**filename.html**\n```\n{{ define \"main\" }}\ncontent\n{{ end }}\n```\n\n**index.html**\n```\n{{ import \"/path/to/file.html\" }}\n{{ template \"main\" }}\n```\n\n##### `include`\n\nIncludes the contents of another file and renders in-place. Optionally can pass key-value pairs as arguments to be accessed by the included file.\n\n```\n{{include \"path/to/file.html\"}} // no arguments\n{{include \"path/to/file.html\" \"arg1\" 2 \"value 3\"}} // with arguments\n```\n\n##### `listFiles`\n\nReturns a list of the files in the given directory, which is relative to the template context's file root.\n\n```\n{{listFiles \"/mydir\"}}\n```\n\n##### `markdown`\n\nRenders the given Markdown text as HTML. This uses the\n[Goldmark](https://github.com/yuin/goldmark) library,\nwhich is CommonMark compliant. It also has these plugins\nenabled: Github Flavored Markdown, Footnote and syntax\nhighlighting provided by [Chroma](https://github.com/alecthomas/chroma).\n\n```\n{{markdown \"My _markdown_ text\"}}\n```\n\n##### `.RemoteIP`\n\nReturns the client's IP address.\n\n```\n{{.RemoteIP}}\n```\n\n##### `.Req`\n\nAccesses the current HTTP request, which has various fields, including:\n\n - `.Method` - the method\n - `.URL` - the URL, which in turn has component fields (Scheme, Host, Path, etc.)\n - `.Header` - the header fields\n - `.Host` - the Host or :authority header of the request\n\n```\n{{.Req.Header.Get \"User-Agent\"}}\n```\n\n##### `.OriginalReq`\n\nLike .Req, except it accesses the original HTTP request before rewrites or other internal modifications.\n\n##### `.RespHeader.Add`\n\nAdds a header field to the HTTP response.\n\n```\n{{.RespHeader.Add \"Field-Name\" \"val\"}}\n```\n\n##### `.RespHeader.Del`\n\nDeletes a header field on the HTTP response.\n\n```\n{{.RespHeader.Del \"Field-Name\"}}\n```\n\n##### `.RespHeader.Set`\n\nSets a header field on the HTTP response, replacing any existing value.\n\n```\n{{.RespHeader.Set \"Field-Name\" \"val\"}}\n```\n\n##### `splitFrontMatter`\n\nSplits front matter out from the body. Front matter is metadata that appears at the very beginning of a file or string. Front matter can be in YAML, TOML, or JSON formats:\n\n**TOML** front matter starts and ends with `+++`:\n\n```\n+++\ntemplate = \"blog\"\ntitle = \"Blog Homepage\"\nsitename = \"A Caddy site\"\n+++\n```\n\n**YAML** is surrounded by `---`:\n\n```\n---\ntemplate: blog\ntitle: Blog Homepage\nsitename: A Caddy site\n---\n```\n\n**JSON** is simply `{` and `}`:\n\n```\n{\n\t\"template\": \"blog\",\n\t\"title\": \"Blog Homepage\",\n\t\"sitename\": \"A Caddy site\"\n}\n```\n\nThe resulting front matter will be made available like so:\n\n- `.Meta` to access the metadata fields, for example: `{{$parsed.Meta.title}}`\n- `.Body` to access the body after the front matter, for example: `{{markdown $parsed.Body}}`\n\n##### `stripHTML`\n\nRemoves HTML from a string.\n\n```\n{{stripHTML \"Shows \u003cb\u003eonly\u003c/b\u003e text content\"}}\n```\n\n", + "markdownDescription": "templates: `object` \nModule: `http.handlers.templates` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/templates#Templates) \nTemplates is a middleware which executes response bodies as Go templates.\nThe syntax is documented in the Go standard library's\n[text/template package](https://golang.org/pkg/text/template/).\n\n⚠️ Template functions/actions are still experimental, so they are subject to change.\n\nCustom template functions can be registered by creating a plugin module under the `http.handlers.templates.functions.*` namespace that implements the `CustomFunctions` interface.\n\n[All Sprig functions](https://masterminds.github.io/sprig/) are supported.\n\nIn addition to the standard functions and the Sprig library, Caddy adds\nextra functions and data that are available to a template:\n\n##### `.Args`\n\nA slice of arguments passed to this page/context, for example as the result of a `include`.\n\n```\n{{index .Args 0}} // first argument\n```\n\n##### `.Cookie`\n\nGets the value of a cookie by name.\n\n```\n{{.Cookie \"cookiename\"}}\n```\n\n##### `env`\n\nGets an environment variable.\n\n```\n{{env \"VAR_NAME\"}}\n```\n\n##### `placeholder`\n\nGets an [placeholder variable](/docs/conventions#placeholders).\nThe braces (`{}`) have to be omitted.\n\n```\n{{placeholder \"http.request.uri.path\"}}\n{{placeholder \"http.error.status_code\"}}\n```\n\n##### `.Host`\n\nReturns the hostname portion (no port) of the Host header of the HTTP request.\n\n```\n{{.Host}}\n```\n\n##### `httpInclude`\n\nIncludes the contents of another file by making a virtual HTTP request (also known as a sub-request). The URI path must exist on the same virtual server because the request does not use sockets; instead, the request is crafted in memory and the handler is invoked directly for increased efficiency.\n\n```\n{{httpInclude \"/foo/bar?q=val\"}}\n```\n\n##### `import`\n\nImports the contents of another file and adds any template definitions to the template stack. If there are no defitions, the filepath will be the defition name. Any {{ define }} blocks will be accessible by {{ template }} or {{ block }}. Imports must happen before the template or block action is called\n\n**filename.html**\n```\n{{ define \"main\" }}\ncontent\n{{ end }}\n```\n\n**index.html**\n```\n{{ import \"/path/to/file.html\" }}\n{{ template \"main\" }}\n```\n\n##### `include`\n\nIncludes the contents of another file and renders in-place. Optionally can pass key-value pairs as arguments to be accessed by the included file.\n\n```\n{{include \"path/to/file.html\"}} // no arguments\n{{include \"path/to/file.html\" \"arg1\" 2 \"value 3\"}} // with arguments\n```\n\n##### `listFiles`\n\nReturns a list of the files in the given directory, which is relative to the template context's file root.\n\n```\n{{listFiles \"/mydir\"}}\n```\n\n##### `markdown`\n\nRenders the given Markdown text as HTML. This uses the\n[Goldmark](https://github.com/yuin/goldmark) library,\nwhich is CommonMark compliant. It also has these plugins\nenabled: Github Flavored Markdown, Footnote and syntax\nhighlighting provided by [Chroma](https://github.com/alecthomas/chroma).\n\n```\n{{markdown \"My _markdown_ text\"}}\n```\n\n##### `.RemoteIP`\n\nReturns the client's IP address.\n\n```\n{{.RemoteIP}}\n```\n\n##### `.Req`\n\nAccesses the current HTTP request, which has various fields, including:\n\n - `.Method` - the method\n - `.URL` - the URL, which in turn has component fields (Scheme, Host, Path, etc.)\n - `.Header` - the header fields\n - `.Host` - the Host or :authority header of the request\n\n```\n{{.Req.Header.Get \"User-Agent\"}}\n```\n\n##### `.OriginalReq`\n\nLike .Req, except it accesses the original HTTP request before rewrites or other internal modifications.\n\n##### `.RespHeader.Add`\n\nAdds a header field to the HTTP response.\n\n```\n{{.RespHeader.Add \"Field-Name\" \"val\"}}\n```\n\n##### `.RespHeader.Del`\n\nDeletes a header field on the HTTP response.\n\n```\n{{.RespHeader.Del \"Field-Name\"}}\n```\n\n##### `.RespHeader.Set`\n\nSets a header field on the HTTP response, replacing any existing value.\n\n```\n{{.RespHeader.Set \"Field-Name\" \"val\"}}\n```\n\n##### `splitFrontMatter`\n\nSplits front matter out from the body. Front matter is metadata that appears at the very beginning of a file or string. Front matter can be in YAML, TOML, or JSON formats:\n\n**TOML** front matter starts and ends with `+++`:\n\n```\n+++\ntemplate = \"blog\"\ntitle = \"Blog Homepage\"\nsitename = \"A Caddy site\"\n+++\n```\n\n**YAML** is surrounded by `---`:\n\n```\n---\ntemplate: blog\ntitle: Blog Homepage\nsitename: A Caddy site\n---\n```\n\n**JSON** is simply `{` and `}`:\n\n```\n{\n\t\"template\": \"blog\",\n\t\"title\": \"Blog Homepage\",\n\t\"sitename\": \"A Caddy site\"\n}\n```\n\nThe resulting front matter will be made available like so:\n\n- `.Meta` to access the metadata fields, for example: `{{$parsed.Meta.title}}`\n- `.Body` to access the body after the front matter, for example: `{{markdown $parsed.Body}}`\n\n##### `stripHTML`\n\nRemoves HTML from a string.\n\n```\n{{stripHTML \"Shows \u003cb\u003eonly\u003c/b\u003e text content\"}}\n```\n \n", + "type": "object", + "properties": { + "delimiters": { + "description": "delimiters: array\nModule: http.handlers.templates\nThe template action delimiters. If set, must be precisely two elements:\nthe opening and closing delimiters. Default: `[\"{{\", \"}}\"]`\n", + "markdownDescription": "delimiters: `array` \nModule: `http.handlers.templates` \nThe template action delimiters. If set, must be precisely two elements:\nthe opening and closing delimiters. Default: `[\"{{\", \"}}\"]` \n", + "type": "array", + "items": { + "description": "The template action delimiters. If set, must be precisely two elements:\nthe opening and closing delimiters. Default: `[\"{{\", \"}}\"]`\n", + "markdownDescription": "The template action delimiters. If set, must be precisely two elements:\nthe opening and closing delimiters. Default: `[\"{{\", \"}}\"]` \n", + "type": "string" + } + }, + "file_root": { + "description": "file_root: string\nModule: http.handlers.templates\nThe root path from which to load files. Required if template functions\naccessing the file system are used (such as include). Default is\n`{http.vars.root}` if set, or current working directory otherwise.\n", + "markdownDescription": "file_root: `string` \nModule: `http.handlers.templates` \nThe root path from which to load files. Required if template functions\naccessing the file system are used (such as include). Default is\n`{http.vars.root}` if set, or current working directory otherwise. \n", + "type": "string" + }, + "mime_types": { + "description": "mime_types: array\nModule: http.handlers.templates\nThe MIME types for which to render templates. It is important to use\nthis if the route matchers do not exclude images or other binary files.\nDefault is text/plain, text/markdown, and text/html.\n", + "markdownDescription": "mime_types: `array` \nModule: `http.handlers.templates` \nThe MIME types for which to render templates. It is important to use\nthis if the route matchers do not exclude images or other binary files.\nDefault is text/plain, text/markdown, and text/html. \n", + "type": "array", + "items": { + "description": "The MIME types for which to render templates. It is important to use\nthis if the route matchers do not exclude images or other binary files.\nDefault is text/plain, text/markdown, and text/html.\n", + "markdownDescription": "The MIME types for which to render templates. It is important to use\nthis if the route matchers do not exclude images or other binary files.\nDefault is text/plain, text/markdown, and text/html. \n", + "type": "string" + } + } + } + }, + "http.handlers.tracing": { + "description": "tracing: object\nModule: http.handlers.tracing\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/tracing#Tracing\nTracing implements an HTTP handler that adds support for distributed tracing,\nusing OpenTelemetry. This module is responsible for the injection and\npropagation of the trace context. Configure this module via environment\nvariables (see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/sdk-environment-variables.md).\nSome values can be overwritten in the configuration file.\n\n", + "markdownDescription": "tracing: `object` \nModule: `http.handlers.tracing` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/tracing#Tracing) \nTracing implements an HTTP handler that adds support for distributed tracing,\nusing OpenTelemetry. This module is responsible for the injection and\npropagation of the trace context. Configure this module via environment\nvariables (see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/sdk-environment-variables.md).\nSome values can be overwritten in the configuration file.\n \n", + "type": "object", + "properties": { + "span": { + "description": "span: string\nModule: http.handlers.tracing\nSpanName is a span name. It should follow the naming guidelines here:\nhttps://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#span\n", + "markdownDescription": "span: `string` \nModule: `http.handlers.tracing` \nSpanName is a span name. It should follow the naming guidelines here:\nhttps://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#span \n", + "type": "string" + } + } + }, + "http.handlers.vars": { + "description": "vars: object\nModule: http.handlers.vars\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#VarsMiddleware\nVarsMiddleware is an HTTP middleware which sets variables to\nhave values that can be used in the HTTP request handler\nchain. The primary way to access variables is with placeholders,\nwhich have the form: `{http.vars.variable_name}`, or with\nthe `vars` and `vars_regexp` request matchers.\n\nThe key is the variable name, and the value is the value of the\nvariable. Both the name and value may use or contain placeholders.\n\n", + "markdownDescription": "vars: `object` \nModule: `http.handlers.vars` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#VarsMiddleware) \nVarsMiddleware is an HTTP middleware which sets variables to\nhave values that can be used in the HTTP request handler\nchain. The primary way to access variables is with placeholders,\nwhich have the form: `{http.vars.variable_name}`, or with\nthe `vars` and `vars_regexp` request matchers.\n\nThe key is the variable name, and the value is the value of the\nvariable. Both the name and value may use or contain placeholders.\n \n", + "type": "object", + "additionalProperties": {} + }, + "http.matchers.expression": { + "description": "expression: string\nModule: http.matchers.expression\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchExpression\nMatchExpression matches requests by evaluating a\n[CEL](https://github.com/google/cel-spec) expression.\nThis enables complex logic to be expressed using a comfortable,\nfamiliar syntax. Please refer to\n[the standard definitions of CEL functions and operators](https://github.com/google/cel-spec/blob/master/doc/langdef.md#standard-definitions).\n\nThis matcher's JSON interface is actually a string, not a struct.\nThe generated docs are not correct because this type has custom\nmarshaling logic.\n\nCOMPATIBILITY NOTE: This module is still experimental and is not\nsubject to Caddy's compatibility guarantee.\n\n", + "markdownDescription": "expression: `string` \nModule: `http.matchers.expression` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchExpression) \nMatchExpression matches requests by evaluating a\n[CEL](https://github.com/google/cel-spec) expression.\nThis enables complex logic to be expressed using a comfortable,\nfamiliar syntax. Please refer to\n[the standard definitions of CEL functions and operators](https://github.com/google/cel-spec/blob/master/doc/langdef.md#standard-definitions).\n\nThis matcher's JSON interface is actually a string, not a struct.\nThe generated docs are not correct because this type has custom\nmarshaling logic.\n\nCOMPATIBILITY NOTE: This module is still experimental and is not\nsubject to Caddy's compatibility guarantee.\n \n", + "type": "string" + }, + "http.matchers.file": { + "description": "file: object\nModule: http.matchers.file\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/fileserver#MatchFile\nMatchFile is an HTTP request matcher that can match\nrequests based upon file existence.\n\nUpon matching, three new placeholders will be made\navailable:\n\n- `{http.matchers.file.relative}` The root-relative\npath of the file. This is often useful when rewriting\nrequests.\n- `{http.matchers.file.absolute}` The absolute path\nof the matched file.\n- `{http.matchers.file.type}` Set to \"directory\" if\nthe matched file is a directory, \"file\" otherwise.\n- `{http.matchers.file.remainder}` Set to the remainder\nof the path if the path was split by `split_path`.\n\n", + "markdownDescription": "file: `object` \nModule: `http.matchers.file` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/fileserver#MatchFile) \nMatchFile is an HTTP request matcher that can match\nrequests based upon file existence.\n\nUpon matching, three new placeholders will be made\navailable:\n\n- `{http.matchers.file.relative}` The root-relative\npath of the file. This is often useful when rewriting\nrequests.\n- `{http.matchers.file.absolute}` The absolute path\nof the matched file.\n- `{http.matchers.file.type}` Set to \"directory\" if\nthe matched file is a directory, \"file\" otherwise.\n- `{http.matchers.file.remainder}` Set to the remainder\nof the path if the path was split by `split_path`.\n \n", + "type": "object", + "properties": { + "root": { + "description": "root: string\nModule: http.matchers.file\nThe root directory, used for creating absolute\nfile paths, and required when working with\nrelative paths; if not specified, `{http.vars.root}`\nwill be used, if set; otherwise, the current\ndirectory is assumed. Accepts placeholders.\n", + "markdownDescription": "root: `string` \nModule: `http.matchers.file` \nThe root directory, used for creating absolute\nfile paths, and required when working with\nrelative paths; if not specified, `{http.vars.root}`\nwill be used, if set; otherwise, the current\ndirectory is assumed. Accepts placeholders. \n", + "type": "string" + }, + "split_path": { + "description": "split_path: array\nModule: http.matchers.file\nA list of delimiters to use to split the path in two\nwhen trying files. If empty, no splitting will\noccur, and the path will be tried as-is. For each\nsplit value, the left-hand side of the split,\nincluding the split value, will be the path tried.\nFor example, the path `/remote.php/dav/` using the\nsplit value `.php` would try the file `/remote.php`.\nEach delimiter must appear at the end of a URI path\ncomponent in order to be used as a split delimiter.\n", + "markdownDescription": "split_path: `array` \nModule: `http.matchers.file` \nA list of delimiters to use to split the path in two\nwhen trying files. If empty, no splitting will\noccur, and the path will be tried as-is. For each\nsplit value, the left-hand side of the split,\nincluding the split value, will be the path tried.\nFor example, the path `/remote.php/dav/` using the\nsplit value `.php` would try the file `/remote.php`.\nEach delimiter must appear at the end of a URI path\ncomponent in order to be used as a split delimiter. \n", + "type": "array", + "items": { + "description": "A list of delimiters to use to split the path in two\nwhen trying files. If empty, no splitting will\noccur, and the path will be tried as-is. For each\nsplit value, the left-hand side of the split,\nincluding the split value, will be the path tried.\nFor example, the path `/remote.php/dav/` using the\nsplit value `.php` would try the file `/remote.php`.\nEach delimiter must appear at the end of a URI path\ncomponent in order to be used as a split delimiter.\n", + "markdownDescription": "A list of delimiters to use to split the path in two\nwhen trying files. If empty, no splitting will\noccur, and the path will be tried as-is. For each\nsplit value, the left-hand side of the split,\nincluding the split value, will be the path tried.\nFor example, the path `/remote.php/dav/` using the\nsplit value `.php` would try the file `/remote.php`.\nEach delimiter must appear at the end of a URI path\ncomponent in order to be used as a split delimiter. \n", + "type": "string" + } + }, + "try_files": { + "description": "try_files: array\nModule: http.matchers.file\nThe list of files to try. Each path here is\nconsidered related to Root. If nil, the request\nURL's path will be assumed. Files and\ndirectories are treated distinctly, so to match\na directory, the filepath MUST end in a forward\nslash `/`. To match a regular file, there must\nbe no trailing slash. Accepts placeholders. If\nthe policy is \"first_exist\", then an error may\nbe triggered as a fallback by configuring \"=\"\nfollowed by a status code number,\nfor example \"=404\".\n", + "markdownDescription": "try_files: `array` \nModule: `http.matchers.file` \nThe list of files to try. Each path here is\nconsidered related to Root. If nil, the request\nURL's path will be assumed. Files and\ndirectories are treated distinctly, so to match\na directory, the filepath MUST end in a forward\nslash `/`. To match a regular file, there must\nbe no trailing slash. Accepts placeholders. If\nthe policy is \"first_exist\", then an error may\nbe triggered as a fallback by configuring \"=\"\nfollowed by a status code number,\nfor example \"=404\". \n", + "type": "array", + "items": { + "description": "The list of files to try. Each path here is\nconsidered related to Root. If nil, the request\nURL's path will be assumed. Files and\ndirectories are treated distinctly, so to match\na directory, the filepath MUST end in a forward\nslash `/`. To match a regular file, there must\nbe no trailing slash. Accepts placeholders. If\nthe policy is \"first_exist\", then an error may\nbe triggered as a fallback by configuring \"=\"\nfollowed by a status code number,\nfor example \"=404\".\n", + "markdownDescription": "The list of files to try. Each path here is\nconsidered related to Root. If nil, the request\nURL's path will be assumed. Files and\ndirectories are treated distinctly, so to match\na directory, the filepath MUST end in a forward\nslash `/`. To match a regular file, there must\nbe no trailing slash. Accepts placeholders. If\nthe policy is \"first_exist\", then an error may\nbe triggered as a fallback by configuring \"=\"\nfollowed by a status code number,\nfor example \"=404\". \n", + "type": "string" + } + }, + "try_policy": { + "description": "try_policy: string\nModule: http.matchers.file\nHow to choose a file in TryFiles. Can be:\n\n- first_exist\n- smallest_size\n- largest_size\n- most_recently_modified\n\nDefault is first_exist.\n", + "markdownDescription": "try_policy: `string` \nModule: `http.matchers.file` \nHow to choose a file in TryFiles. Can be:\n\n- first_exist\n- smallest_size\n- largest_size\n- most_recently_modified\n\nDefault is first_exist. \n", + "type": "string" + } + } + }, + "http.matchers.header": { + "description": "header: object\nModule: http.matchers.header\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchHeader\nMatchHeader matches requests by header fields. The key is the field\nname and the array is the list of field values. It performs fast,\nexact string comparisons of the field values. Fast prefix, suffix,\nand substring matches can also be done by suffixing, prefixing, or\nsurrounding the value with the wildcard `*` character, respectively.\nIf a list is null, the header must not exist. If the list is empty,\nthe field must simply exist, regardless of its value.\n\n", + "markdownDescription": "header: `object` \nModule: `http.matchers.header` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchHeader) \nMatchHeader matches requests by header fields. The key is the field\nname and the array is the list of field values. It performs fast,\nexact string comparisons of the field values. Fast prefix, suffix,\nand substring matches can also be done by suffixing, prefixing, or\nsurrounding the value with the wildcard `*` character, respectively.\nIf a list is null, the header must not exist. If the list is empty,\nthe field must simply exist, regardless of its value.\n \n", + "type": "object", + "additionalProperties": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "http.matchers.header_regexp": { + "description": "header_regexp: object\nModule: http.matchers.header_regexp\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRegexp\nMatchRegexp is an embedable type for matching\nusing regular expressions. It adds placeholders\nto the request's replacer.\n\n", + "markdownDescription": "header_regexp: `object` \nModule: `http.matchers.header_regexp` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRegexp) \nMatchRegexp is an embedable type for matching\nusing regular expressions. It adds placeholders\nto the request's replacer.\n \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRegexp\nMatchRegexp is an embedable type for matching\nusing regular expressions. It adds placeholders\nto the request's replacer.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRegexp) \nMatchRegexp is an embedable type for matching\nusing regular expressions. It adds placeholders\nto the request's replacer.\n \n", + "properties": { + "name": { + "description": "name: string\nModule: http.matchers.header_regexp\nA unique name for this regular expression. Optional,\nbut useful to prevent overwriting captures from other\nregexp matchers.\n", + "markdownDescription": "name: `string` \nModule: `http.matchers.header_regexp` \nA unique name for this regular expression. Optional,\nbut useful to prevent overwriting captures from other\nregexp matchers. \n", + "type": "string" + }, + "pattern": { + "description": "pattern: string\nModule: http.matchers.header_regexp\nThe regular expression to evaluate, in RE2 syntax,\nwhich is the same general syntax used by Go, Perl,\nand Python. For details, see\n[Go's regexp package](https://golang.org/pkg/regexp/).\nCaptures are accessible via placeholders. Unnamed\ncapture groups are exposed as their numeric, 1-based\nindex, while named capture groups are available by\nthe capture group name.\n", + "markdownDescription": "pattern: `string` \nModule: `http.matchers.header_regexp` \nThe regular expression to evaluate, in RE2 syntax,\nwhich is the same general syntax used by Go, Perl,\nand Python. For details, see\n[Go's regexp package](https://golang.org/pkg/regexp/).\nCaptures are accessible via placeholders. Unnamed\ncapture groups are exposed as their numeric, 1-based\nindex, while named capture groups are available by\nthe capture group name. \n", + "type": "string" + } + } + } + }, + "http.matchers.host": { + "description": "host: array\nModule: http.matchers.host\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchHost\nMatchHost matches requests by the Host value (case-insensitive).\n\nWhen used in a top-level HTTP route,\n[qualifying domain names](/docs/automatic-https#hostname-requirements)\nmay trigger [automatic HTTPS](/docs/automatic-https), which automatically\nprovisions and renews certificates for you. Before doing this, you\nshould ensure that DNS records for these domains are properly configured,\nespecially A/AAAA pointed at your server.\n\nAutomatic HTTPS can be\n[customized or disabled](/docs/modules/http#servers/automatic_https).\n\nWildcards (`*`) may be used to represent exactly one label of the\nhostname, in accordance with RFC 1034 (because host matchers are also\nused for automatic HTTPS which influences TLS certificates). Thus,\na host of `*` matches hosts like `localhost` or `internal` but not\n`example.com`. To catch all hosts, omit the host matcher entirely.\n\nThe wildcard can be useful for matching all subdomains, for example:\n`*.example.com` matches `foo.example.com` but not `foo.bar.example.com`.\n\nDuplicate entries will return an error.\n\n", + "markdownDescription": "host: `array` \nModule: `http.matchers.host` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchHost) \nMatchHost matches requests by the Host value (case-insensitive).\n\nWhen used in a top-level HTTP route,\n[qualifying domain names](/docs/automatic-https#hostname-requirements)\nmay trigger [automatic HTTPS](/docs/automatic-https), which automatically\nprovisions and renews certificates for you. Before doing this, you\nshould ensure that DNS records for these domains are properly configured,\nespecially A/AAAA pointed at your server.\n\nAutomatic HTTPS can be\n[customized or disabled](/docs/modules/http#servers/automatic_https).\n\nWildcards (`*`) may be used to represent exactly one label of the\nhostname, in accordance with RFC 1034 (because host matchers are also\nused for automatic HTTPS which influences TLS certificates). Thus,\na host of `*` matches hosts like `localhost` or `internal` but not\n`example.com`. To catch all hosts, omit the host matcher entirely.\n\nThe wildcard can be useful for matching all subdomains, for example:\n`*.example.com` matches `foo.example.com` but not `foo.bar.example.com`.\n\nDuplicate entries will return an error.\n \n", + "type": "array", + "items": { + "type": "string" + } + }, + "http.matchers.method": { + "description": "method: array\nModule: http.matchers.method\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchMethod\nMatchMethod matches requests by the method.\n\n", + "markdownDescription": "method: `array` \nModule: `http.matchers.method` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchMethod) \nMatchMethod matches requests by the method.\n \n", + "type": "array", + "items": { + "type": "string" + } + }, + "http.matchers.not": { + "description": "not: array\nModule: http.matchers.not\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchNot\nMatchNot matches requests by negating the results of its matcher\nsets. A single \"not\" matcher takes one or more matcher sets. Each\nmatcher set is OR'ed; in other words, if any matcher set returns\ntrue, the final result of the \"not\" matcher is false. Individual\nmatchers within a set work the same (i.e. different matchers in\nthe same set are AND'ed).\n\nNOTE: The generated docs which describe the structure of this\nmodule are wrong because of how this type unmarshals JSON in a\ncustom way. The correct structure is:\n\n```json\n[\n\t{},\n\t{}\n]\n```\n\nwhere each of the array elements is a matcher set, i.e. an\nobject keyed by matcher name.\n\n", + "markdownDescription": "not: `array` \nModule: `http.matchers.not` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchNot) \nMatchNot matches requests by negating the results of its matcher\nsets. A single \"not\" matcher takes one or more matcher sets. Each\nmatcher set is OR'ed; in other words, if any matcher set returns\ntrue, the final result of the \"not\" matcher is false. Individual\nmatchers within a set work the same (i.e. different matchers in\nthe same set are AND'ed).\n\nNOTE: The generated docs which describe the structure of this\nmodule are wrong because of how this type unmarshals JSON in a\ncustom way. The correct structure is:\n\n```json\n[\n\t{},\n\t{}\n]\n```\n\nwhere each of the array elements is a matcher set, i.e. an\nobject keyed by matcher name.\n \n", + "type": "array", + "items": { + "properties": { + "expression": { + "$ref": "#/definitions/http.matchers.expression" + }, + "file": { + "$ref": "#/definitions/http.matchers.file" + }, + "header": { + "$ref": "#/definitions/http.matchers.header" + }, + "header_regexp": { + "$ref": "#/definitions/http.matchers.header_regexp" + }, + "host": { + "$ref": "#/definitions/http.matchers.host" + }, + "method": { + "$ref": "#/definitions/http.matchers.method" + }, + "not": { + "$ref": "#/definitions/http.matchers.not" + }, + "path": { + "$ref": "#/definitions/http.matchers.path" + }, + "path_regexp": { + "$ref": "#/definitions/http.matchers.path_regexp" + }, + "protocol": { + "$ref": "#/definitions/http.matchers.protocol" + }, + "query": { + "$ref": "#/definitions/http.matchers.query" + }, + "remote_ip": { + "$ref": "#/definitions/http.matchers.remote_ip" + }, + "vars": { + "$ref": "#/definitions/http.matchers.vars" + }, + "vars_regexp": { + "$ref": "#/definitions/http.matchers.vars_regexp" + } + } + } + }, + "http.matchers.path": { + "description": "path: array\nModule: http.matchers.path\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchPath\nMatchPath matches requests by the URI's path (case-insensitive). Path\nmatches are exact, but wildcards may be used:\n\n- At the end, for a prefix match (`/prefix/*`)\n- At the beginning, for a suffix match (`*.suffix`)\n- On both sides, for a substring match (`*/contains/*`)\n- In the middle, for a globular match (`/accounts/*/info`)\n\nThis matcher is fast, so it does not support regular expressions or\ncapture groups. For slower but more powerful matching, use the\npath_regexp matcher.\n\n", + "markdownDescription": "path: `array` \nModule: `http.matchers.path` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchPath) \nMatchPath matches requests by the URI's path (case-insensitive). Path\nmatches are exact, but wildcards may be used:\n\n- At the end, for a prefix match (`/prefix/*`)\n- At the beginning, for a suffix match (`*.suffix`)\n- On both sides, for a substring match (`*/contains/*`)\n- In the middle, for a globular match (`/accounts/*/info`)\n\nThis matcher is fast, so it does not support regular expressions or\ncapture groups. For slower but more powerful matching, use the\npath_regexp matcher.\n \n", + "type": "array", + "items": { + "type": "string" + } + }, + "http.matchers.path_regexp": { + "description": "path_regexp: object\nModule: http.matchers.path_regexp\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchPathRE\nMatchPathRE matches requests by a regular expression on the URI's path.\n\nUpon a match, it adds placeholders to the request: `{http.regexp.name.capture_group}`\nwhere `name` is the regular expression's name, and `capture_group` is either\nthe named or positional capture group from the expression itself. If no name\nis given, then the placeholder omits the name: `{http.regexp.capture_group}`\n(potentially leading to collisions).\n\n", + "markdownDescription": "path_regexp: `object` \nModule: `http.matchers.path_regexp` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchPathRE) \nMatchPathRE matches requests by a regular expression on the URI's path.\n\nUpon a match, it adds placeholders to the request: `{http.regexp.name.capture_group}`\nwhere `name` is the regular expression's name, and `capture_group` is either\nthe named or positional capture group from the expression itself. If no name\nis given, then the placeholder omits the name: `{http.regexp.capture_group}`\n(potentially leading to collisions).\n \n", + "type": "object", + "properties": { + "name": { + "description": "name: string\nModule: http.matchers.path_regexp\nA unique name for this regular expression. Optional,\nbut useful to prevent overwriting captures from other\nregexp matchers.\n", + "markdownDescription": "name: `string` \nModule: `http.matchers.path_regexp` \nA unique name for this regular expression. Optional,\nbut useful to prevent overwriting captures from other\nregexp matchers. \n", + "type": "string" + }, + "pattern": { + "description": "pattern: string\nModule: http.matchers.path_regexp\nThe regular expression to evaluate, in RE2 syntax,\nwhich is the same general syntax used by Go, Perl,\nand Python. For details, see\n[Go's regexp package](https://golang.org/pkg/regexp/).\nCaptures are accessible via placeholders. Unnamed\ncapture groups are exposed as their numeric, 1-based\nindex, while named capture groups are available by\nthe capture group name.\n", + "markdownDescription": "pattern: `string` \nModule: `http.matchers.path_regexp` \nThe regular expression to evaluate, in RE2 syntax,\nwhich is the same general syntax used by Go, Perl,\nand Python. For details, see\n[Go's regexp package](https://golang.org/pkg/regexp/).\nCaptures are accessible via placeholders. Unnamed\ncapture groups are exposed as their numeric, 1-based\nindex, while named capture groups are available by\nthe capture group name. \n", + "type": "string" + } + } + }, + "http.matchers.protocol": { + "description": "protocol: string\nModule: http.matchers.protocol\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchProtocol\nMatchProtocol matches requests by protocol. Recognized values are\n\"http\", \"https\", and \"grpc\".\n\n", + "markdownDescription": "protocol: `string` \nModule: `http.matchers.protocol` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchProtocol) \nMatchProtocol matches requests by protocol. Recognized values are\n\"http\", \"https\", and \"grpc\".\n \n", + "type": "string" + }, + "http.matchers.query": { + "description": "query: object\nModule: http.matchers.query\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchQuery\nMatchQuery matches requests by the URI's query string. It takes a JSON object\nkeyed by the query keys, with an array of string values to match for that key.\nQuery key matches are exact, but wildcards may be used for value matches. Both\nkeys and values may be placeholders.\nAn example of the structure to match `?key=value\u0026topic=api\u0026query=something` is:\n\n```json\n{\n\t\"key\": [\"value\"],\n\t\"topic\": [\"api\"],\n\t\"query\": [\"*\"]\n}\n```\n\n", + "markdownDescription": "query: `object` \nModule: `http.matchers.query` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchQuery) \nMatchQuery matches requests by the URI's query string. It takes a JSON object\nkeyed by the query keys, with an array of string values to match for that key.\nQuery key matches are exact, but wildcards may be used for value matches. Both\nkeys and values may be placeholders.\nAn example of the structure to match `?key=value\u0026topic=api\u0026query=something` is:\n\n```json\n{\n\t\"key\": [\"value\"],\n\t\"topic\": [\"api\"],\n\t\"query\": [\"*\"]\n}\n```\n \n", + "type": "object", + "additionalProperties": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "http.matchers.remote_ip": { + "description": "remote_ip: object\nModule: http.matchers.remote_ip\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRemoteIP\nMatchRemoteIP matches requests by client IP (or CIDR range).\n\n", + "markdownDescription": "remote_ip: `object` \nModule: `http.matchers.remote_ip` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRemoteIP) \nMatchRemoteIP matches requests by client IP (or CIDR range).\n \n", + "type": "object", + "properties": { + "forwarded": { + "description": "forwarded: boolean\nModule: http.matchers.remote_ip\nIf true, prefer the first IP in the request's X-Forwarded-For\nheader, if present, rather than the immediate peer's IP, as\nthe reference IP against which to match. Note that it is easy\nto spoof request headers. Default: false\n", + "markdownDescription": "forwarded: `boolean` \nModule: `http.matchers.remote_ip` \nIf true, prefer the first IP in the request's X-Forwarded-For\nheader, if present, rather than the immediate peer's IP, as\nthe reference IP against which to match. Note that it is easy\nto spoof request headers. Default: false \n", + "type": "boolean" + }, + "ranges": { + "description": "ranges: array\nModule: http.matchers.remote_ip\nThe IPs or CIDR ranges to match.\n", + "markdownDescription": "ranges: `array` \nModule: `http.matchers.remote_ip` \nThe IPs or CIDR ranges to match. \n", + "type": "array", + "items": { + "description": "The IPs or CIDR ranges to match.\n", + "markdownDescription": "The IPs or CIDR ranges to match. \n", + "type": "string" + } + } + } + }, + "http.matchers.vars": { + "description": "vars: object\nModule: http.matchers.vars\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#VarsMatcher\nVarsMatcher is an HTTP request matcher which can match\nrequests based on variables in the context. The key is\nthe name of the variable, and the values are possible\nvalues the variable can be in order to match (OR'ed).\n\nAs a special case, this matcher can also match on\nplaceholders generally. If the key is not an HTTP chain\nvariable, it will be checked to see if it is a\nplaceholder name, and if so, will compare its value.\n\n", + "markdownDescription": "vars: `object` \nModule: `http.matchers.vars` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#VarsMatcher) \nVarsMatcher is an HTTP request matcher which can match\nrequests based on variables in the context. The key is\nthe name of the variable, and the values are possible\nvalues the variable can be in order to match (OR'ed).\n\nAs a special case, this matcher can also match on\nplaceholders generally. If the key is not an HTTP chain\nvariable, it will be checked to see if it is a\nplaceholder name, and if so, will compare its value.\n \n", + "type": "object", + "additionalProperties": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "http.matchers.vars_regexp": { + "description": "vars_regexp: object\nModule: http.matchers.vars_regexp\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRegexp\nMatchRegexp is an embedable type for matching\nusing regular expressions. It adds placeholders\nto the request's replacer.\n\n", + "markdownDescription": "vars_regexp: `object` \nModule: `http.matchers.vars_regexp` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRegexp) \nMatchRegexp is an embedable type for matching\nusing regular expressions. It adds placeholders\nto the request's replacer.\n \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRegexp\nMatchRegexp is an embedable type for matching\nusing regular expressions. It adds placeholders\nto the request's replacer.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp#MatchRegexp) \nMatchRegexp is an embedable type for matching\nusing regular expressions. It adds placeholders\nto the request's replacer.\n \n", + "properties": { + "name": { + "description": "name: string\nModule: http.matchers.vars_regexp\nA unique name for this regular expression. Optional,\nbut useful to prevent overwriting captures from other\nregexp matchers.\n", + "markdownDescription": "name: `string` \nModule: `http.matchers.vars_regexp` \nA unique name for this regular expression. Optional,\nbut useful to prevent overwriting captures from other\nregexp matchers. \n", + "type": "string" + }, + "pattern": { + "description": "pattern: string\nModule: http.matchers.vars_regexp\nThe regular expression to evaluate, in RE2 syntax,\nwhich is the same general syntax used by Go, Perl,\nand Python. For details, see\n[Go's regexp package](https://golang.org/pkg/regexp/).\nCaptures are accessible via placeholders. Unnamed\ncapture groups are exposed as their numeric, 1-based\nindex, while named capture groups are available by\nthe capture group name.\n", + "markdownDescription": "pattern: `string` \nModule: `http.matchers.vars_regexp` \nThe regular expression to evaluate, in RE2 syntax,\nwhich is the same general syntax used by Go, Perl,\nand Python. For details, see\n[Go's regexp package](https://golang.org/pkg/regexp/).\nCaptures are accessible via placeholders. Unnamed\ncapture groups are exposed as their numeric, 1-based\nindex, while named capture groups are available by\nthe capture group name. \n", + "type": "string" + } + } + } + }, + "http.precompressed.br": { + "description": "br: object\nModule: http.precompressed.br\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/brotli#BrotliPrecompressed", + "markdownDescription": "br: `object` \nModule: `http.precompressed.br` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/brotli#BrotliPrecompressed)", + "type": "object" + }, + "http.precompressed.gzip": { + "description": "gzip: object\nModule: http.precompressed.gzip\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/gzip#GzipPrecompressed", + "markdownDescription": "gzip: `object` \nModule: `http.precompressed.gzip` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/gzip#GzipPrecompressed)", + "type": "object", + "properties": { + "level": { + "description": "level: number\nModule: http.precompressed.gzip\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/gzip#GzipPrecompressed", + "markdownDescription": "level: `number` \nModule: `http.precompressed.gzip` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/gzip#GzipPrecompressed)", + "type": "number" + } + } + }, + "http.precompressed.zstd": { + "description": "zstd: object\nModule: http.precompressed.zstd\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/zstd#ZstdPrecompressed", + "markdownDescription": "zstd: `object` \nModule: `http.precompressed.zstd` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/zstd#ZstdPrecompressed)", + "type": "object" + }, + "http.reverse_proxy.selection_policies.cookie": { + "description": "cookie: object\nModule: http.reverse_proxy.selection_policies.cookie\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CookieHashSelection", + "markdownDescription": "cookie: `object` \nModule: `http.reverse_proxy.selection_policies.cookie` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CookieHashSelection)", + "type": "object", + "properties": { + "name": { + "description": "name: string\nModule: http.reverse_proxy.selection_policies.cookie\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CookieHashSelection", + "markdownDescription": "name: `string` \nModule: `http.reverse_proxy.selection_policies.cookie` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CookieHashSelection)", + "type": "string" + }, + "secret": { + "description": "secret: string\nModule: http.reverse_proxy.selection_policies.cookie\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CookieHashSelection", + "markdownDescription": "secret: `string` \nModule: `http.reverse_proxy.selection_policies.cookie` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#CookieHashSelection)", + "type": "string" + } + } + }, + "http.reverse_proxy.selection_policies.first": { + "description": "first: object\nModule: http.reverse_proxy.selection_policies.first\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#FirstSelection", + "markdownDescription": "first: `object` \nModule: `http.reverse_proxy.selection_policies.first` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#FirstSelection)", + "type": "object" + }, + "http.reverse_proxy.selection_policies.header": { + "description": "header: object\nModule: http.reverse_proxy.selection_policies.header\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HeaderHashSelection", + "markdownDescription": "header: `object` \nModule: `http.reverse_proxy.selection_policies.header` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HeaderHashSelection)", + "type": "object", + "properties": { + "field": { + "description": "field: string\nModule: http.reverse_proxy.selection_policies.header\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HeaderHashSelection", + "markdownDescription": "field: `string` \nModule: `http.reverse_proxy.selection_policies.header` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HeaderHashSelection)", + "type": "string" + } + } + }, + "http.reverse_proxy.selection_policies.ip_hash": { + "description": "ip_hash: object\nModule: http.reverse_proxy.selection_policies.ip_hash\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#IPHashSelection", + "markdownDescription": "ip_hash: `object` \nModule: `http.reverse_proxy.selection_policies.ip_hash` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#IPHashSelection)", + "type": "object" + }, + "http.reverse_proxy.selection_policies.least_conn": { + "description": "least_conn: object\nModule: http.reverse_proxy.selection_policies.least_conn\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#LeastConnSelection", + "markdownDescription": "least_conn: `object` \nModule: `http.reverse_proxy.selection_policies.least_conn` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#LeastConnSelection)", + "type": "object" + }, + "http.reverse_proxy.selection_policies.random": { + "description": "random: object\nModule: http.reverse_proxy.selection_policies.random\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#RandomSelection", + "markdownDescription": "random: `object` \nModule: `http.reverse_proxy.selection_policies.random` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#RandomSelection)", + "type": "object" + }, + "http.reverse_proxy.selection_policies.random_choose": { + "description": "random_choose: object\nModule: http.reverse_proxy.selection_policies.random_choose\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#RandomChoiceSelection", + "markdownDescription": "random_choose: `object` \nModule: `http.reverse_proxy.selection_policies.random_choose` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#RandomChoiceSelection)", + "type": "object", + "properties": { + "choose": { + "description": "choose: number\nModule: http.reverse_proxy.selection_policies.random_choose\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#RandomChoiceSelection", + "markdownDescription": "choose: `number` \nModule: `http.reverse_proxy.selection_policies.random_choose` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#RandomChoiceSelection)", + "type": "number" + } + } + }, + "http.reverse_proxy.selection_policies.round_robin": { + "description": "round_robin: object\nModule: http.reverse_proxy.selection_policies.round_robin\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#RoundRobinSelection", + "markdownDescription": "round_robin: `object` \nModule: `http.reverse_proxy.selection_policies.round_robin` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#RoundRobinSelection)", + "type": "object" + }, + "http.reverse_proxy.selection_policies.uri_hash": { + "description": "uri_hash: object\nModule: http.reverse_proxy.selection_policies.uri_hash\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#URIHashSelection", + "markdownDescription": "uri_hash: `object` \nModule: `http.reverse_proxy.selection_policies.uri_hash` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#URIHashSelection)", + "type": "object" + }, + "http.reverse_proxy.transport.fastcgi": { + "description": "fastcgi: object\nModule: http.reverse_proxy.transport.fastcgi\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport", + "markdownDescription": "fastcgi: `object` \nModule: `http.reverse_proxy.transport.fastcgi` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport)", + "type": "object", + "properties": { + "dial_timeout": { + "description": "dial_timeout: number\nModule: http.reverse_proxy.transport.fastcgi\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport", + "markdownDescription": "dial_timeout: `number` \nModule: `http.reverse_proxy.transport.fastcgi` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport)", + "type": "number" + }, + "env": { + "description": "env: object\nModule: http.reverse_proxy.transport.fastcgi\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport", + "markdownDescription": "env: `object` \nModule: `http.reverse_proxy.transport.fastcgi` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport)", + "type": "object", + "additionalProperties": {} + }, + "read_timeout": { + "description": "read_timeout: number\nModule: http.reverse_proxy.transport.fastcgi\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport", + "markdownDescription": "read_timeout: `number` \nModule: `http.reverse_proxy.transport.fastcgi` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport)", + "type": "number" + }, + "resolve_root_symlink": { + "description": "resolve_root_symlink: boolean\nModule: http.reverse_proxy.transport.fastcgi\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport", + "markdownDescription": "resolve_root_symlink: `boolean` \nModule: `http.reverse_proxy.transport.fastcgi` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport)", + "type": "boolean" + }, + "root": { + "description": "root: string\nModule: http.reverse_proxy.transport.fastcgi\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport", + "markdownDescription": "root: `string` \nModule: `http.reverse_proxy.transport.fastcgi` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport)", + "type": "string" + }, + "split_path": { + "description": "split_path: array\nModule: http.reverse_proxy.transport.fastcgi\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport", + "markdownDescription": "split_path: `array` \nModule: `http.reverse_proxy.transport.fastcgi` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport)", + "type": "array", + "items": { + "type": "string" + } + }, + "write_timeout": { + "description": "write_timeout: number\nModule: http.reverse_proxy.transport.fastcgi\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport", + "markdownDescription": "write_timeout: `number` \nModule: `http.reverse_proxy.transport.fastcgi` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi#Transport)", + "type": "number" + } + } + }, + "http.reverse_proxy.transport.http": { + "description": "http: object\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "http: `object` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "object", + "properties": { + "compression": { + "description": "compression: boolean\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "compression: `boolean` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "boolean" + }, + "dial_fallback_delay": { + "description": "dial_fallback_delay: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "dial_fallback_delay: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "dial_timeout": { + "description": "dial_timeout: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "dial_timeout: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "expect_continue_timeout": { + "description": "expect_continue_timeout: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "expect_continue_timeout: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "keep_alive": { + "description": "keep_alive: object\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "keep_alive: `object` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "object", + "properties": { + "enabled": { + "description": "enabled: boolean\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "enabled: `boolean` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "boolean" + }, + "idle_timeout": { + "description": "idle_timeout: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "idle_timeout: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "max_idle_conns": { + "description": "max_idle_conns: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "max_idle_conns: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "max_idle_conns_per_host": { + "description": "max_idle_conns_per_host: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "max_idle_conns_per_host: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "probe_interval": { + "description": "probe_interval: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "probe_interval: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + } + } + }, + "max_conns_per_host": { + "description": "max_conns_per_host: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "max_conns_per_host: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "max_response_header_size": { + "description": "max_response_header_size: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "max_response_header_size: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "read_buffer_size": { + "description": "read_buffer_size: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "read_buffer_size: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "resolver": { + "description": "resolver: object\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "resolver: `object` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "object", + "properties": { + "addresses": { + "description": "addresses: array\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "addresses: `array` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "response_header_timeout": { + "description": "response_header_timeout: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "response_header_timeout: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "tls": { + "description": "tls: object\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "tls: `object` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "object", + "properties": { + "client_certificate_automate": { + "description": "client_certificate_automate: string\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "client_certificate_automate: `string` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "string" + }, + "client_certificate_file": { + "description": "client_certificate_file: string\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "client_certificate_file: `string` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "string" + }, + "client_certificate_key_file": { + "description": "client_certificate_key_file: string\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "client_certificate_key_file: `string` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "string" + }, + "except_ports": { + "description": "except_ports: array\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "except_ports: `array` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "array", + "items": { + "type": "string" + } + }, + "handshake_timeout": { + "description": "handshake_timeout: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "handshake_timeout: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + }, + "insecure_skip_verify": { + "description": "insecure_skip_verify: boolean\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "insecure_skip_verify: `boolean` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "boolean" + }, + "renegotiation": { + "description": "renegotiation: string\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "renegotiation: `string` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "string" + }, + "root_ca_pem_files": { + "description": "root_ca_pem_files: array\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "root_ca_pem_files: `array` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "array", + "items": { + "type": "string" + } + }, + "root_ca_pool": { + "description": "root_ca_pool: array\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "root_ca_pool: `array` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "array", + "items": { + "type": "string" + } + }, + "server_name": { + "description": "server_name: string\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "server_name: `string` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "string" + } + } + }, + "versions": { + "description": "versions: array\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "versions: `array` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "array", + "items": { + "type": "string" + } + }, + "write_buffer_size": { + "description": "write_buffer_size: number\nModule: http.reverse_proxy.transport.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport", + "markdownDescription": "write_buffer_size: `number` \nModule: `http.reverse_proxy.transport.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#HTTPTransport)", + "type": "number" + } + } + }, + "http.reverse_proxy.upstreams.a": { + "description": "a: object\nModule: http.reverse_proxy.upstreams.a\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams", + "markdownDescription": "a: `object` \nModule: `http.reverse_proxy.upstreams.a` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams)", + "type": "object", + "properties": { + "dial_fallback_delay": { + "description": "dial_fallback_delay: number\nModule: http.reverse_proxy.upstreams.a\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams", + "markdownDescription": "dial_fallback_delay: `number` \nModule: `http.reverse_proxy.upstreams.a` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams)", + "type": "number" + }, + "dial_timeout": { + "description": "dial_timeout: number\nModule: http.reverse_proxy.upstreams.a\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams", + "markdownDescription": "dial_timeout: `number` \nModule: `http.reverse_proxy.upstreams.a` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams)", + "type": "number" + }, + "name": { + "description": "name: string\nModule: http.reverse_proxy.upstreams.a\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams", + "markdownDescription": "name: `string` \nModule: `http.reverse_proxy.upstreams.a` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams)", + "type": "string" + }, + "port": { + "description": "port: string\nModule: http.reverse_proxy.upstreams.a\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams", + "markdownDescription": "port: `string` \nModule: `http.reverse_proxy.upstreams.a` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams)", + "type": "string" + }, + "refresh": { + "description": "refresh: number\nModule: http.reverse_proxy.upstreams.a\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams", + "markdownDescription": "refresh: `number` \nModule: `http.reverse_proxy.upstreams.a` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams)", + "type": "number" + }, + "resolver": { + "description": "resolver: object\nModule: http.reverse_proxy.upstreams.a\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams", + "markdownDescription": "resolver: `object` \nModule: `http.reverse_proxy.upstreams.a` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams)", + "type": "object", + "properties": { + "addresses": { + "description": "addresses: array\nModule: http.reverse_proxy.upstreams.a\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams", + "markdownDescription": "addresses: `array` \nModule: `http.reverse_proxy.upstreams.a` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#AUpstreams)", + "type": "array", + "items": { + "type": "string" + } + } + } + } + } + }, + "http.reverse_proxy.upstreams.srv": { + "description": "srv: object\nModule: http.reverse_proxy.upstreams.srv\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams", + "markdownDescription": "srv: `object` \nModule: `http.reverse_proxy.upstreams.srv` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams)", + "type": "object", + "properties": { + "dial_fallback_delay": { + "description": "dial_fallback_delay: number\nModule: http.reverse_proxy.upstreams.srv\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams", + "markdownDescription": "dial_fallback_delay: `number` \nModule: `http.reverse_proxy.upstreams.srv` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams)", + "type": "number" + }, + "dial_timeout": { + "description": "dial_timeout: number\nModule: http.reverse_proxy.upstreams.srv\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams", + "markdownDescription": "dial_timeout: `number` \nModule: `http.reverse_proxy.upstreams.srv` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams)", + "type": "number" + }, + "name": { + "description": "name: string\nModule: http.reverse_proxy.upstreams.srv\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams", + "markdownDescription": "name: `string` \nModule: `http.reverse_proxy.upstreams.srv` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams)", + "type": "string" + }, + "proto": { + "description": "proto: string\nModule: http.reverse_proxy.upstreams.srv\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams", + "markdownDescription": "proto: `string` \nModule: `http.reverse_proxy.upstreams.srv` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams)", + "type": "string" + }, + "refresh": { + "description": "refresh: number\nModule: http.reverse_proxy.upstreams.srv\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams", + "markdownDescription": "refresh: `number` \nModule: `http.reverse_proxy.upstreams.srv` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams)", + "type": "number" + }, + "resolver": { + "description": "resolver: object\nModule: http.reverse_proxy.upstreams.srv\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams", + "markdownDescription": "resolver: `object` \nModule: `http.reverse_proxy.upstreams.srv` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams)", + "type": "object", + "properties": { + "addresses": { + "description": "addresses: array\nModule: http.reverse_proxy.upstreams.srv\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams", + "markdownDescription": "addresses: `array` \nModule: `http.reverse_proxy.upstreams.srv` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams)", + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "service": { + "description": "service: string\nModule: http.reverse_proxy.upstreams.srv\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams", + "markdownDescription": "service: `string` \nModule: `http.reverse_proxy.upstreams.srv` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#SRVUpstreams)", + "type": "string" + } + } + }, + "layer4": { + "description": "layer4: object\nModule: layer4\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/layer4#App\nApp is a Caddy app that operates closest to layer 4 of the OSI model.\n\n", + "markdownDescription": "layer4: `object` \nModule: `layer4` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/layer4#App) \nApp is a Caddy app that operates closest to layer 4 of the OSI model.\n \n", + "type": "object", + "properties": { + "servers": { + "description": "servers: object\nModule: layer4\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/layer4#Server\nServer represents a Caddy layer4 server.\n\n", + "markdownDescription": "servers: `object` \nModule: `layer4` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/layer4#Server) \nServer represents a Caddy layer4 server.\n \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/mholt/caddy-l4/layer4#Server\nServer represents a Caddy layer4 server.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/layer4#Server) \nServer represents a Caddy layer4 server.\n \n", + "properties": { + "listen": { + "description": "listen: array\nModule: layer4\n", + "markdownDescription": "listen: `array` \nModule: `layer4` \n", + "type": "array", + "items": { + "type": "string" + } + }, + "routes": { + "description": "routes: array\nModule: layer4\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/layer4#Route\nRoute represents a collection of handlers that are gated\nby matching and other kinds of logic.\n\n", + "markdownDescription": "routes: `array` \nModule: `layer4` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/layer4#Route) \nRoute represents a collection of handlers that are gated\nby matching and other kinds of logic.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/mholt/caddy-l4/layer4#Route\nRoute represents a collection of handlers that are gated\nby matching and other kinds of logic.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/layer4#Route) \nRoute represents a collection of handlers that are gated\nby matching and other kinds of logic.\n \n", + "type": "object", + "properties": { + "handle": { + "description": "handle: array\nModule: layer4.handlers\n", + "markdownDescription": "handle: `array` \nModule: `layer4.handlers` \n", + "type": "array", + "items": { + "required": [ + "handler" + ], + "allOf": [ + { + "if": { + "properties": { + "handler": { + "const": "throttle" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.throttle" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tls" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.tls" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "echo" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.echo" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "proxy" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.proxy" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "proxy_protocol" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.proxy_protocol" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "subroute" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.subroute" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tee" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.tee" + } + }, + { + "properties": { + "handler": { + "description": "key to identify handle module.\nhandler: string\nModule: layer4.handlers", + "markdownDescription": "key to identify `handle` module. \nhandler: `string` \nModule: `layer4.handlers`", + "type": "string", + "enum": [ + "throttle", + "tls", + "echo", + "proxy", + "proxy_protocol", + "subroute", + "tee" + ] + } + } + } + ] + } + }, + "match": { + "description": "match: array\nModule: layer4.matchers\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n\n", + "markdownDescription": "match: `array` \nModule: `layer4.matchers` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n \n", + "properties": { + "http": { + "$ref": "#/definitions/layer4.matchers.http" + }, + "ip": { + "$ref": "#/definitions/layer4.matchers.ip" + }, + "proxy_protocol": { + "$ref": "#/definitions/layer4.matchers.proxy_protocol" + }, + "ssh": { + "$ref": "#/definitions/layer4.matchers.ssh" + }, + "tls": { + "$ref": "#/definitions/layer4.matchers.tls" + }, + "xmpp": { + "$ref": "#/definitions/layer4.matchers.xmpp" + } + } + } + } + } + } + } + } + } + } + } + }, + "layer4.handlers.echo": { + "description": "echo: object\nModule: layer4.handlers.echo\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4echo#Handler\nHandler is a simple handler that writes what it reads.\n\n", + "markdownDescription": "echo: `object` \nModule: `layer4.handlers.echo` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4echo#Handler) \nHandler is a simple handler that writes what it reads.\n \n", + "type": "object" + }, + "layer4.handlers.proxy": { + "description": "proxy: object\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Handler\nHandler is a handler that can proxy connections.\n\n", + "markdownDescription": "proxy: `object` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Handler) \nHandler is a handler that can proxy connections.\n \n", + "type": "object", + "properties": { + "health_checks": { + "description": "health_checks: object\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#HealthChecks\nHealth checks update the status of backends, whether they are\nup or down. Down backends will not be proxied to.\n\n\nHealthChecks configures active and passive health checks.\n", + "markdownDescription": "health_checks: `object` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#HealthChecks) \nHealth checks update the status of backends, whether they are\nup or down. Down backends will not be proxied to.\n\n\nHealthChecks configures active and passive health checks. \n", + "type": "object", + "properties": { + "active": { + "description": "active: object\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#ActiveHealthChecks\nActive health checks run in the background on a timer. To\nminimally enable active health checks, set either path or\nport (or both).\n\n\nActiveHealthChecks holds configuration related to active health\nchecks (that is, health checks which occur independently in a\nbackground goroutine).\n", + "markdownDescription": "active: `object` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#ActiveHealthChecks) \nActive health checks run in the background on a timer. To\nminimally enable active health checks, set either path or\nport (or both).\n\n\nActiveHealthChecks holds configuration related to active health\nchecks (that is, health checks which occur independently in a\nbackground goroutine). \n", + "type": "object", + "properties": { + "interval": { + "description": "interval: number\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow frequently to perform active health checks (default 30s).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "interval: `number` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow frequently to perform active health checks (default 30s).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "port": { + "description": "port: number\nModule: layer4.handlers.proxy\nThe port to use (if different from the upstream's dial\naddress) for health checks.\n", + "markdownDescription": "port: `number` \nModule: `layer4.handlers.proxy` \nThe port to use (if different from the upstream's dial\naddress) for health checks. \n", + "type": "number" + }, + "timeout": { + "description": "timeout: number\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to wait for a connection to be established with\npeer before considering it unhealthy (default 5s).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "timeout: `number` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to wait for a connection to be established with\npeer before considering it unhealthy (default 5s).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + }, + "passive": { + "description": "passive: object\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#PassiveHealthChecks\nPassive health checks monitor proxied connections for errors or timeouts.\nTo minimally enable passive health checks, specify at least an empty\nconfig object.\n\n\nPassiveHealthChecks holds configuration related to passive\nhealth checks (that is, health checks which occur during\nthe normal flow of connection proxying).\n", + "markdownDescription": "passive: `object` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#PassiveHealthChecks) \nPassive health checks monitor proxied connections for errors or timeouts.\nTo minimally enable passive health checks, specify at least an empty\nconfig object.\n\n\nPassiveHealthChecks holds configuration related to passive\nhealth checks (that is, health checks which occur during\nthe normal flow of connection proxying). \n", + "type": "object", + "properties": { + "fail_duration": { + "description": "fail_duration: number\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to remember a failed connection to a backend. A\nduration \u003e 0 enables passive health checking. Default 0.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "fail_duration: `number` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to remember a failed connection to a backend. A\nduration \u003e 0 enables passive health checking. Default 0.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "max_fails": { + "description": "max_fails: number\nModule: layer4.handlers.proxy\nThe number of failed connections within the FailDuration window to\nconsider a backend as \"down\". Must be \u003e= 1; default is 1. Requires\nthat FailDuration be \u003e 0.\n", + "markdownDescription": "max_fails: `number` \nModule: `layer4.handlers.proxy` \nThe number of failed connections within the FailDuration window to\nconsider a backend as \"down\". Must be \u003e= 1; default is 1. Requires\nthat FailDuration be \u003e 0. \n", + "type": "number" + }, + "unhealthy_connnection_count": { + "description": "unhealthy_connnection_count: number\nModule: layer4.handlers.proxy\nLimits the number of simultaneous connections to a backend by\nmarking the backend as \"down\" if it has this many or more\nconcurrent connections.\n", + "markdownDescription": "unhealthy_connnection_count: `number` \nModule: `layer4.handlers.proxy` \nLimits the number of simultaneous connections to a backend by\nmarking the backend as \"down\" if it has this many or more\nconcurrent connections. \n", + "type": "number" + } + } + } + } + }, + "load_balancing": { + "description": "load_balancing: object\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#LoadBalancing\nLoad balancing distributes load/connections between backends.\n\n\nLoadBalancing has parameters related to load balancing.\n", + "markdownDescription": "load_balancing: `object` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#LoadBalancing) \nLoad balancing distributes load/connections between backends.\n\n\nLoadBalancing has parameters related to load balancing. \n", + "type": "object", + "properties": { + "selection": { + "description": "selection: object\nModule: layer4.proxy.selection_policies\nA selection policy is how to choose an available backend.\nThe default policy is random selection.\n", + "markdownDescription": "selection: `object` \nModule: `layer4.proxy.selection_policies` \nA selection policy is how to choose an available backend.\nThe default policy is random selection. \n", + "type": "object", + "required": [ + "policy" + ], + "allOf": [ + { + "if": { + "properties": { + "policy": { + "const": "random" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.proxy.selection_policies.random" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "random_choose" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.proxy.selection_policies.random_choose" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "round_robin" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.proxy.selection_policies.round_robin" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "first" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.proxy.selection_policies.first" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "ip_hash" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.proxy.selection_policies.ip_hash" + } + }, + { + "if": { + "properties": { + "policy": { + "const": "least_conn" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.proxy.selection_policies.least_conn" + } + }, + { + "properties": { + "policy": { + "description": "key to identify selection module.\npolicy: string\nModule: layer4.proxy.selection_policies", + "markdownDescription": "key to identify `selection` module. \npolicy: `string` \nModule: `layer4.proxy.selection_policies`", + "type": "string", + "enum": [ + "random", + "random_choose", + "round_robin", + "first", + "ip_hash", + "least_conn" + ] + } + } + } + ] + }, + "try_duration": { + "description": "try_duration: number\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to try selecting available backends for each connection\nif the next available host is down. By default, this retry is\ndisabled. Clients will wait for up to this long while the load\nbalancer tries to find an available upstream host.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "try_duration: `number` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to try selecting available backends for each connection\nif the next available host is down. By default, this retry is\ndisabled. Clients will wait for up to this long while the load\nbalancer tries to find an available upstream host.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "try_interval": { + "description": "try_interval: number\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to wait between selecting the next host from the pool. Default\nis 250ms. Only relevant when a connection to an upstream host fails. Be\naware that setting this to 0 with a non-zero try_duration can cause the\nCPU to spin if all backends are down and latency is very low.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "try_interval: `number` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to wait between selecting the next host from the pool. Default\nis 250ms. Only relevant when a connection to an upstream host fails. Be\naware that setting this to 0 with a non-zero try_duration can cause the\nCPU to spin if all backends are down and latency is very low.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + }, + "proxy_protocol": { + "description": "proxy_protocol: string\nModule: layer4.handlers.proxy\nSpecifies the version of the Proxy Protocol header to add, either \"v1\" or \"v2\".\nRef: https://www.haproxy.org/download/1.8/doc/proxy-protocol.txt\n", + "markdownDescription": "proxy_protocol: `string` \nModule: `layer4.handlers.proxy` \nSpecifies the version of the Proxy Protocol header to add, either \"v1\" or \"v2\".\nRef: https://www.haproxy.org/download/1.8/doc/proxy-protocol.txt \n", + "type": "string" + }, + "upstreams": { + "description": "upstreams: array\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Upstream\nUpstreams is the list of backends to proxy to.\n\n\nUpstream represents a proxy upstream.\n", + "markdownDescription": "upstreams: `array` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Upstream) \nUpstreams is the list of backends to proxy to.\n\n\nUpstream represents a proxy upstream. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Upstream\nUpstreams is the list of backends to proxy to.\n\n\nUpstream represents a proxy upstream.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Upstream) \nUpstreams is the list of backends to proxy to.\n\n\nUpstream represents a proxy upstream. \n", + "type": "object", + "properties": { + "dial": { + "description": "dial: array\nModule: layer4.handlers.proxy\nThe network addresses to dial. Supports placeholders, but not port\nranges currently (each address must be exactly 1 socket).\n", + "markdownDescription": "dial: `array` \nModule: `layer4.handlers.proxy` \nThe network addresses to dial. Supports placeholders, but not port\nranges currently (each address must be exactly 1 socket). \n", + "type": "array", + "items": { + "description": "The network addresses to dial. Supports placeholders, but not port\nranges currently (each address must be exactly 1 socket).\n", + "markdownDescription": "The network addresses to dial. Supports placeholders, but not port\nranges currently (each address must be exactly 1 socket). \n", + "type": "string" + } + }, + "max_connections": { + "description": "max_connections: number\nModule: layer4.handlers.proxy\nHow many connections this upstream is allowed to\nhave before being marked as unhealthy (if \u003e 0).\n", + "markdownDescription": "max_connections: `number` \nModule: `layer4.handlers.proxy` \nHow many connections this upstream is allowed to\nhave before being marked as unhealthy (if \u003e 0). \n", + "type": "number" + }, + "tls": { + "description": "tls: object\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#TLSConfig\nSet this field to enable TLS to the upstream.\n\n\nTLSConfig holds configuration related to the TLS configuration for the\ntransport/client.\n", + "markdownDescription": "tls: `object` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy#TLSConfig) \nSet this field to enable TLS to the upstream.\n\n\nTLSConfig holds configuration related to the TLS configuration for the\ntransport/client. \n", + "type": "object", + "properties": { + "client_certificate_automate": { + "description": "client_certificate_automate: string\nModule: layer4.handlers.proxy\nIf specified, Caddy will use and automate a client certificate\nwith this subject name.\n", + "markdownDescription": "client_certificate_automate: `string` \nModule: `layer4.handlers.proxy` \nIf specified, Caddy will use and automate a client certificate\nwith this subject name. \n", + "type": "string" + }, + "client_certificate_file": { + "description": "client_certificate_file: string\nModule: layer4.handlers.proxy\nPEM-encoded client certificate filename to present to servers.\n", + "markdownDescription": "client_certificate_file: `string` \nModule: `layer4.handlers.proxy` \nPEM-encoded client certificate filename to present to servers. \n", + "type": "string" + }, + "client_certificate_key_file": { + "description": "client_certificate_key_file: string\nModule: layer4.handlers.proxy\nPEM-encoded key to use with the client certificate.\n", + "markdownDescription": "client_certificate_key_file: `string` \nModule: `layer4.handlers.proxy` \nPEM-encoded key to use with the client certificate. \n", + "type": "string" + }, + "except_ports": { + "description": "except_ports: array\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Handler", + "markdownDescription": "except_ports: `array` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Handler)", + "type": "array", + "items": { + "type": "string" + } + }, + "handshake_timeout": { + "description": "handshake_timeout: number\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nThe duration to allow a TLS handshake to a server. Default: No timeout.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "handshake_timeout: `number` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nThe duration to allow a TLS handshake to a server. Default: No timeout.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "insecure_skip_verify": { + "description": "insecure_skip_verify: boolean\nModule: layer4.handlers.proxy\nIf true, TLS verification of server certificates will be disabled.\nThis is insecure and may be removed in the future. Do not use this\noption except in testing or local development environments.\n", + "markdownDescription": "insecure_skip_verify: `boolean` \nModule: `layer4.handlers.proxy` \nIf true, TLS verification of server certificates will be disabled.\nThis is insecure and may be removed in the future. Do not use this\noption except in testing or local development environments. \n", + "type": "boolean" + }, + "renegotiation": { + "description": "renegotiation: string\nModule: layer4.handlers.proxy\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Handler", + "markdownDescription": "renegotiation: `string` \nModule: `layer4.handlers.proxy` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#Handler)", + "type": "string" + }, + "root_ca_pem_files": { + "description": "root_ca_pem_files: array\nModule: layer4.handlers.proxy\nList of PEM-encoded CA certificate files to add to the same trust\nstore as RootCAPool (or root_ca_pool in the JSON).\n", + "markdownDescription": "root_ca_pem_files: `array` \nModule: `layer4.handlers.proxy` \nList of PEM-encoded CA certificate files to add to the same trust\nstore as RootCAPool (or root_ca_pool in the JSON). \n", + "type": "array", + "items": { + "description": "List of PEM-encoded CA certificate files to add to the same trust\nstore as RootCAPool (or root_ca_pool in the JSON).\n", + "markdownDescription": "List of PEM-encoded CA certificate files to add to the same trust\nstore as RootCAPool (or root_ca_pool in the JSON). \n", + "type": "string" + } + }, + "root_ca_pool": { + "description": "root_ca_pool: array\nModule: layer4.handlers.proxy\nOptional list of base64-encoded DER-encoded CA certificates to trust.\n", + "markdownDescription": "root_ca_pool: `array` \nModule: `layer4.handlers.proxy` \nOptional list of base64-encoded DER-encoded CA certificates to trust. \n", + "type": "array", + "items": { + "description": "Optional list of base64-encoded DER-encoded CA certificates to trust.\n", + "markdownDescription": "Optional list of base64-encoded DER-encoded CA certificates to trust. \n", + "type": "string" + } + }, + "server_name": { + "description": "server_name: string\nModule: layer4.handlers.proxy\nThe server name (SNI) to use in TLS handshakes.\n", + "markdownDescription": "server_name: `string` \nModule: `layer4.handlers.proxy` \nThe server name (SNI) to use in TLS handshakes. \n", + "type": "string" + } + } + } + } + } + } + } + }, + "layer4.handlers.proxy_protocol": { + "description": "proxy_protocol: object\nModule: layer4.handlers.proxy_protocol\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxyprotocol#Handler\nHandler is a connection handler that accepts the PROXY protocol.\n\n", + "markdownDescription": "proxy_protocol: `object` \nModule: `layer4.handlers.proxy_protocol` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxyprotocol#Handler) \nHandler is a connection handler that accepts the PROXY protocol.\n \n", + "type": "object", + "properties": { + "allow": { + "description": "allow: array\nModule: layer4.handlers.proxy_protocol\nAn optional list of CIDR ranges to allow/require PROXY headers from.\n", + "markdownDescription": "allow: `array` \nModule: `layer4.handlers.proxy_protocol` \nAn optional list of CIDR ranges to allow/require PROXY headers from. \n", + "type": "array", + "items": { + "description": "An optional list of CIDR ranges to allow/require PROXY headers from.\n", + "markdownDescription": "An optional list of CIDR ranges to allow/require PROXY headers from. \n", + "type": "string" + } + }, + "timeout": { + "description": "timeout: number\nModule: layer4.handlers.proxy_protocol\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to wait for the PROXY protocol header to be received.\nDefaults to zero, which means timeout is disabled.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "timeout: `number` \nModule: `layer4.handlers.proxy_protocol` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to wait for the PROXY protocol header to be received.\nDefaults to zero, which means timeout is disabled.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + }, + "layer4.handlers.subroute": { + "description": "subroute: object\nModule: layer4.handlers.subroute\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4subroute#Handler", + "markdownDescription": "subroute: `object` \nModule: `layer4.handlers.subroute` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4subroute#Handler)", + "type": "object", + "properties": { + "routes": { + "description": "routes: array\nModule: layer4.handlers.subroute\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4subroute#Handler", + "markdownDescription": "routes: `array` \nModule: `layer4.handlers.subroute` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4subroute#Handler)", + "type": "array", + "items": { + "type": "object", + "properties": { + "handle": { + "description": "handle: array\nModule: layer4.handlers", + "markdownDescription": "handle: `array` \nModule: `layer4.handlers`", + "type": "array", + "items": { + "required": [ + "handler" + ], + "allOf": [ + { + "if": { + "properties": { + "handler": { + "const": "echo" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.echo" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "proxy" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.proxy" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "proxy_protocol" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.proxy_protocol" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "subroute" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.subroute" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tee" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.tee" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "throttle" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.throttle" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tls" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.tls" + } + }, + { + "properties": { + "handler": { + "description": "key to identify handle module.\nhandler: string\nModule: layer4.handlers", + "markdownDescription": "key to identify `handle` module. \nhandler: `string` \nModule: `layer4.handlers`", + "type": "string", + "enum": [ + "echo", + "proxy", + "proxy_protocol", + "subroute", + "tee", + "throttle", + "tls" + ] + } + } + } + ] + } + }, + "match": { + "description": "match: array\nModule: layer4.matchers", + "markdownDescription": "match: `array` \nModule: `layer4.matchers`", + "type": "array", + "items": { + "properties": { + "http": { + "$ref": "#/definitions/layer4.matchers.http" + }, + "ip": { + "$ref": "#/definitions/layer4.matchers.ip" + }, + "proxy_protocol": { + "$ref": "#/definitions/layer4.matchers.proxy_protocol" + }, + "ssh": { + "$ref": "#/definitions/layer4.matchers.ssh" + }, + "tls": { + "$ref": "#/definitions/layer4.matchers.tls" + }, + "xmpp": { + "$ref": "#/definitions/layer4.matchers.xmpp" + } + } + } + } + } + } + } + } + }, + "layer4.handlers.tee": { + "description": "tee: object\nModule: layer4.handlers.tee\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4tee#Handler\nHandler is a layer4 handler that replicates a connection so\nthat a branch of handlers can concurrently handle it. Reads\nhappen in lock-step with all concurrent branches so as to\navoid buffering: if one of the branches (including the main\nhandler chain) stops reading from the connection, it will\nblock all branches.\n\n", + "markdownDescription": "tee: `object` \nModule: `layer4.handlers.tee` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4tee#Handler) \nHandler is a layer4 handler that replicates a connection so\nthat a branch of handlers can concurrently handle it. Reads\nhappen in lock-step with all concurrent branches so as to\navoid buffering: if one of the branches (including the main\nhandler chain) stops reading from the connection, it will\nblock all branches.\n \n", + "type": "object", + "properties": { + "branch": { + "description": "branch: array\nModule: layer4.handlers\nHandlers is the list of handlers that constitute this\nconcurrent branch. Any handlers that do connection\nmatching (which involves recording and rewinding the\nstream) are unsafe to tee, so do all connection\nmatching before teeing.\n", + "markdownDescription": "branch: `array` \nModule: `layer4.handlers` \nHandlers is the list of handlers that constitute this\nconcurrent branch. Any handlers that do connection\nmatching (which involves recording and rewinding the\nstream) are unsafe to tee, so do all connection\nmatching before teeing. \n", + "type": "array", + "items": { + "description": "Handlers is the list of handlers that constitute this\nconcurrent branch. Any handlers that do connection\nmatching (which involves recording and rewinding the\nstream) are unsafe to tee, so do all connection\nmatching before teeing.\n", + "markdownDescription": "Handlers is the list of handlers that constitute this\nconcurrent branch. Any handlers that do connection\nmatching (which involves recording and rewinding the\nstream) are unsafe to tee, so do all connection\nmatching before teeing. \n", + "required": [ + "handler" + ], + "allOf": [ + { + "if": { + "properties": { + "handler": { + "const": "subroute" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.subroute" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tee" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.tee" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "throttle" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.throttle" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "tls" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.tls" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "echo" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.echo" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "proxy" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.proxy" + } + }, + { + "if": { + "properties": { + "handler": { + "const": "proxy_protocol" + } + } + }, + "then": { + "$ref": "#/definitions/layer4.handlers.proxy_protocol" + } + }, + { + "properties": { + "handler": { + "description": "key to identify branch module.\nhandler: string\nModule: layer4.handlers", + "markdownDescription": "key to identify `branch` module. \nhandler: `string` \nModule: `layer4.handlers`", + "type": "string", + "enum": [ + "subroute", + "tee", + "throttle", + "tls", + "echo", + "proxy", + "proxy_protocol" + ] + } + } + } + ] + } + } + } + }, + "layer4.handlers.throttle": { + "description": "throttle: object\nModule: layer4.handlers.throttle\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4throttle#Handler\nHandler throttles connections using leaky bucket rate limiting.\n\n", + "markdownDescription": "throttle: `object` \nModule: `layer4.handlers.throttle` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4throttle#Handler) \nHandler throttles connections using leaky bucket rate limiting.\n \n", + "type": "object", + "properties": { + "latency": { + "description": "latency: number\nModule: layer4.handlers.throttle\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nDelay before initial read on each connection.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "latency: `number` \nModule: `layer4.handlers.throttle` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nDelay before initial read on each connection.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "read_burst_size": { + "description": "read_burst_size: number\nModule: layer4.handlers.throttle\nThe maximum number of bytes to read at once (rate permitting) per connection.\nIf a rate is specified, burst must be greater than zero; default is same as\nthe rate (truncated to integer).\n", + "markdownDescription": "read_burst_size: `number` \nModule: `layer4.handlers.throttle` \nThe maximum number of bytes to read at once (rate permitting) per connection.\nIf a rate is specified, burst must be greater than zero; default is same as\nthe rate (truncated to integer). \n", + "type": "number" + }, + "read_bytes_per_second": { + "description": "read_bytes_per_second: object\nModule: layer4.handlers.throttle\nThe number of bytes to read per second, per connection.\n", + "markdownDescription": "read_bytes_per_second: `object` \nModule: `layer4.handlers.throttle` \nThe number of bytes to read per second, per connection. \n", + "type": "object" + }, + "total_read_burst_size": { + "description": "total_read_burst_size: number\nModule: layer4.handlers.throttle\nThe maximum number of bytes to read at once (rate permitting) across all\nconnections (\"per handler\"). If a rate is specified, burst must be greater\nthan zero; default is same as the rate (truncated to integer).\n", + "markdownDescription": "total_read_burst_size: `number` \nModule: `layer4.handlers.throttle` \nThe maximum number of bytes to read at once (rate permitting) across all\nconnections (\"per handler\"). If a rate is specified, burst must be greater\nthan zero; default is same as the rate (truncated to integer). \n", + "type": "number" + }, + "total_read_bytes_per_second": { + "description": "total_read_bytes_per_second: object\nModule: layer4.handlers.throttle\nThe number of bytes to read per second, across all connections (\"per handler\").\n", + "markdownDescription": "total_read_bytes_per_second: `object` \nModule: `layer4.handlers.throttle` \nThe number of bytes to read per second, across all connections (\"per handler\"). \n", + "type": "object" + } + } + }, + "layer4.handlers.tls": { + "description": "tls: object\nModule: layer4.handlers.tls\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4tls#Handler\nHandler is a connection handler that terminates TLS.\n\n", + "markdownDescription": "tls: `object` \nModule: `layer4.handlers.tls` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4tls#Handler) \nHandler is a connection handler that terminates TLS.\n \n", + "type": "object", + "properties": { + "connection_policies": { + "description": "connection_policies: array\nModule: layer4.handlers.tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ConnectionPolicy\nConnectionPolicy specifies the logic for handling a TLS handshake.\nAn empty policy is valid; safe and sensible defaults will be used.\n\n", + "markdownDescription": "connection_policies: `array` \nModule: `layer4.handlers.tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ConnectionPolicy) \nConnectionPolicy specifies the logic for handling a TLS handshake.\nAn empty policy is valid; safe and sensible defaults will be used.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ConnectionPolicy\nConnectionPolicy specifies the logic for handling a TLS handshake.\nAn empty policy is valid; safe and sensible defaults will be used.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ConnectionPolicy) \nConnectionPolicy specifies the logic for handling a TLS handshake.\nAn empty policy is valid; safe and sensible defaults will be used.\n \n", + "type": "object", + "properties": { + "alpn": { + "description": "alpn: array\nModule: layer4.handlers.tls\nProtocols to use for Application-Layer Protocol\nNegotiation (ALPN) during the handshake.\n", + "markdownDescription": "alpn: `array` \nModule: `layer4.handlers.tls` \nProtocols to use for Application-Layer Protocol\nNegotiation (ALPN) during the handshake. \n", + "type": "array", + "items": { + "description": "Protocols to use for Application-Layer Protocol\nNegotiation (ALPN) during the handshake.\n", + "markdownDescription": "Protocols to use for Application-Layer Protocol\nNegotiation (ALPN) during the handshake. \n", + "type": "string" + } + }, + "certificate_selection": { + "description": "certificate_selection: object\nModule: layer4.handlers.tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CustomCertSelectionPolicy\nHow to choose a certificate if more than one matched\nthe given ServerName (SNI) value.\n\n\nCustomCertSelectionPolicy represents a policy for selecting the certificate\nused to complete a handshake when there may be multiple options. All fields\nspecified must match the candidate certificate for it to be chosen.\nThis was needed to solve https://github.com/caddyserver/caddy/issues/2588.\n", + "markdownDescription": "certificate_selection: `object` \nModule: `layer4.handlers.tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CustomCertSelectionPolicy) \nHow to choose a certificate if more than one matched\nthe given ServerName (SNI) value.\n\n\nCustomCertSelectionPolicy represents a policy for selecting the certificate\nused to complete a handshake when there may be multiple options. All fields\nspecified must match the candidate certificate for it to be chosen.\nThis was needed to solve https://github.com/caddyserver/caddy/issues/2588. \n", + "type": "object", + "properties": { + "all_tags": { + "description": "all_tags: array\nModule: layer4.handlers.tls\nThe certificate must have all of the tags in the list.\n", + "markdownDescription": "all_tags: `array` \nModule: `layer4.handlers.tls` \nThe certificate must have all of the tags in the list. \n", + "type": "array", + "items": { + "description": "The certificate must have all of the tags in the list.\n", + "markdownDescription": "The certificate must have all of the tags in the list. \n", + "type": "string" + } + }, + "any_tag": { + "description": "any_tag: array\nModule: layer4.handlers.tls\nThe certificate must have at least one of the tags in the list.\n", + "markdownDescription": "any_tag: `array` \nModule: `layer4.handlers.tls` \nThe certificate must have at least one of the tags in the list. \n", + "type": "array", + "items": { + "description": "The certificate must have at least one of the tags in the list.\n", + "markdownDescription": "The certificate must have at least one of the tags in the list. \n", + "type": "string" + } + }, + "public_key_algorithm": { + "description": "public_key_algorithm: number\nModule: layer4.handlers.tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#PublicKeyAlgorithm\nThe certificate must use this public key algorithm.\n\n\nPublicKeyAlgorithm is a JSON-unmarshalable wrapper type.\n", + "markdownDescription": "public_key_algorithm: `number` \nModule: `layer4.handlers.tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#PublicKeyAlgorithm) \nThe certificate must use this public key algorithm.\n\n\nPublicKeyAlgorithm is a JSON-unmarshalable wrapper type. \n", + "type": "number" + }, + "serial_number": { + "description": "serial_number: array\nModule: layer4.handlers.tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#bigInt\nThe certificate must have one of these serial numbers.\n\n\nbigInt is a big.Int type that interops with JSON encodings as a string.\n", + "markdownDescription": "serial_number: `array` \nModule: `layer4.handlers.tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#bigInt) \nThe certificate must have one of these serial numbers.\n\n\nbigInt is a big.Int type that interops with JSON encodings as a string. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#bigInt\nThe certificate must have one of these serial numbers.\n\n\nbigInt is a big.Int type that interops with JSON encodings as a string.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#bigInt) \nThe certificate must have one of these serial numbers.\n\n\nbigInt is a big.Int type that interops with JSON encodings as a string. \n", + "type": "object" + } + }, + "subject_organization": { + "description": "subject_organization: array\nModule: layer4.handlers.tls\nThe certificate must have one of these organization names.\n", + "markdownDescription": "subject_organization: `array` \nModule: `layer4.handlers.tls` \nThe certificate must have one of these organization names. \n", + "type": "array", + "items": { + "description": "The certificate must have one of these organization names.\n", + "markdownDescription": "The certificate must have one of these organization names. \n", + "type": "string" + } + } + } + }, + "cipher_suites": { + "description": "cipher_suites: array\nModule: layer4.handlers.tls\nThe list of cipher suites to support. Caddy's\ndefaults are modern and secure.\n", + "markdownDescription": "cipher_suites: `array` \nModule: `layer4.handlers.tls` \nThe list of cipher suites to support. Caddy's\ndefaults are modern and secure. \n", + "type": "array", + "items": { + "description": "The list of cipher suites to support. Caddy's\ndefaults are modern and secure.\n", + "markdownDescription": "The list of cipher suites to support. Caddy's\ndefaults are modern and secure. \n", + "type": "string" + } + }, + "client_authentication": { + "description": "client_authentication: object\nModule: layer4.handlers.tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ClientAuthentication\nEnables and configures TLS client authentication.\n\n\nClientAuthentication configures TLS client auth.\n", + "markdownDescription": "client_authentication: `object` \nModule: `layer4.handlers.tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ClientAuthentication) \nEnables and configures TLS client authentication.\n\n\nClientAuthentication configures TLS client auth. \n", + "type": "object", + "properties": { + "mode": { + "description": "mode: string\nModule: layer4.handlers.tls\nThe mode for authenticating the client. Allowed values are:\n\nMode | Description\n-----|---------------\n`request` | Ask clients for a certificate, but allow even if there isn't one; do not verify it\n`require` | Require clients to present a certificate, but do not verify it\n`verify_if_given` | Ask clients for a certificate; allow even if there isn't one, but verify it if there is\n`require_and_verify` | Require clients to present a valid certificate that is verified\n\nThe default mode is `require_and_verify` if any\nTrustedCACerts or TrustedCACertPEMFiles or TrustedLeafCerts\nare provided; otherwise, the default mode is `require`.\n", + "markdownDescription": "mode: `string` \nModule: `layer4.handlers.tls` \nThe mode for authenticating the client. Allowed values are:\n\nMode | Description\n-----|---------------\n`request` | Ask clients for a certificate, but allow even if there isn't one; do not verify it\n`require` | Require clients to present a certificate, but do not verify it\n`verify_if_given` | Ask clients for a certificate; allow even if there isn't one, but verify it if there is\n`require_and_verify` | Require clients to present a valid certificate that is verified\n\nThe default mode is `require_and_verify` if any\nTrustedCACerts or TrustedCACertPEMFiles or TrustedLeafCerts\nare provided; otherwise, the default mode is `require`. \n", + "type": "string" + }, + "trusted_ca_certs": { + "description": "trusted_ca_certs: array\nModule: layer4.handlers.tls\nA list of base64 DER-encoded CA certificates\nagainst which to validate client certificates.\nClient certs which are not signed by any of\nthese CAs will be rejected.\n", + "markdownDescription": "trusted_ca_certs: `array` \nModule: `layer4.handlers.tls` \nA list of base64 DER-encoded CA certificates\nagainst which to validate client certificates.\nClient certs which are not signed by any of\nthese CAs will be rejected. \n", + "type": "array", + "items": { + "description": "A list of base64 DER-encoded CA certificates\nagainst which to validate client certificates.\nClient certs which are not signed by any of\nthese CAs will be rejected.\n", + "markdownDescription": "A list of base64 DER-encoded CA certificates\nagainst which to validate client certificates.\nClient certs which are not signed by any of\nthese CAs will be rejected. \n", + "type": "string" + } + }, + "trusted_ca_certs_pem_files": { + "description": "trusted_ca_certs_pem_files: array\nModule: layer4.handlers.tls\nTrustedCACertPEMFiles is a list of PEM file names\nfrom which to load certificates of trusted CAs.\nClient certificates which are not signed by any of\nthese CA certificates will be rejected.\n", + "markdownDescription": "trusted_ca_certs_pem_files: `array` \nModule: `layer4.handlers.tls` \nTrustedCACertPEMFiles is a list of PEM file names\nfrom which to load certificates of trusted CAs.\nClient certificates which are not signed by any of\nthese CA certificates will be rejected. \n", + "type": "array", + "items": { + "description": "TrustedCACertPEMFiles is a list of PEM file names\nfrom which to load certificates of trusted CAs.\nClient certificates which are not signed by any of\nthese CA certificates will be rejected.\n", + "markdownDescription": "TrustedCACertPEMFiles is a list of PEM file names\nfrom which to load certificates of trusted CAs.\nClient certificates which are not signed by any of\nthese CA certificates will be rejected. \n", + "type": "string" + } + }, + "trusted_leaf_certs": { + "description": "trusted_leaf_certs: array\nModule: layer4.handlers.tls\nA list of base64 DER-encoded client leaf certs\nto accept. If this list is not empty, client certs\nwhich are not in this list will be rejected.\n", + "markdownDescription": "trusted_leaf_certs: `array` \nModule: `layer4.handlers.tls` \nA list of base64 DER-encoded client leaf certs\nto accept. If this list is not empty, client certs\nwhich are not in this list will be rejected. \n", + "type": "array", + "items": { + "description": "A list of base64 DER-encoded client leaf certs\nto accept. If this list is not empty, client certs\nwhich are not in this list will be rejected.\n", + "markdownDescription": "A list of base64 DER-encoded client leaf certs\nto accept. If this list is not empty, client certs\nwhich are not in this list will be rejected. \n", + "type": "string" + } + }, + "verifiers": { + "description": "verifiers: array\nModule: tls.client_auth", + "markdownDescription": "verifiers: `array` \nModule: `tls.client_auth`", + "type": "array", + "items": { + "required": [ + "verifier" + ], + "allOf": [ + { + "if": { + "properties": { + "verifier": { + "const": "leaf" + } + } + }, + "then": { + "$ref": "#/definitions/tls.client_auth.leaf" + } + }, + { + "properties": { + "verifier": { + "description": "key to identify verifiers module.\nverifier: string\nModule: tls.client_auth", + "markdownDescription": "key to identify `verifiers` module. \nverifier: `string` \nModule: `tls.client_auth`", + "type": "string", + "enum": [ + "leaf" + ] + } + } + } + ] + } + } + } + }, + "curves": { + "description": "curves: array\nModule: layer4.handlers.tls\nThe list of elliptic curves to support. Caddy's\ndefaults are modern and secure.\n", + "markdownDescription": "curves: `array` \nModule: `layer4.handlers.tls` \nThe list of elliptic curves to support. Caddy's\ndefaults are modern and secure. \n", + "type": "array", + "items": { + "description": "The list of elliptic curves to support. Caddy's\ndefaults are modern and secure.\n", + "markdownDescription": "The list of elliptic curves to support. Caddy's\ndefaults are modern and secure. \n", + "type": "string" + } + }, + "default_sni": { + "description": "default_sni: string\nModule: layer4.handlers.tls\nDefaultSNI becomes the ServerName in a ClientHello if there\nis no policy configured for the empty SNI value.\n", + "markdownDescription": "default_sni: `string` \nModule: `layer4.handlers.tls` \nDefaultSNI becomes the ServerName in a ClientHello if there\nis no policy configured for the empty SNI value. \n", + "type": "string" + }, + "match": { + "description": "match: object\nModule: tls.handshake_match\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nHow to match this policy with a TLS ClientHello. If\nthis policy is the first to match, it will be used.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "match: `object` \nModule: `tls.handshake_match` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nHow to match this policy with a TLS ClientHello. If\nthis policy is the first to match, it will be used.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "object", + "properties": { + "alpn": { + "$ref": "#/definitions/tls.handshake_match.alpn" + }, + "remote_ip": { + "$ref": "#/definitions/tls.handshake_match.remote_ip" + }, + "sni": { + "$ref": "#/definitions/tls.handshake_match.sni" + } + } + }, + "protocol_max": { + "description": "protocol_max: string\nModule: layer4.handlers.tls\nMaximum TLS protocol version to allow. Default: `tls1.3`\n", + "markdownDescription": "protocol_max: `string` \nModule: `layer4.handlers.tls` \nMaximum TLS protocol version to allow. Default: `tls1.3` \n", + "type": "string" + }, + "protocol_min": { + "description": "protocol_min: string\nModule: layer4.handlers.tls\nMinimum TLS protocol version to allow. Default: `tls1.2`\n", + "markdownDescription": "protocol_min: `string` \nModule: `layer4.handlers.tls` \nMinimum TLS protocol version to allow. Default: `tls1.2` \n", + "type": "string" + } + } + } + } + } + }, + "layer4.matchers.http": { + "description": "http: any\nModule: layer4.matchers.http\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4http#MatchHTTP\nMatchHTTP is able to match HTTP connections. The auto-generated\ndocumentation for this type is wrong; instead of an object, it\nis an array of matcher set objects.\n\n", + "markdownDescription": "http: `any` \nModule: `layer4.matchers.http` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4http#MatchHTTP) \nMatchHTTP is able to match HTTP connections. The auto-generated\ndocumentation for this type is wrong; instead of an object, it\nis an array of matcher set objects.\n \n" + }, + "layer4.matchers.ip": { + "description": "ip: object\nModule: layer4.matchers.ip\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/layer4#MatchIP\nMatchIP matches requests by remote IP (or CIDR range).\n\n", + "markdownDescription": "ip: `object` \nModule: `layer4.matchers.ip` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/layer4#MatchIP) \nMatchIP matches requests by remote IP (or CIDR range).\n \n", + "type": "object", + "properties": { + "ranges": { + "description": "ranges: array\nModule: layer4.matchers.ip\n", + "markdownDescription": "ranges: `array` \nModule: `layer4.matchers.ip` \n", + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "layer4.matchers.proxy_protocol": { + "description": "proxy_protocol: object\nModule: layer4.matchers.proxy_protocol\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxyprotocol#MatchProxyProtocol", + "markdownDescription": "proxy_protocol: `object` \nModule: `layer4.matchers.proxy_protocol` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxyprotocol#MatchProxyProtocol)", + "type": "object" + }, + "layer4.matchers.ssh": { + "description": "ssh: object\nModule: layer4.matchers.ssh\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4ssh#MatchSSH\nMatchSSH is able to match SSH connections.\n\n", + "markdownDescription": "ssh: `object` \nModule: `layer4.matchers.ssh` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4ssh#MatchSSH) \nMatchSSH is able to match SSH connections.\n \n", + "type": "object" + }, + "layer4.matchers.tls": { + "description": "tls: any\nModule: layer4.matchers.tls\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4tls#MatchTLS\nMatchTLS is able to match TLS connections. Its structure\nis different from the auto-generated documentation. This\nvalue should be a map of matcher names to their values.\n\n", + "markdownDescription": "tls: `any` \nModule: `layer4.matchers.tls` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4tls#MatchTLS) \nMatchTLS is able to match TLS connections. Its structure\nis different from the auto-generated documentation. This\nvalue should be a map of matcher names to their values.\n \n" + }, + "layer4.matchers.xmpp": { + "description": "xmpp: object\nModule: layer4.matchers.xmpp\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4xmpp#MatchXMPP\nMatchXMPP is able to match XMPP connections.\n\n", + "markdownDescription": "xmpp: `object` \nModule: `layer4.matchers.xmpp` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4xmpp#MatchXMPP) \nMatchXMPP is able to match XMPP connections.\n \n", + "type": "object" + }, + "layer4.proxy.selection_policies.first": { + "description": "first: object\nModule: layer4.proxy.selection_policies.first\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#FirstSelection", + "markdownDescription": "first: `object` \nModule: `layer4.proxy.selection_policies.first` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#FirstSelection)", + "type": "object" + }, + "layer4.proxy.selection_policies.ip_hash": { + "description": "ip_hash: object\nModule: layer4.proxy.selection_policies.ip_hash\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#IPHashSelection", + "markdownDescription": "ip_hash: `object` \nModule: `layer4.proxy.selection_policies.ip_hash` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#IPHashSelection)", + "type": "object" + }, + "layer4.proxy.selection_policies.least_conn": { + "description": "least_conn: object\nModule: layer4.proxy.selection_policies.least_conn\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#LeastConnSelection", + "markdownDescription": "least_conn: `object` \nModule: `layer4.proxy.selection_policies.least_conn` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#LeastConnSelection)", + "type": "object" + }, + "layer4.proxy.selection_policies.random": { + "description": "random: object\nModule: layer4.proxy.selection_policies.random\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#RandomSelection", + "markdownDescription": "random: `object` \nModule: `layer4.proxy.selection_policies.random` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#RandomSelection)", + "type": "object" + }, + "layer4.proxy.selection_policies.random_choose": { + "description": "random_choose: object\nModule: layer4.proxy.selection_policies.random_choose\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#RandomChoiceSelection", + "markdownDescription": "random_choose: `object` \nModule: `layer4.proxy.selection_policies.random_choose` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#RandomChoiceSelection)", + "type": "object", + "properties": { + "choose": { + "description": "choose: number\nModule: layer4.proxy.selection_policies.random_choose\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#RandomChoiceSelection", + "markdownDescription": "choose: `number` \nModule: `layer4.proxy.selection_policies.random_choose` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#RandomChoiceSelection)", + "type": "number" + } + } + }, + "layer4.proxy.selection_policies.round_robin": { + "description": "round_robin: object\nModule: layer4.proxy.selection_policies.round_robin\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#RoundRobinSelection", + "markdownDescription": "round_robin: `object` \nModule: `layer4.proxy.selection_policies.round_robin` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4proxy#RoundRobinSelection)", + "type": "object" + }, + "pki": { + "description": "pki: object\nModule: pki\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#PKI\nPKI provides Public Key Infrastructure facilities for Caddy.\n\nThis app can define certificate authorities (CAs) which are capable\nof signing certificates. Other modules can be configured to use\nthe CAs defined by this app for issuing certificates or getting\nkey information needed for establishing trust.\n\n", + "markdownDescription": "pki: `object` \nModule: `pki` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#PKI) \nPKI provides Public Key Infrastructure facilities for Caddy.\n\nThis app can define certificate authorities (CAs) which are capable\nof signing certificates. Other modules can be configured to use\nthe CAs defined by this app for issuing certificates or getting\nkey information needed for establishing trust.\n \n", + "type": "object", + "properties": { + "certificate_authorities": { + "description": "certificate_authorities: object\nModule: pki\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#CA\nThe certificate authorities to manage. Each CA is keyed by an\nID that is used to uniquely identify it from other CAs.\nAt runtime, the GetCA() method should be used instead to ensure\nthe default CA is provisioned if it hadn't already been.\nThe default CA ID is \"local\".\n\n\nCA describes a certificate authority, which consists of\nroot/signing certificates and various settings pertaining\nto the issuance of certificates and trusting them.\n", + "markdownDescription": "certificate_authorities: `object` \nModule: `pki` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#CA) \nThe certificate authorities to manage. Each CA is keyed by an\nID that is used to uniquely identify it from other CAs.\nAt runtime, the GetCA() method should be used instead to ensure\nthe default CA is provisioned if it hadn't already been.\nThe default CA ID is \"local\".\n\n\nCA describes a certificate authority, which consists of\nroot/signing certificates and various settings pertaining\nto the issuance of certificates and trusting them. \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#CA\nThe certificate authorities to manage. Each CA is keyed by an\nID that is used to uniquely identify it from other CAs.\nAt runtime, the GetCA() method should be used instead to ensure\nthe default CA is provisioned if it hadn't already been.\nThe default CA ID is \"local\".\n\n\nCA describes a certificate authority, which consists of\nroot/signing certificates and various settings pertaining\nto the issuance of certificates and trusting them.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#CA) \nThe certificate authorities to manage. Each CA is keyed by an\nID that is used to uniquely identify it from other CAs.\nAt runtime, the GetCA() method should be used instead to ensure\nthe default CA is provisioned if it hadn't already been.\nThe default CA ID is \"local\".\n\n\nCA describes a certificate authority, which consists of\nroot/signing certificates and various settings pertaining\nto the issuance of certificates and trusting them. \n", + "properties": { + "install_trust": { + "description": "install_trust: boolean\nModule: pki\nWhether Caddy will attempt to install the CA's root\ninto the system trust store, as well as into Java\nand Mozilla Firefox trust stores. Default: true.\n", + "markdownDescription": "install_trust: `boolean` \nModule: `pki` \nWhether Caddy will attempt to install the CA's root\ninto the system trust store, as well as into Java\nand Mozilla Firefox trust stores. Default: true. \n", + "type": "boolean" + }, + "intermediate": { + "description": "intermediate: object\nModule: pki\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#KeyPair\nThe intermediate (signing) certificate; if null, one will be generated.\n\n\nKeyPair represents a public-private key pair, where the\npublic key is also called a certificate.\n", + "markdownDescription": "intermediate: `object` \nModule: `pki` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#KeyPair) \nThe intermediate (signing) certificate; if null, one will be generated.\n\n\nKeyPair represents a public-private key pair, where the\npublic key is also called a certificate. \n", + "type": "object", + "properties": { + "certificate": { + "description": "certificate: string\nModule: pki\nThe certificate. By default, this should be the path to\na PEM file unless format is something else.\n", + "markdownDescription": "certificate: `string` \nModule: `pki` \nThe certificate. By default, this should be the path to\na PEM file unless format is something else. \n", + "type": "string" + }, + "format": { + "description": "format: string\nModule: pki\nThe format in which the certificate and private\nkey are provided. Default: pem_file\n", + "markdownDescription": "format: `string` \nModule: `pki` \nThe format in which the certificate and private\nkey are provided. Default: pem_file \n", + "type": "string" + }, + "private_key": { + "description": "private_key: string\nModule: pki\nThe private key. By default, this should be the path to\na PEM file unless format is something else.\n", + "markdownDescription": "private_key: `string` \nModule: `pki` \nThe private key. By default, this should be the path to\na PEM file unless format is something else. \n", + "type": "string" + } + } + }, + "intermediate_common_name": { + "description": "intermediate_common_name: string\nModule: pki\nThe name to put in the CommonName field of the\nintermediate certificates.\n", + "markdownDescription": "intermediate_common_name: `string` \nModule: `pki` \nThe name to put in the CommonName field of the\nintermediate certificates. \n", + "type": "string" + }, + "name": { + "description": "name: string\nModule: pki\nThe user-facing name of the certificate authority.\n", + "markdownDescription": "name: `string` \nModule: `pki` \nThe user-facing name of the certificate authority. \n", + "type": "string" + }, + "root": { + "description": "root: object\nModule: pki\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#KeyPair\nThe root certificate to use; if null, one will be generated.\n\n\nKeyPair represents a public-private key pair, where the\npublic key is also called a certificate.\n", + "markdownDescription": "root: `object` \nModule: `pki` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddypki#KeyPair) \nThe root certificate to use; if null, one will be generated.\n\n\nKeyPair represents a public-private key pair, where the\npublic key is also called a certificate. \n", + "type": "object", + "properties": { + "certificate": { + "description": "certificate: string\nModule: pki\nThe certificate. By default, this should be the path to\na PEM file unless format is something else.\n", + "markdownDescription": "certificate: `string` \nModule: `pki` \nThe certificate. By default, this should be the path to\na PEM file unless format is something else. \n", + "type": "string" + }, + "format": { + "description": "format: string\nModule: pki\nThe format in which the certificate and private\nkey are provided. Default: pem_file\n", + "markdownDescription": "format: `string` \nModule: `pki` \nThe format in which the certificate and private\nkey are provided. Default: pem_file \n", + "type": "string" + }, + "private_key": { + "description": "private_key: string\nModule: pki\nThe private key. By default, this should be the path to\na PEM file unless format is something else.\n", + "markdownDescription": "private_key: `string` \nModule: `pki` \nThe private key. By default, this should be the path to\na PEM file unless format is something else. \n", + "type": "string" + } + } + }, + "root_common_name": { + "description": "root_common_name: string\nModule: pki\nThe name to put in the CommonName field of the\nroot certificate.\n", + "markdownDescription": "root_common_name: `string` \nModule: `pki` \nThe name to put in the CommonName field of the\nroot certificate. \n", + "type": "string" + }, + "storage": { + "description": "storage: object\nModule: caddy.storage\nOptionally configure a separate storage module associated with this\nissuer, instead of using Caddy's global/default-configured storage.\nThis can be useful if you want to keep your signing keys in a\nseparate location from your leaf certificates.\n", + "markdownDescription": "storage: `object` \nModule: `caddy.storage` \nOptionally configure a separate storage module associated with this\nissuer, instead of using Caddy's global/default-configured storage.\nThis can be useful if you want to keep your signing keys in a\nseparate location from your leaf certificates. \n", + "type": "object", + "required": [ + "module" + ], + "allOf": [ + { + "if": { + "properties": { + "module": { + "const": "consul" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.storage.consul" + } + }, + { + "if": { + "properties": { + "module": { + "const": "file_system" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.storage.file_system" + } + }, + { + "properties": { + "module": { + "description": "key to identify storage module.\nmodule: string\nModule: caddy.storage", + "markdownDescription": "key to identify `storage` module. \nmodule: `string` \nModule: `caddy.storage`", + "type": "string", + "enum": [ + "consul", + "file_system" + ] + } + } + } + ] + } + } + } + } + } + }, + "tls": { + "description": "tls: object\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#TLS\nTLS provides TLS facilities including certificate\nloading and management, client auth, and more.\n\n", + "markdownDescription": "tls: `object` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#TLS) \nTLS provides TLS facilities including certificate\nloading and management, client auth, and more.\n \n", + "type": "object", + "properties": { + "automation": { + "description": "automation: object\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#AutomationConfig\nConfigures certificate automation.\n\n\nAutomationConfig governs the automated management of TLS certificates.\n", + "markdownDescription": "automation: `object` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#AutomationConfig) \nConfigures certificate automation.\n\n\nAutomationConfig governs the automated management of TLS certificates. \n", + "type": "object", + "properties": { + "ocsp_interval": { + "description": "ocsp_interval: number\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nCaddy staples OCSP (and caches the response) for all\nqualifying certificates by default. This setting\nchanges how often it scans responses for freshness,\nand updates them if they are getting stale. Default: 1h\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "ocsp_interval: `number` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nCaddy staples OCSP (and caches the response) for all\nqualifying certificates by default. This setting\nchanges how often it scans responses for freshness,\nand updates them if they are getting stale. Default: 1h\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "on_demand": { + "description": "on_demand: object\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#OnDemandConfig\nOn-Demand TLS defers certificate operations to the\nmoment they are needed, e.g. during a TLS handshake.\nUseful when you don't know all the hostnames at\nconfig-time, or when you are not in control of the\ndomain names you are managing certificates for.\nIn 2015, Caddy became the first web server to\nimplement this experimental technology.\n\nNote that this field does not enable on-demand TLS;\nit only configures it for when it is used. To enable\nit, create an automation policy with `on_demand`.\n\n\nOnDemandConfig configures on-demand TLS, for obtaining\nneeded certificates at handshake-time. Because this\nfeature can easily be abused, you should use this to\nestablish rate limits and/or an internal endpoint that\nCaddy can \"ask\" if it should be allowed to manage\ncertificates for a given hostname.\n", + "markdownDescription": "on_demand: `object` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#OnDemandConfig) \nOn-Demand TLS defers certificate operations to the\nmoment they are needed, e.g. during a TLS handshake.\nUseful when you don't know all the hostnames at\nconfig-time, or when you are not in control of the\ndomain names you are managing certificates for.\nIn 2015, Caddy became the first web server to\nimplement this experimental technology.\n\nNote that this field does not enable on-demand TLS;\nit only configures it for when it is used. To enable\nit, create an automation policy with `on_demand`.\n\n\nOnDemandConfig configures on-demand TLS, for obtaining\nneeded certificates at handshake-time. Because this\nfeature can easily be abused, you should use this to\nestablish rate limits and/or an internal endpoint that\nCaddy can \"ask\" if it should be allowed to manage\ncertificates for a given hostname. \n", + "type": "object", + "properties": { + "ask": { + "description": "ask: string\nModule: tls\nIf Caddy needs to obtain or renew a certificate\nduring a TLS handshake, it will perform a quick\nHTTP request to this URL to check if it should be\nallowed to try to get a certificate for the name\nin the \"domain\" query string parameter, like so:\n`?domain=example.com`. The endpoint must return a\n200 OK status if a certificate is allowed;\nanything else will cause it to be denied.\nRedirects are not followed.\n", + "markdownDescription": "ask: `string` \nModule: `tls` \nIf Caddy needs to obtain or renew a certificate\nduring a TLS handshake, it will perform a quick\nHTTP request to this URL to check if it should be\nallowed to try to get a certificate for the name\nin the \"domain\" query string parameter, like so:\n`?domain=example.com`. The endpoint must return a\n200 OK status if a certificate is allowed;\nanything else will cause it to be denied.\nRedirects are not followed. \n", + "type": "string" + }, + "rate_limit": { + "description": "rate_limit: object\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#RateLimit\nAn optional rate limit to throttle the\nissuance of certificates from handshakes.\n\n\nRateLimit specifies an interval with optional burst size.\n", + "markdownDescription": "rate_limit: `object` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#RateLimit) \nAn optional rate limit to throttle the\nissuance of certificates from handshakes.\n\n\nRateLimit specifies an interval with optional burst size. \n", + "type": "object", + "properties": { + "burst": { + "description": "burst: number\nModule: tls\nHow many times during an interval a certificate can be obtained.\n", + "markdownDescription": "burst: `number` \nModule: `tls` \nHow many times during an interval a certificate can be obtained. \n", + "type": "number" + }, + "interval": { + "description": "interval: number\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nA duration value. A certificate may be obtained 'burst'\ntimes during this interval.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "interval: `number` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nA duration value. A certificate may be obtained 'burst'\ntimes during this interval.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + } + } + }, + "policies": { + "description": "policies: array\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#AutomationPolicy\nThe list of automation policies. The first policy matching\na certificate or subject name will be applied.\n\n\nAutomationPolicy designates the policy for automating the\nmanagement (obtaining, renewal, and revocation) of managed\nTLS certificates.\n\nAn AutomationPolicy value is not valid until it has been\nprovisioned; use the `AddAutomationPolicy()` method on the\nTLS app to properly provision a new policy.\n", + "markdownDescription": "policies: `array` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#AutomationPolicy) \nThe list of automation policies. The first policy matching\na certificate or subject name will be applied.\n\n\nAutomationPolicy designates the policy for automating the\nmanagement (obtaining, renewal, and revocation) of managed\nTLS certificates.\n\nAn AutomationPolicy value is not valid until it has been\nprovisioned; use the `AddAutomationPolicy()` method on the\nTLS app to properly provision a new policy. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#AutomationPolicy\nThe list of automation policies. The first policy matching\na certificate or subject name will be applied.\n\n\nAutomationPolicy designates the policy for automating the\nmanagement (obtaining, renewal, and revocation) of managed\nTLS certificates.\n\nAn AutomationPolicy value is not valid until it has been\nprovisioned; use the `AddAutomationPolicy()` method on the\nTLS app to properly provision a new policy.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#AutomationPolicy) \nThe list of automation policies. The first policy matching\na certificate or subject name will be applied.\n\n\nAutomationPolicy designates the policy for automating the\nmanagement (obtaining, renewal, and revocation) of managed\nTLS certificates.\n\nAn AutomationPolicy value is not valid until it has been\nprovisioned; use the `AddAutomationPolicy()` method on the\nTLS app to properly provision a new policy. \n", + "type": "object", + "properties": { + "disable_ocsp_stapling": { + "description": "disable_ocsp_stapling: boolean\nModule: tls\nDisables OCSP stapling. Disabling OCSP stapling puts clients at\ngreater risk, reduces their privacy, and usually lowers client\nperformance. It is NOT recommended to disable this unless you\nare able to justify the costs.\nEXPERIMENTAL. Subject to change.\n", + "markdownDescription": "disable_ocsp_stapling: `boolean` \nModule: `tls` \nDisables OCSP stapling. Disabling OCSP stapling puts clients at\ngreater risk, reduces their privacy, and usually lowers client\nperformance. It is NOT recommended to disable this unless you\nare able to justify the costs.\nEXPERIMENTAL. Subject to change. \n", + "type": "boolean" + }, + "get_certificate": { + "description": "get_certificate: array\nModule: tls.get_certificate\nModules that can get a custom certificate to use for any\ngiven TLS handshake at handshake-time. Custom certificates\ncan be useful if another entity is managing certificates\nand Caddy need only get it and serve it.\n\nTODO: This is an EXPERIMENTAL feature. It is subject to change or removal.\n", + "markdownDescription": "get_certificate: `array` \nModule: `tls.get_certificate` \nModules that can get a custom certificate to use for any\ngiven TLS handshake at handshake-time. Custom certificates\ncan be useful if another entity is managing certificates\nand Caddy need only get it and serve it.\n\nTODO: This is an EXPERIMENTAL feature. It is subject to change or removal. \n", + "type": "array", + "items": { + "description": "Modules that can get a custom certificate to use for any\ngiven TLS handshake at handshake-time. Custom certificates\ncan be useful if another entity is managing certificates\nand Caddy need only get it and serve it.\n\nTODO: This is an EXPERIMENTAL feature. It is subject to change or removal.\n", + "markdownDescription": "Modules that can get a custom certificate to use for any\ngiven TLS handshake at handshake-time. Custom certificates\ncan be useful if another entity is managing certificates\nand Caddy need only get it and serve it.\n\nTODO: This is an EXPERIMENTAL feature. It is subject to change or removal. \n", + "required": [ + "via" + ], + "allOf": [ + { + "if": { + "properties": { + "via": { + "const": "http" + } + } + }, + "then": { + "$ref": "#/definitions/tls.get_certificate.http" + } + }, + { + "if": { + "properties": { + "via": { + "const": "tailscale" + } + } + }, + "then": { + "$ref": "#/definitions/tls.get_certificate.tailscale" + } + }, + { + "properties": { + "via": { + "description": "key to identify get_certificate module.\nvia: string\nModule: tls.get_certificate", + "markdownDescription": "key to identify `get_certificate` module. \nvia: `string` \nModule: `tls.get_certificate`", + "type": "string", + "enum": [ + "http", + "tailscale" + ] + } + } + } + ] + } + }, + "issuers": { + "description": "issuers: array\nModule: tls.issuance\nThe modules that may issue certificates. Default: internal if all\nsubjects do not qualify for public certificates; othewise acme and\nzerossl.\n", + "markdownDescription": "issuers: `array` \nModule: `tls.issuance` \nThe modules that may issue certificates. Default: internal if all\nsubjects do not qualify for public certificates; othewise acme and\nzerossl. \n", + "type": "array", + "items": { + "description": "The modules that may issue certificates. Default: internal if all\nsubjects do not qualify for public certificates; othewise acme and\nzerossl.\n", + "markdownDescription": "The modules that may issue certificates. Default: internal if all\nsubjects do not qualify for public certificates; othewise acme and\nzerossl. \n", + "required": [ + "module" + ], + "allOf": [ + { + "if": { + "properties": { + "module": { + "const": "zerossl" + } + } + }, + "then": { + "$ref": "#/definitions/tls.issuance.zerossl" + } + }, + { + "if": { + "properties": { + "module": { + "const": "acme" + } + } + }, + "then": { + "$ref": "#/definitions/tls.issuance.acme" + } + }, + { + "if": { + "properties": { + "module": { + "const": "internal" + } + } + }, + "then": { + "$ref": "#/definitions/tls.issuance.internal" + } + }, + { + "properties": { + "module": { + "description": "key to identify issuers module.\nmodule: string\nModule: tls.issuance", + "markdownDescription": "key to identify `issuers` module. \nmodule: `string` \nModule: `tls.issuance`", + "type": "string", + "enum": [ + "zerossl", + "acme", + "internal" + ] + } + } + } + ] + } + }, + "key_type": { + "description": "key_type: string\nModule: tls\nThe type of key to generate for certificates.\nSupported values: `ed25519`, `p256`, `p384`, `rsa2048`, `rsa4096`.\n", + "markdownDescription": "key_type: `string` \nModule: `tls` \nThe type of key to generate for certificates.\nSupported values: `ed25519`, `p256`, `p384`, `rsa2048`, `rsa4096`. \n", + "type": "string" + }, + "must_staple": { + "description": "must_staple: boolean\nModule: tls\nIf true, certificates will be requested with MustStaple. Not all\nCAs support this, and there are potentially serious consequences\nof enabling this feature without proper threat modeling.\n", + "markdownDescription": "must_staple: `boolean` \nModule: `tls` \nIf true, certificates will be requested with MustStaple. Not all\nCAs support this, and there are potentially serious consequences\nof enabling this feature without proper threat modeling. \n", + "type": "boolean" + }, + "ocsp_overrides": { + "description": "ocsp_overrides: object\nModule: tls\nOverrides the URLs of OCSP responders embedded in certificates.\nEach key is a OCSP server URL to override, and its value is the\nreplacement. An empty value will disable querying of that server.\nEXPERIMENTAL. Subject to change.\n", + "markdownDescription": "ocsp_overrides: `object` \nModule: `tls` \nOverrides the URLs of OCSP responders embedded in certificates.\nEach key is a OCSP server URL to override, and its value is the\nreplacement. An empty value will disable querying of that server.\nEXPERIMENTAL. Subject to change. \n", + "type": "object", + "additionalProperties": { + "description": "Overrides the URLs of OCSP responders embedded in certificates.\nEach key is a OCSP server URL to override, and its value is the\nreplacement. An empty value will disable querying of that server.\nEXPERIMENTAL. Subject to change.\n", + "markdownDescription": "Overrides the URLs of OCSP responders embedded in certificates.\nEach key is a OCSP server URL to override, and its value is the\nreplacement. An empty value will disable querying of that server.\nEXPERIMENTAL. Subject to change. \n" + } + }, + "on_demand": { + "description": "on_demand: boolean\nModule: tls\nIf true, certificates will be managed \"on demand\"; that is, during\nTLS handshakes or when needed, as opposed to at startup or config\nload. This enables On-Demand TLS for this policy.\n", + "markdownDescription": "on_demand: `boolean` \nModule: `tls` \nIf true, certificates will be managed \"on demand\"; that is, during\nTLS handshakes or when needed, as opposed to at startup or config\nload. This enables On-Demand TLS for this policy. \n", + "type": "boolean" + }, + "renewal_window_ratio": { + "description": "renewal_window_ratio: object\nModule: tls\nHow long before a certificate's expiration to try renewing it,\nas a function of its total lifetime. As a general and conservative\nrule, it is a good idea to renew a certificate when it has about\n1/3 of its total lifetime remaining. This utilizes the majority\nof the certificate's lifetime while still saving time to\ntroubleshoot problems. However, for extremely short-lived certs,\nyou may wish to increase the ratio to ~1/2.\n", + "markdownDescription": "renewal_window_ratio: `object` \nModule: `tls` \nHow long before a certificate's expiration to try renewing it,\nas a function of its total lifetime. As a general and conservative\nrule, it is a good idea to renew a certificate when it has about\n1/3 of its total lifetime remaining. This utilizes the majority\nof the certificate's lifetime while still saving time to\ntroubleshoot problems. However, for extremely short-lived certs,\nyou may wish to increase the ratio to ~1/2. \n", + "type": "object" + }, + "storage": { + "description": "storage: object\nModule: caddy.storage\nOptionally configure a separate storage module associated with this\nmanager, instead of using Caddy's global/default-configured storage.\n", + "markdownDescription": "storage: `object` \nModule: `caddy.storage` \nOptionally configure a separate storage module associated with this\nmanager, instead of using Caddy's global/default-configured storage. \n", + "type": "object", + "required": [ + "module" + ], + "allOf": [ + { + "if": { + "properties": { + "module": { + "const": "consul" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.storage.consul" + } + }, + { + "if": { + "properties": { + "module": { + "const": "file_system" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.storage.file_system" + } + }, + { + "properties": { + "module": { + "description": "key to identify storage module.\nmodule: string\nModule: caddy.storage", + "markdownDescription": "key to identify `storage` module. \nmodule: `string` \nModule: `caddy.storage`", + "type": "string", + "enum": [ + "consul", + "file_system" + ] + } + } + } + ] + }, + "subjects": { + "description": "subjects: array\nModule: tls\nWhich subjects (hostnames or IP addresses) this policy applies to.\n", + "markdownDescription": "subjects: `array` \nModule: `tls` \nWhich subjects (hostnames or IP addresses) this policy applies to. \n", + "type": "array", + "items": { + "description": "Which subjects (hostnames or IP addresses) this policy applies to.\n", + "markdownDescription": "Which subjects (hostnames or IP addresses) this policy applies to. \n", + "type": "string" + } + } + } + } + }, + "renew_interval": { + "description": "renew_interval: number\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nEvery so often, Caddy will scan all loaded, managed\ncertificates for expiration. This setting changes how\nfrequently the scan for expiring certificates is\nperformed. Default: 10m\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "renew_interval: `number` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nEvery so often, Caddy will scan all loaded, managed\ncertificates for expiration. This setting changes how\nfrequently the scan for expiring certificates is\nperformed. Default: 10m\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "storage_clean_interval": { + "description": "storage_clean_interval: number\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow often to scan storage units for old or expired\nassets and remove them. These scans exert lots of\nreads (and list operations) on the storage module, so\nchoose a longer interval for large deployments.\nDefault: 24h\n\nStorage will always be cleaned when the process first\nstarts. Then, a new cleaning will be started this\nduration after the previous cleaning started if the\nprevious cleaning finished in less than half the time\nof this interval (otherwise next start will be skipped).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "storage_clean_interval: `number` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow often to scan storage units for old or expired\nassets and remove them. These scans exert lots of\nreads (and list operations) on the storage module, so\nchoose a longer interval for large deployments.\nDefault: 24h\n\nStorage will always be cleaned when the process first\nstarts. Then, a new cleaning will be started this\nduration after the previous cleaning started if the\nprevious cleaning finished in less than half the time\nof this interval (otherwise next start will be skipped).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + }, + "cache": { + "description": "cache: object\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertCacheOptions\nConfigures the in-memory certificate cache.\n\n\nCertCacheOptions configures the certificate cache.\n", + "markdownDescription": "cache: `object` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertCacheOptions) \nConfigures the in-memory certificate cache.\n\n\nCertCacheOptions configures the certificate cache. \n", + "type": "object", + "properties": { + "capacity": { + "description": "capacity: number\nModule: tls\nMaximum number of certificates to allow in the\ncache. If reached, certificates will be randomly\nevicted to make room for new ones. Default: 10,000\n", + "markdownDescription": "capacity: `number` \nModule: `tls` \nMaximum number of certificates to allow in the\ncache. If reached, certificates will be randomly\nevicted to make room for new ones. Default: 10,000 \n", + "type": "number" + } + } + }, + "certificates": { + "description": "certificates: object\nModule: tls.certificates\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nCaches certificates in memory for quick use during\nTLS handshakes. Each key is the name of a certificate\nloader module. All loaded certificates get pooled\ninto the same cache and may be used to complete TLS\nhandshakes for the relevant server names (SNI).\nCertificates loaded manually (anything other than\n\"automate\") are not automatically managed and will\nhave to be refreshed manually before they expire.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "certificates: `object` \nModule: `tls.certificates` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nCaches certificates in memory for quick use during\nTLS handshakes. Each key is the name of a certificate\nloader module. All loaded certificates get pooled\ninto the same cache and may be used to complete TLS\nhandshakes for the relevant server names (SNI).\nCertificates loaded manually (anything other than\n\"automate\") are not automatically managed and will\nhave to be refreshed manually before they expire.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "object", + "properties": { + "automate": { + "$ref": "#/definitions/tls.certificates.automate" + }, + "load_files": { + "$ref": "#/definitions/tls.certificates.load_files" + }, + "load_folders": { + "$ref": "#/definitions/tls.certificates.load_folders" + }, + "load_pem": { + "$ref": "#/definitions/tls.certificates.load_pem" + }, + "load_storage": { + "$ref": "#/definitions/tls.certificates.load_storage" + } + } + }, + "disable_ocsp_stapling": { + "description": "disable_ocsp_stapling: boolean\nModule: tls\nDisables OCSP stapling for manually-managed certificates only.\nTo configure OCSP stapling for automated certificates, use an\nautomation policy instead.\n\nDisabling OCSP stapling puts clients at greater risk, reduces their\nprivacy, and usually lowers client performance. It is NOT recommended\nto disable this unless you are able to justify the costs.\nEXPERIMENTAL. Subject to change.\n", + "markdownDescription": "disable_ocsp_stapling: `boolean` \nModule: `tls` \nDisables OCSP stapling for manually-managed certificates only.\nTo configure OCSP stapling for automated certificates, use an\nautomation policy instead.\n\nDisabling OCSP stapling puts clients at greater risk, reduces their\nprivacy, and usually lowers client performance. It is NOT recommended\nto disable this unless you are able to justify the costs.\nEXPERIMENTAL. Subject to change. \n", + "type": "boolean" + }, + "session_tickets": { + "description": "session_tickets: object\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#SessionTicketService\nConfigures session ticket ephemeral keys (STEKs).\n\n\nSessionTicketService configures and manages TLS session tickets.\n", + "markdownDescription": "session_tickets: `object` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#SessionTicketService) \nConfigures session ticket ephemeral keys (STEKs).\n\n\nSessionTicketService configures and manages TLS session tickets. \n", + "type": "object", + "properties": { + "disable_rotation": { + "description": "disable_rotation: boolean\nModule: tls\nDisables STEK rotation.\n", + "markdownDescription": "disable_rotation: `boolean` \nModule: `tls` \nDisables STEK rotation. \n", + "type": "boolean" + }, + "disabled": { + "description": "disabled: boolean\nModule: tls\nDisables TLS session resumption by tickets.\n", + "markdownDescription": "disabled: `boolean` \nModule: `tls` \nDisables TLS session resumption by tickets. \n", + "type": "boolean" + }, + "key_source": { + "description": "key_source: object\nModule: tls.stek\nKeySource is the method by which Caddy produces or obtains\nTLS session ticket keys (STEKs). By default, Caddy generates\nthem internally using a secure pseudorandom source.\n", + "markdownDescription": "key_source: `object` \nModule: `tls.stek` \nKeySource is the method by which Caddy produces or obtains\nTLS session ticket keys (STEKs). By default, Caddy generates\nthem internally using a secure pseudorandom source. \n", + "type": "object", + "required": [ + "provider" + ], + "allOf": [ + { + "if": { + "properties": { + "provider": { + "const": "distributed" + } + } + }, + "then": { + "$ref": "#/definitions/tls.stek.distributed" + } + }, + { + "if": { + "properties": { + "provider": { + "const": "standard" + } + } + }, + "then": { + "$ref": "#/definitions/tls.stek.standard" + } + }, + { + "properties": { + "provider": { + "description": "key to identify key_source module.\nprovider: string\nModule: tls.stek", + "markdownDescription": "key to identify `key_source` module. \nprovider: `string` \nModule: `tls.stek`", + "type": "string", + "enum": [ + "distributed", + "standard" + ] + } + } + } + ] + }, + "max_keys": { + "description": "max_keys: number\nModule: tls\nThe maximum number of keys to keep in rotation. Default: 4.\n", + "markdownDescription": "max_keys: `number` \nModule: `tls` \nThe maximum number of keys to keep in rotation. Default: 4. \n", + "type": "number" + }, + "rotation_interval": { + "description": "rotation_interval: number\nModule: tls\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow often Caddy rotates STEKs. Default: 12h.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "rotation_interval: `number` \nModule: `tls` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow often Caddy rotates STEKs. Default: 12h.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + } + } + }, + "tls.certificates.automate": { + "description": "automate: array\nModule: tls.certificates.automate\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#AutomateLoader\nAutomateLoader will automatically manage certificates for the names in the\nlist, including obtaining and renewing certificates. Automated certificates\nare managed according to their matching automation policy, configured\nelsewhere in this app.\n\nTechnically, this is a no-op certificate loader module that is treated as\na special case: it uses this app's automation features to load certificates\nfor the list of hostnames, rather than loading certificates manually.\n\n", + "markdownDescription": "automate: `array` \nModule: `tls.certificates.automate` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#AutomateLoader) \nAutomateLoader will automatically manage certificates for the names in the\nlist, including obtaining and renewing certificates. Automated certificates\nare managed according to their matching automation policy, configured\nelsewhere in this app.\n\nTechnically, this is a no-op certificate loader module that is treated as\na special case: it uses this app's automation features to load certificates\nfor the list of hostnames, rather than loading certificates manually.\n \n", + "type": "array", + "items": { + "type": "string" + } + }, + "tls.certificates.load_files": { + "description": "load_files: array\nModule: tls.certificates.load_files\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyFilePair\nCertKeyFilePair pairs certificate and key file names along with their\nencoding format so that they can be loaded from disk.\n\n", + "markdownDescription": "load_files: `array` \nModule: `tls.certificates.load_files` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyFilePair) \nCertKeyFilePair pairs certificate and key file names along with their\nencoding format so that they can be loaded from disk.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyFilePair\nCertKeyFilePair pairs certificate and key file names along with their\nencoding format so that they can be loaded from disk.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyFilePair) \nCertKeyFilePair pairs certificate and key file names along with their\nencoding format so that they can be loaded from disk.\n \n", + "type": "object", + "properties": { + "certificate": { + "description": "certificate: string\nModule: tls.certificates.load_files\nPath to the certificate (public key) file.\n", + "markdownDescription": "certificate: `string` \nModule: `tls.certificates.load_files` \nPath to the certificate (public key) file. \n", + "type": "string" + }, + "format": { + "description": "format: string\nModule: tls.certificates.load_files\nThe format of the cert and key. Can be \"pem\". Default: \"pem\"\n", + "markdownDescription": "format: `string` \nModule: `tls.certificates.load_files` \nThe format of the cert and key. Can be \"pem\". Default: \"pem\" \n", + "type": "string" + }, + "key": { + "description": "key: string\nModule: tls.certificates.load_files\nPath to the private key file.\n", + "markdownDescription": "key: `string` \nModule: `tls.certificates.load_files` \nPath to the private key file. \n", + "type": "string" + }, + "tags": { + "description": "tags: array\nModule: tls.certificates.load_files\nArbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates.\n", + "markdownDescription": "tags: `array` \nModule: `tls.certificates.load_files` \nArbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates. \n", + "type": "array", + "items": { + "description": "Arbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates.\n", + "markdownDescription": "Arbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates. \n", + "type": "string" + } + } + } + } + }, + "tls.certificates.load_folders": { + "description": "load_folders: array\nModule: tls.certificates.load_folders\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#FolderLoader\nFolderLoader loads certificates and their associated keys from disk\nby recursively walking the specified directories, looking for PEM\nfiles which contain both a certificate and a key.\n\n", + "markdownDescription": "load_folders: `array` \nModule: `tls.certificates.load_folders` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#FolderLoader) \nFolderLoader loads certificates and their associated keys from disk\nby recursively walking the specified directories, looking for PEM\nfiles which contain both a certificate and a key.\n \n", + "type": "array", + "items": { + "type": "string" + } + }, + "tls.certificates.load_pem": { + "description": "load_pem: array\nModule: tls.certificates.load_pem\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyPEMPair\nCertKeyPEMPair pairs certificate and key PEM blocks.\n\n", + "markdownDescription": "load_pem: `array` \nModule: `tls.certificates.load_pem` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyPEMPair) \nCertKeyPEMPair pairs certificate and key PEM blocks.\n \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyPEMPair\nCertKeyPEMPair pairs certificate and key PEM blocks.\n\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyPEMPair) \nCertKeyPEMPair pairs certificate and key PEM blocks.\n \n", + "type": "object", + "properties": { + "certificate": { + "description": "certificate: string\nModule: tls.certificates.load_pem\nThe certificate (public key) in PEM format.\n", + "markdownDescription": "certificate: `string` \nModule: `tls.certificates.load_pem` \nThe certificate (public key) in PEM format. \n", + "type": "string" + }, + "key": { + "description": "key: string\nModule: tls.certificates.load_pem\nThe private key in PEM format.\n", + "markdownDescription": "key: `string` \nModule: `tls.certificates.load_pem` \nThe private key in PEM format. \n", + "type": "string" + }, + "tags": { + "description": "tags: array\nModule: tls.certificates.load_pem\nArbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates.\n", + "markdownDescription": "tags: `array` \nModule: `tls.certificates.load_pem` \nArbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates. \n", + "type": "array", + "items": { + "description": "Arbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates.\n", + "markdownDescription": "Arbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates. \n", + "type": "string" + } + } + } + } + }, + "tls.certificates.load_storage": { + "description": "load_storage: object\nModule: tls.certificates.load_storage\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#StorageLoader\nStorageLoader loads certificates and their associated keys\nfrom the globally configured storage module.\n\n", + "markdownDescription": "load_storage: `object` \nModule: `tls.certificates.load_storage` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#StorageLoader) \nStorageLoader loads certificates and their associated keys\nfrom the globally configured storage module.\n \n", + "type": "object", + "properties": { + "pairs": { + "description": "pairs: array\nModule: tls.certificates.load_storage\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyFilePair\nA list of pairs of certificate and key file names along with their\nencoding format so that they can be loaded from storage.\n\n\nCertKeyFilePair pairs certificate and key file names along with their\nencoding format so that they can be loaded from disk.\n", + "markdownDescription": "pairs: `array` \nModule: `tls.certificates.load_storage` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyFilePair) \nA list of pairs of certificate and key file names along with their\nencoding format so that they can be loaded from storage.\n\n\nCertKeyFilePair pairs certificate and key file names along with their\nencoding format so that they can be loaded from disk. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyFilePair\nA list of pairs of certificate and key file names along with their\nencoding format so that they can be loaded from storage.\n\n\nCertKeyFilePair pairs certificate and key file names along with their\nencoding format so that they can be loaded from disk.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#CertKeyFilePair) \nA list of pairs of certificate and key file names along with their\nencoding format so that they can be loaded from storage.\n\n\nCertKeyFilePair pairs certificate and key file names along with their\nencoding format so that they can be loaded from disk. \n", + "type": "object", + "properties": { + "certificate": { + "description": "certificate: string\nModule: tls.certificates.load_storage\nPath to the certificate (public key) file.\n", + "markdownDescription": "certificate: `string` \nModule: `tls.certificates.load_storage` \nPath to the certificate (public key) file. \n", + "type": "string" + }, + "format": { + "description": "format: string\nModule: tls.certificates.load_storage\nThe format of the cert and key. Can be \"pem\". Default: \"pem\"\n", + "markdownDescription": "format: `string` \nModule: `tls.certificates.load_storage` \nThe format of the cert and key. Can be \"pem\". Default: \"pem\" \n", + "type": "string" + }, + "key": { + "description": "key: string\nModule: tls.certificates.load_storage\nPath to the private key file.\n", + "markdownDescription": "key: `string` \nModule: `tls.certificates.load_storage` \nPath to the private key file. \n", + "type": "string" + }, + "tags": { + "description": "tags: array\nModule: tls.certificates.load_storage\nArbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates.\n", + "markdownDescription": "tags: `array` \nModule: `tls.certificates.load_storage` \nArbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates. \n", + "type": "array", + "items": { + "description": "Arbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates.\n", + "markdownDescription": "Arbitrary values to associate with this certificate.\nCan be useful when you want to select a particular\ncertificate when there may be multiple valid candidates. \n", + "type": "string" + } + } + } + } + } + } + }, + "tls.client_auth.leaf": { + "description": "leaf: any\nModule: tls.client_auth.leaf\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#LeafCertClientAuth", + "markdownDescription": "leaf: `any` \nModule: `tls.client_auth.leaf` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#LeafCertClientAuth)" + }, + "tls.get_certificate.http": { + "description": "http: object\nModule: tls.get_certificate.http\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#HTTPCertGetter\nHTTPCertGetter can get a certificate via HTTP(S) request.\n\n", + "markdownDescription": "http: `object` \nModule: `tls.get_certificate.http` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#HTTPCertGetter) \nHTTPCertGetter can get a certificate via HTTP(S) request.\n \n", + "type": "object", + "properties": { + "url": { + "description": "url: string\nModule: tls.get_certificate.http\nThe URL from which to download the certificate. Required.\n\nThe URL will be augmented with query string parameters taken\nfrom the TLS handshake:\n\n- server_name: The SNI value\n- signature_schemes: Comma-separated list of hex IDs of signatures\n- cipher_suites: Comma-separated list of hex IDs of cipher suites\n\nTo be valid, the response must be HTTP 200 with a PEM body\nconsisting of blocks for the certificate chain and the private\nkey.\n", + "markdownDescription": "url: `string` \nModule: `tls.get_certificate.http` \nThe URL from which to download the certificate. Required.\n\nThe URL will be augmented with query string parameters taken\nfrom the TLS handshake:\n\n- server_name: The SNI value\n- signature_schemes: Comma-separated list of hex IDs of signatures\n- cipher_suites: Comma-separated list of hex IDs of cipher suites\n\nTo be valid, the response must be HTTP 200 with a PEM body\nconsisting of blocks for the certificate chain and the private\nkey. \n", + "type": "string" + } + } + }, + "tls.get_certificate.tailscale": { + "description": "tailscale: object\nModule: tls.get_certificate.tailscale\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#Tailscale\nTailscale is a module that can get certificates from the local Tailscale process.\n\n", + "markdownDescription": "tailscale: `object` \nModule: `tls.get_certificate.tailscale` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#Tailscale) \nTailscale is a module that can get certificates from the local Tailscale process.\n \n", + "type": "object", + "properties": { + "optional": { + "description": "optional: boolean\nModule: tls.get_certificate.tailscale\nIf true, this module will operate in \"best-effort\" mode and\nignore \"soft\" errors; i.e. try Tailscale, and if it doesn't connect\nor return a certificate, oh well. Failure to connect to Tailscale\nresults in a no-op instead of an error. Intended for the use case\nwhere this module is added implicitly for convenience, even if\nTailscale isn't necessarily running.\n", + "markdownDescription": "optional: `boolean` \nModule: `tls.get_certificate.tailscale` \nIf true, this module will operate in \"best-effort\" mode and\nignore \"soft\" errors; i.e. try Tailscale, and if it doesn't connect\nor return a certificate, oh well. Failure to connect to Tailscale\nresults in a no-op instead of an error. Intended for the use case\nwhere this module is added implicitly for convenience, even if\nTailscale isn't necessarily running. \n", + "type": "boolean" + } + } + }, + "tls.handshake_match.alpn": { + "description": "alpn: array\nModule: tls.handshake_match.alpn\nhttps://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4tls#MatchALPN", + "markdownDescription": "alpn: `array` \nModule: `tls.handshake_match.alpn` \n[godoc](https://pkg.go.dev/github.com/mholt/caddy-l4/modules/l4tls#MatchALPN)", + "type": "array", + "items": { + "type": "string" + } + }, + "tls.handshake_match.remote_ip": { + "description": "remote_ip: object\nModule: tls.handshake_match.remote_ip\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#MatchRemoteIP\nMatchRemoteIP matches based on the remote IP of the\nconnection. Specific IPs or CIDR ranges can be specified.\n\nNote that IPs can sometimes be spoofed, so do not rely\non this as a replacement for actual authentication.\n\n", + "markdownDescription": "remote_ip: `object` \nModule: `tls.handshake_match.remote_ip` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#MatchRemoteIP) \nMatchRemoteIP matches based on the remote IP of the\nconnection. Specific IPs or CIDR ranges can be specified.\n\nNote that IPs can sometimes be spoofed, so do not rely\non this as a replacement for actual authentication.\n \n", + "type": "object", + "properties": { + "not_ranges": { + "description": "not_ranges: array\nModule: tls.handshake_match.remote_ip\nThe IPs or CIDR ranges to *NOT* match.\n", + "markdownDescription": "not_ranges: `array` \nModule: `tls.handshake_match.remote_ip` \nThe IPs or CIDR ranges to *NOT* match. \n", + "type": "array", + "items": { + "description": "The IPs or CIDR ranges to *NOT* match.\n", + "markdownDescription": "The IPs or CIDR ranges to *NOT* match. \n", + "type": "string" + } + }, + "ranges": { + "description": "ranges: array\nModule: tls.handshake_match.remote_ip\nThe IPs or CIDR ranges to match.\n", + "markdownDescription": "ranges: `array` \nModule: `tls.handshake_match.remote_ip` \nThe IPs or CIDR ranges to match. \n", + "type": "array", + "items": { + "description": "The IPs or CIDR ranges to match.\n", + "markdownDescription": "The IPs or CIDR ranges to match. \n", + "type": "string" + } + } + } + }, + "tls.handshake_match.sni": { + "description": "sni: array\nModule: tls.handshake_match.sni\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#MatchServerName\nMatchServerName matches based on SNI. Names in\nthis list may use left-most-label wildcards,\nsimilar to wildcard certificates.\n\n", + "markdownDescription": "sni: `array` \nModule: `tls.handshake_match.sni` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#MatchServerName) \nMatchServerName matches based on SNI. Names in\nthis list may use left-most-label wildcards,\nsimilar to wildcard certificates.\n \n", + "type": "array", + "items": { + "type": "string" + } + }, + "tls.issuance.acme": { + "description": "acme: object\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ACMEIssuer\nACMEIssuer manages certificates using the ACME protocol (RFC 8555).\n\n", + "markdownDescription": "acme: `object` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ACMEIssuer) \nACMEIssuer manages certificates using the ACME protocol (RFC 8555).\n \n", + "type": "object", + "properties": { + "account_key": { + "description": "account_key: string\nModule: tls.issuance.acme\nIf you have an existing account with the ACME server, put\nthe private key here in PEM format. The ACME client will\nlook up your account information with this key first before\ntrying to create a new one. You can use placeholders here,\nfor example if you have it in an environment variable.\n", + "markdownDescription": "account_key: `string` \nModule: `tls.issuance.acme` \nIf you have an existing account with the ACME server, put\nthe private key here in PEM format. The ACME client will\nlook up your account information with this key first before\ntrying to create a new one. You can use placeholders here,\nfor example if you have it in an environment variable. \n", + "type": "string" + }, + "acme_timeout": { + "description": "acme_timeout: number\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nTime to wait before timing out an ACME operation.\nDefault: 0 (no timeout)\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "acme_timeout: `number` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nTime to wait before timing out an ACME operation.\nDefault: 0 (no timeout)\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "ca": { + "description": "ca: string\nModule: tls.issuance.acme\nThe URL to the CA's ACME directory endpoint. Default:\nhttps://acme-v02.api.letsencrypt.org/directory\n", + "markdownDescription": "ca: `string` \nModule: `tls.issuance.acme` \nThe URL to the CA's ACME directory endpoint. Default:\nhttps://acme-v02.api.letsencrypt.org/directory \n", + "type": "string" + }, + "challenges": { + "description": "challenges: object\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ChallengesConfig\nConfigures the various ACME challenge types.\n\n\nChallengesConfig configures the ACME challenges.\n", + "markdownDescription": "challenges: `object` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ChallengesConfig) \nConfigures the various ACME challenge types.\n\n\nChallengesConfig configures the ACME challenges. \n", + "type": "object", + "properties": { + "bind_host": { + "description": "bind_host: string\nModule: tls.issuance.acme\nOptionally customize the host to which a listener\nis bound if required for solving a challenge.\n", + "markdownDescription": "bind_host: `string` \nModule: `tls.issuance.acme` \nOptionally customize the host to which a listener\nis bound if required for solving a challenge. \n", + "type": "string" + }, + "dns": { + "description": "dns: object\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#DNSChallengeConfig\nConfigures the ACME DNS challenge. Because this\nchallenge typically requires credentials for\ninterfacing with a DNS provider, this challenge is\nnot enabled by default. This is the only challenge\ntype which does not require a direct connection\nto Caddy from an external server.\n\nNOTE: DNS providers are currently being upgraded,\nand this API is subject to change, but should be\nstabilized soon.\n\n\nDNSChallengeConfig configures the ACME DNS challenge.\n\nNOTE: This API is still experimental and is subject to change.\n", + "markdownDescription": "dns: `object` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#DNSChallengeConfig) \nConfigures the ACME DNS challenge. Because this\nchallenge typically requires credentials for\ninterfacing with a DNS provider, this challenge is\nnot enabled by default. This is the only challenge\ntype which does not require a direct connection\nto Caddy from an external server.\n\nNOTE: DNS providers are currently being upgraded,\nand this API is subject to change, but should be\nstabilized soon.\n\n\nDNSChallengeConfig configures the ACME DNS challenge.\n\nNOTE: This API is still experimental and is subject to change. \n", + "type": "object", + "properties": { + "override_domain": { + "description": "override_domain: string\nModule: tls.issuance.acme\nOverride the domain to use for the DNS challenge. This\nis to delegate the challenge to a different domain,\ne.g. one that updates faster or one with a provider API.\n", + "markdownDescription": "override_domain: `string` \nModule: `tls.issuance.acme` \nOverride the domain to use for the DNS challenge. This\nis to delegate the challenge to a different domain,\ne.g. one that updates faster or one with a provider API. \n", + "type": "string" + }, + "propagation_delay": { + "description": "propagation_delay: number\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to wait before starting propagation checks.\nDefault: 0 (no wait).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "propagation_delay: `number` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to wait before starting propagation checks.\nDefault: 0 (no wait).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "propagation_timeout": { + "description": "propagation_timeout: number\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nMaximum time to wait for temporary DNS record to appear.\nSet to -1 to disable propagation checks.\nDefault: 2 minutes.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "propagation_timeout: `number` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nMaximum time to wait for temporary DNS record to appear.\nSet to -1 to disable propagation checks.\nDefault: 2 minutes.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "provider": { + "description": "provider: any\nModule: dns.providers\nThe DNS provider module to use which will manage\nthe DNS records relevant to the ACME challenge.\n", + "markdownDescription": "provider: `any` \nModule: `dns.providers` \nThe DNS provider module to use which will manage\nthe DNS records relevant to the ACME challenge. \n" + }, + "resolvers": { + "description": "resolvers: array\nModule: tls.issuance.acme\nCustom DNS resolvers to prefer over system/built-in defaults.\nOften necessary to configure when using split-horizon DNS.\n", + "markdownDescription": "resolvers: `array` \nModule: `tls.issuance.acme` \nCustom DNS resolvers to prefer over system/built-in defaults.\nOften necessary to configure when using split-horizon DNS. \n", + "type": "array", + "items": { + "description": "Custom DNS resolvers to prefer over system/built-in defaults.\nOften necessary to configure when using split-horizon DNS.\n", + "markdownDescription": "Custom DNS resolvers to prefer over system/built-in defaults.\nOften necessary to configure when using split-horizon DNS. \n", + "type": "string" + } + }, + "ttl": { + "description": "ttl: number\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nThe TTL of the TXT record used for the DNS challenge.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "ttl: `number` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nThe TTL of the TXT record used for the DNS challenge.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + }, + "http": { + "description": "http: object\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#HTTPChallengeConfig\nHTTP configures the ACME HTTP challenge. This\nchallenge is enabled and used automatically\nand by default.\n\n\nHTTPChallengeConfig configures the ACME HTTP challenge.\n", + "markdownDescription": "http: `object` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#HTTPChallengeConfig) \nHTTP configures the ACME HTTP challenge. This\nchallenge is enabled and used automatically\nand by default.\n\n\nHTTPChallengeConfig configures the ACME HTTP challenge. \n", + "type": "object", + "properties": { + "alternate_port": { + "description": "alternate_port: number\nModule: tls.issuance.acme\nAn alternate port on which to service this\nchallenge. Note that the HTTP challenge port is\nhard-coded into the spec and cannot be changed,\nso you would have to forward packets from the\nstandard HTTP challenge port to this one.\n", + "markdownDescription": "alternate_port: `number` \nModule: `tls.issuance.acme` \nAn alternate port on which to service this\nchallenge. Note that the HTTP challenge port is\nhard-coded into the spec and cannot be changed,\nso you would have to forward packets from the\nstandard HTTP challenge port to this one. \n", + "type": "number" + }, + "disabled": { + "description": "disabled: boolean\nModule: tls.issuance.acme\nIf true, the HTTP challenge will be disabled.\n", + "markdownDescription": "disabled: `boolean` \nModule: `tls.issuance.acme` \nIf true, the HTTP challenge will be disabled. \n", + "type": "boolean" + } + } + }, + "tls-alpn": { + "description": "tls-alpn: object\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#TLSALPNChallengeConfig\nTLSALPN configures the ACME TLS-ALPN challenge.\nThis challenge is enabled and used automatically\nand by default.\n\n\nTLSALPNChallengeConfig configures the ACME TLS-ALPN challenge.\n", + "markdownDescription": "tls-alpn: `object` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#TLSALPNChallengeConfig) \nTLSALPN configures the ACME TLS-ALPN challenge.\nThis challenge is enabled and used automatically\nand by default.\n\n\nTLSALPNChallengeConfig configures the ACME TLS-ALPN challenge. \n", + "type": "object", + "properties": { + "alternate_port": { + "description": "alternate_port: number\nModule: tls.issuance.acme\nAn alternate port on which to service this\nchallenge. Note that the TLS-ALPN challenge port\nis hard-coded into the spec and cannot be changed,\nso you would have to forward packets from the\nstandard TLS-ALPN challenge port to this one.\n", + "markdownDescription": "alternate_port: `number` \nModule: `tls.issuance.acme` \nAn alternate port on which to service this\nchallenge. Note that the TLS-ALPN challenge port\nis hard-coded into the spec and cannot be changed,\nso you would have to forward packets from the\nstandard TLS-ALPN challenge port to this one. \n", + "type": "number" + }, + "disabled": { + "description": "disabled: boolean\nModule: tls.issuance.acme\nIf true, the TLS-ALPN challenge will be disabled.\n", + "markdownDescription": "disabled: `boolean` \nModule: `tls.issuance.acme` \nIf true, the TLS-ALPN challenge will be disabled. \n", + "type": "boolean" + } + } + } + } + }, + "email": { + "description": "email: string\nModule: tls.issuance.acme\nYour email address, so the CA can contact you if necessary.\nNot required, but strongly recommended to provide one so\nyou can be reached if there is a problem. Your email is\nnot sent to any Caddy mothership or used for any purpose\nother than ACME transactions.\n", + "markdownDescription": "email: `string` \nModule: `tls.issuance.acme` \nYour email address, so the CA can contact you if necessary.\nNot required, but strongly recommended to provide one so\nyou can be reached if there is a problem. Your email is\nnot sent to any Caddy mothership or used for any purpose\nother than ACME transactions. \n", + "type": "string" + }, + "external_account": { + "description": "external_account: object\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/mholt/acmez/acme#EAB\nIf using an ACME CA that requires an external account\nbinding, specify the CA-provided credentials here.\n\n\nEAB (External Account Binding) contains information\nnecessary to bind or map an ACME account to some\nother account known by the CA.\n\nExternal account bindings are \"used to associate an\nACME account with an existing account in a non-ACME\nsystem, such as a CA customer database.\"\n\n\"To enable ACME account binding, the CA operating the\nACME server needs to provide the ACME client with a\nMAC key and a key identifier, using some mechanism\noutside of ACME.\" §7.3.4\n", + "markdownDescription": "external_account: `object` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/mholt/acmez/acme#EAB) \nIf using an ACME CA that requires an external account\nbinding, specify the CA-provided credentials here.\n\n\nEAB (External Account Binding) contains information\nnecessary to bind or map an ACME account to some\nother account known by the CA.\n\nExternal account bindings are \"used to associate an\nACME account with an existing account in a non-ACME\nsystem, such as a CA customer database.\"\n\n\"To enable ACME account binding, the CA operating the\nACME server needs to provide the ACME client with a\nMAC key and a key identifier, using some mechanism\noutside of ACME.\" §7.3.4 \n", + "type": "object", + "properties": { + "key_id": { + "description": "key_id: string\nModule: tls.issuance.acme\n\"The key identifier MUST be an ASCII string.\" §7.3.4\n", + "markdownDescription": "key_id: `string` \nModule: `tls.issuance.acme` \n\"The key identifier MUST be an ASCII string.\" §7.3.4 \n", + "type": "string" + }, + "mac_key": { + "description": "mac_key: string\nModule: tls.issuance.acme\n\"The MAC key SHOULD be provided in base64url-encoded\nform, to maximize compatibility between non-ACME\nprovisioning systems and ACME clients.\" §7.3.4\n", + "markdownDescription": "mac_key: `string` \nModule: `tls.issuance.acme` \n\"The MAC key SHOULD be provided in base64url-encoded\nform, to maximize compatibility between non-ACME\nprovisioning systems and ACME clients.\" §7.3.4 \n", + "type": "string" + } + } + }, + "preferred_chains": { + "description": "preferred_chains: object\nModule: tls.issuance.acme\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ChainPreference\nPreferences for selecting alternate certificate chains, if offered\nby the CA. By default, the first offered chain will be selected.\nIf configured, the chains may be sorted and the first matching chain\nwill be selected.\n\n\nChainPreference describes the client's preferred certificate chain,\nuseful if the CA offers alternate chains. The first matching chain\nwill be selected.\n", + "markdownDescription": "preferred_chains: `object` \nModule: `tls.issuance.acme` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ChainPreference) \nPreferences for selecting alternate certificate chains, if offered\nby the CA. By default, the first offered chain will be selected.\nIf configured, the chains may be sorted and the first matching chain\nwill be selected.\n\n\nChainPreference describes the client's preferred certificate chain,\nuseful if the CA offers alternate chains. The first matching chain\nwill be selected. \n", + "type": "object", + "properties": { + "any_common_name": { + "description": "any_common_name: array\nModule: tls.issuance.acme\nSelect first chain that has any issuer with one\nof these common names.\n", + "markdownDescription": "any_common_name: `array` \nModule: `tls.issuance.acme` \nSelect first chain that has any issuer with one\nof these common names. \n", + "type": "array", + "items": { + "description": "Select first chain that has any issuer with one\nof these common names.\n", + "markdownDescription": "Select first chain that has any issuer with one\nof these common names. \n", + "type": "string" + } + }, + "root_common_name": { + "description": "root_common_name: array\nModule: tls.issuance.acme\nSelect first chain having a root with one of\nthese common names.\n", + "markdownDescription": "root_common_name: `array` \nModule: `tls.issuance.acme` \nSelect first chain having a root with one of\nthese common names. \n", + "type": "array", + "items": { + "description": "Select first chain having a root with one of\nthese common names.\n", + "markdownDescription": "Select first chain having a root with one of\nthese common names. \n", + "type": "string" + } + }, + "smallest": { + "description": "smallest: boolean\nModule: tls.issuance.acme\nPrefer chains with the fewest number of bytes.\n", + "markdownDescription": "smallest: `boolean` \nModule: `tls.issuance.acme` \nPrefer chains with the fewest number of bytes. \n", + "type": "boolean" + } + } + }, + "test_ca": { + "description": "test_ca: string\nModule: tls.issuance.acme\nThe URL to the test CA's ACME directory endpoint.\nThis endpoint is only used during retries if there\nis a failure using the primary CA. Default:\nhttps://acme-staging-v02.api.letsencrypt.org/directory\n", + "markdownDescription": "test_ca: `string` \nModule: `tls.issuance.acme` \nThe URL to the test CA's ACME directory endpoint.\nThis endpoint is only used during retries if there\nis a failure using the primary CA. Default:\nhttps://acme-staging-v02.api.letsencrypt.org/directory \n", + "type": "string" + }, + "trusted_roots_pem_files": { + "description": "trusted_roots_pem_files: array\nModule: tls.issuance.acme\nAn array of files of CA certificates to accept when connecting to the\nACME CA. Generally, you should only use this if the ACME CA endpoint\nis internal or for development/testing purposes.\n", + "markdownDescription": "trusted_roots_pem_files: `array` \nModule: `tls.issuance.acme` \nAn array of files of CA certificates to accept when connecting to the\nACME CA. Generally, you should only use this if the ACME CA endpoint\nis internal or for development/testing purposes. \n", + "type": "array", + "items": { + "description": "An array of files of CA certificates to accept when connecting to the\nACME CA. Generally, you should only use this if the ACME CA endpoint\nis internal or for development/testing purposes.\n", + "markdownDescription": "An array of files of CA certificates to accept when connecting to the\nACME CA. Generally, you should only use this if the ACME CA endpoint\nis internal or for development/testing purposes. \n", + "type": "string" + } + } + } + }, + "tls.issuance.internal": { + "description": "internal: object\nModule: tls.issuance.internal\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#InternalIssuer\nInternalIssuer is a certificate issuer that generates\ncertificates internally using a locally-configured\nCA which can be customized using the `pki` app.\n\n", + "markdownDescription": "internal: `object` \nModule: `tls.issuance.internal` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#InternalIssuer) \nInternalIssuer is a certificate issuer that generates\ncertificates internally using a locally-configured\nCA which can be customized using the `pki` app.\n \n", + "type": "object", + "properties": { + "ca": { + "description": "ca: string\nModule: tls.issuance.internal\nThe ID of the CA to use for signing. The default\nCA ID is \"local\". The CA can be configured with the\n`pki` app.\n", + "markdownDescription": "ca: `string` \nModule: `tls.issuance.internal` \nThe ID of the CA to use for signing. The default\nCA ID is \"local\". The CA can be configured with the\n`pki` app. \n", + "type": "string" + }, + "lifetime": { + "description": "lifetime: number\nModule: tls.issuance.internal\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nThe validity period of certificates.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "lifetime: `number` \nModule: `tls.issuance.internal` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nThe validity period of certificates.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "sign_with_root": { + "description": "sign_with_root: boolean\nModule: tls.issuance.internal\nIf true, the root will be the issuer instead of\nthe intermediate. This is NOT recommended and should\nonly be used when devices/clients do not properly\nvalidate certificate chains.\n", + "markdownDescription": "sign_with_root: `boolean` \nModule: `tls.issuance.internal` \nIf true, the root will be the issuer instead of\nthe intermediate. This is NOT recommended and should\nonly be used when devices/clients do not properly\nvalidate certificate chains. \n", + "type": "boolean" + } + } + }, + "tls.issuance.zerossl": { + "description": "zerossl: object\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ZeroSSLIssuer\nZeroSSLIssuer makes an ACME manager\nfor managing certificates using ACME.\n\n", + "markdownDescription": "zerossl: `object` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ZeroSSLIssuer) \nZeroSSLIssuer makes an ACME manager\nfor managing certificates using ACME.\n \n", + "type": "object", + "properties": { + "account_key": { + "description": "account_key: string\nModule: tls.issuance.zerossl\nIf you have an existing account with the ACME server, put\nthe private key here in PEM format. The ACME client will\nlook up your account information with this key first before\ntrying to create a new one. You can use placeholders here,\nfor example if you have it in an environment variable.\n", + "markdownDescription": "account_key: `string` \nModule: `tls.issuance.zerossl` \nIf you have an existing account with the ACME server, put\nthe private key here in PEM format. The ACME client will\nlook up your account information with this key first before\ntrying to create a new one. You can use placeholders here,\nfor example if you have it in an environment variable. \n", + "type": "string" + }, + "acme_timeout": { + "description": "acme_timeout: number\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nTime to wait before timing out an ACME operation.\nDefault: 0 (no timeout)\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "acme_timeout: `number` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nTime to wait before timing out an ACME operation.\nDefault: 0 (no timeout)\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "api_key": { + "description": "api_key: string\nModule: tls.issuance.zerossl\nThe API key (or \"access key\") for using the ZeroSSL API.\n", + "markdownDescription": "api_key: `string` \nModule: `tls.issuance.zerossl` \nThe API key (or \"access key\") for using the ZeroSSL API. \n", + "type": "string" + }, + "ca": { + "description": "ca: string\nModule: tls.issuance.zerossl\nThe URL to the CA's ACME directory endpoint. Default:\nhttps://acme-v02.api.letsencrypt.org/directory\n", + "markdownDescription": "ca: `string` \nModule: `tls.issuance.zerossl` \nThe URL to the CA's ACME directory endpoint. Default:\nhttps://acme-v02.api.letsencrypt.org/directory \n", + "type": "string" + }, + "challenges": { + "description": "challenges: object\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ChallengesConfig\nConfigures the various ACME challenge types.\n\n\nChallengesConfig configures the ACME challenges.\n", + "markdownDescription": "challenges: `object` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ChallengesConfig) \nConfigures the various ACME challenge types.\n\n\nChallengesConfig configures the ACME challenges. \n", + "type": "object", + "properties": { + "bind_host": { + "description": "bind_host: string\nModule: tls.issuance.zerossl\nOptionally customize the host to which a listener\nis bound if required for solving a challenge.\n", + "markdownDescription": "bind_host: `string` \nModule: `tls.issuance.zerossl` \nOptionally customize the host to which a listener\nis bound if required for solving a challenge. \n", + "type": "string" + }, + "dns": { + "description": "dns: object\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#DNSChallengeConfig\nConfigures the ACME DNS challenge. Because this\nchallenge typically requires credentials for\ninterfacing with a DNS provider, this challenge is\nnot enabled by default. This is the only challenge\ntype which does not require a direct connection\nto Caddy from an external server.\n\nNOTE: DNS providers are currently being upgraded,\nand this API is subject to change, but should be\nstabilized soon.\n\n\nDNSChallengeConfig configures the ACME DNS challenge.\n\nNOTE: This API is still experimental and is subject to change.\n", + "markdownDescription": "dns: `object` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#DNSChallengeConfig) \nConfigures the ACME DNS challenge. Because this\nchallenge typically requires credentials for\ninterfacing with a DNS provider, this challenge is\nnot enabled by default. This is the only challenge\ntype which does not require a direct connection\nto Caddy from an external server.\n\nNOTE: DNS providers are currently being upgraded,\nand this API is subject to change, but should be\nstabilized soon.\n\n\nDNSChallengeConfig configures the ACME DNS challenge.\n\nNOTE: This API is still experimental and is subject to change. \n", + "type": "object", + "properties": { + "override_domain": { + "description": "override_domain: string\nModule: tls.issuance.zerossl\nOverride the domain to use for the DNS challenge. This\nis to delegate the challenge to a different domain,\ne.g. one that updates faster or one with a provider API.\n", + "markdownDescription": "override_domain: `string` \nModule: `tls.issuance.zerossl` \nOverride the domain to use for the DNS challenge. This\nis to delegate the challenge to a different domain,\ne.g. one that updates faster or one with a provider API. \n", + "type": "string" + }, + "propagation_delay": { + "description": "propagation_delay: number\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nHow long to wait before starting propagation checks.\nDefault: 0 (no wait).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "propagation_delay: `number` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nHow long to wait before starting propagation checks.\nDefault: 0 (no wait).\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "propagation_timeout": { + "description": "propagation_timeout: number\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nMaximum time to wait for temporary DNS record to appear.\nSet to -1 to disable propagation checks.\nDefault: 2 minutes.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "propagation_timeout: `number` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nMaximum time to wait for temporary DNS record to appear.\nSet to -1 to disable propagation checks.\nDefault: 2 minutes.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + }, + "provider": { + "description": "provider: any\nModule: dns.providers\nThe DNS provider module to use which will manage\nthe DNS records relevant to the ACME challenge.\n", + "markdownDescription": "provider: `any` \nModule: `dns.providers` \nThe DNS provider module to use which will manage\nthe DNS records relevant to the ACME challenge. \n" + }, + "resolvers": { + "description": "resolvers: array\nModule: tls.issuance.zerossl\nCustom DNS resolvers to prefer over system/built-in defaults.\nOften necessary to configure when using split-horizon DNS.\n", + "markdownDescription": "resolvers: `array` \nModule: `tls.issuance.zerossl` \nCustom DNS resolvers to prefer over system/built-in defaults.\nOften necessary to configure when using split-horizon DNS. \n", + "type": "array", + "items": { + "description": "Custom DNS resolvers to prefer over system/built-in defaults.\nOften necessary to configure when using split-horizon DNS.\n", + "markdownDescription": "Custom DNS resolvers to prefer over system/built-in defaults.\nOften necessary to configure when using split-horizon DNS. \n", + "type": "string" + } + }, + "ttl": { + "description": "ttl: number\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration\nThe TTL of the TXT record used for the DNS challenge.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`.\n", + "markdownDescription": "ttl: `number` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Duration) \nThe TTL of the TXT record used for the DNS challenge.\n\n\nDuration can be an integer or a string. An integer is\ninterpreted as nanoseconds. If a string, it is a Go\ntime.Duration value such as `300ms`, `1.5h`, or `2h45m`;\nvalid units are `ns`, `us`/`µs`, `ms`, `s`, `m`, `h`, and `d`. \n", + "type": "number" + } + } + }, + "http": { + "description": "http: object\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#HTTPChallengeConfig\nHTTP configures the ACME HTTP challenge. This\nchallenge is enabled and used automatically\nand by default.\n\n\nHTTPChallengeConfig configures the ACME HTTP challenge.\n", + "markdownDescription": "http: `object` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#HTTPChallengeConfig) \nHTTP configures the ACME HTTP challenge. This\nchallenge is enabled and used automatically\nand by default.\n\n\nHTTPChallengeConfig configures the ACME HTTP challenge. \n", + "type": "object", + "properties": { + "alternate_port": { + "description": "alternate_port: number\nModule: tls.issuance.zerossl\nAn alternate port on which to service this\nchallenge. Note that the HTTP challenge port is\nhard-coded into the spec and cannot be changed,\nso you would have to forward packets from the\nstandard HTTP challenge port to this one.\n", + "markdownDescription": "alternate_port: `number` \nModule: `tls.issuance.zerossl` \nAn alternate port on which to service this\nchallenge. Note that the HTTP challenge port is\nhard-coded into the spec and cannot be changed,\nso you would have to forward packets from the\nstandard HTTP challenge port to this one. \n", + "type": "number" + }, + "disabled": { + "description": "disabled: boolean\nModule: tls.issuance.zerossl\nIf true, the HTTP challenge will be disabled.\n", + "markdownDescription": "disabled: `boolean` \nModule: `tls.issuance.zerossl` \nIf true, the HTTP challenge will be disabled. \n", + "type": "boolean" + } + } + }, + "tls-alpn": { + "description": "tls-alpn: object\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#TLSALPNChallengeConfig\nTLSALPN configures the ACME TLS-ALPN challenge.\nThis challenge is enabled and used automatically\nand by default.\n\n\nTLSALPNChallengeConfig configures the ACME TLS-ALPN challenge.\n", + "markdownDescription": "tls-alpn: `object` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#TLSALPNChallengeConfig) \nTLSALPN configures the ACME TLS-ALPN challenge.\nThis challenge is enabled and used automatically\nand by default.\n\n\nTLSALPNChallengeConfig configures the ACME TLS-ALPN challenge. \n", + "type": "object", + "properties": { + "alternate_port": { + "description": "alternate_port: number\nModule: tls.issuance.zerossl\nAn alternate port on which to service this\nchallenge. Note that the TLS-ALPN challenge port\nis hard-coded into the spec and cannot be changed,\nso you would have to forward packets from the\nstandard TLS-ALPN challenge port to this one.\n", + "markdownDescription": "alternate_port: `number` \nModule: `tls.issuance.zerossl` \nAn alternate port on which to service this\nchallenge. Note that the TLS-ALPN challenge port\nis hard-coded into the spec and cannot be changed,\nso you would have to forward packets from the\nstandard TLS-ALPN challenge port to this one. \n", + "type": "number" + }, + "disabled": { + "description": "disabled: boolean\nModule: tls.issuance.zerossl\nIf true, the TLS-ALPN challenge will be disabled.\n", + "markdownDescription": "disabled: `boolean` \nModule: `tls.issuance.zerossl` \nIf true, the TLS-ALPN challenge will be disabled. \n", + "type": "boolean" + } + } + } + } + }, + "email": { + "description": "email: string\nModule: tls.issuance.zerossl\nYour email address, so the CA can contact you if necessary.\nNot required, but strongly recommended to provide one so\nyou can be reached if there is a problem. Your email is\nnot sent to any Caddy mothership or used for any purpose\nother than ACME transactions.\n", + "markdownDescription": "email: `string` \nModule: `tls.issuance.zerossl` \nYour email address, so the CA can contact you if necessary.\nNot required, but strongly recommended to provide one so\nyou can be reached if there is a problem. Your email is\nnot sent to any Caddy mothership or used for any purpose\nother than ACME transactions. \n", + "type": "string" + }, + "external_account": { + "description": "external_account: object\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/mholt/acmez/acme#EAB\nIf using an ACME CA that requires an external account\nbinding, specify the CA-provided credentials here.\n\n\nEAB (External Account Binding) contains information\nnecessary to bind or map an ACME account to some\nother account known by the CA.\n\nExternal account bindings are \"used to associate an\nACME account with an existing account in a non-ACME\nsystem, such as a CA customer database.\"\n\n\"To enable ACME account binding, the CA operating the\nACME server needs to provide the ACME client with a\nMAC key and a key identifier, using some mechanism\noutside of ACME.\" §7.3.4\n", + "markdownDescription": "external_account: `object` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/mholt/acmez/acme#EAB) \nIf using an ACME CA that requires an external account\nbinding, specify the CA-provided credentials here.\n\n\nEAB (External Account Binding) contains information\nnecessary to bind or map an ACME account to some\nother account known by the CA.\n\nExternal account bindings are \"used to associate an\nACME account with an existing account in a non-ACME\nsystem, such as a CA customer database.\"\n\n\"To enable ACME account binding, the CA operating the\nACME server needs to provide the ACME client with a\nMAC key and a key identifier, using some mechanism\noutside of ACME.\" §7.3.4 \n", + "type": "object", + "properties": { + "key_id": { + "description": "key_id: string\nModule: tls.issuance.zerossl\n\"The key identifier MUST be an ASCII string.\" §7.3.4\n", + "markdownDescription": "key_id: `string` \nModule: `tls.issuance.zerossl` \n\"The key identifier MUST be an ASCII string.\" §7.3.4 \n", + "type": "string" + }, + "mac_key": { + "description": "mac_key: string\nModule: tls.issuance.zerossl\n\"The MAC key SHOULD be provided in base64url-encoded\nform, to maximize compatibility between non-ACME\nprovisioning systems and ACME clients.\" §7.3.4\n", + "markdownDescription": "mac_key: `string` \nModule: `tls.issuance.zerossl` \n\"The MAC key SHOULD be provided in base64url-encoded\nform, to maximize compatibility between non-ACME\nprovisioning systems and ACME clients.\" §7.3.4 \n", + "type": "string" + } + } + }, + "preferred_chains": { + "description": "preferred_chains: object\nModule: tls.issuance.zerossl\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ChainPreference\nPreferences for selecting alternate certificate chains, if offered\nby the CA. By default, the first offered chain will be selected.\nIf configured, the chains may be sorted and the first matching chain\nwill be selected.\n\n\nChainPreference describes the client's preferred certificate chain,\nuseful if the CA offers alternate chains. The first matching chain\nwill be selected.\n", + "markdownDescription": "preferred_chains: `object` \nModule: `tls.issuance.zerossl` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls#ChainPreference) \nPreferences for selecting alternate certificate chains, if offered\nby the CA. By default, the first offered chain will be selected.\nIf configured, the chains may be sorted and the first matching chain\nwill be selected.\n\n\nChainPreference describes the client's preferred certificate chain,\nuseful if the CA offers alternate chains. The first matching chain\nwill be selected. \n", + "type": "object", + "properties": { + "any_common_name": { + "description": "any_common_name: array\nModule: tls.issuance.zerossl\nSelect first chain that has any issuer with one\nof these common names.\n", + "markdownDescription": "any_common_name: `array` \nModule: `tls.issuance.zerossl` \nSelect first chain that has any issuer with one\nof these common names. \n", + "type": "array", + "items": { + "description": "Select first chain that has any issuer with one\nof these common names.\n", + "markdownDescription": "Select first chain that has any issuer with one\nof these common names. \n", + "type": "string" + } + }, + "root_common_name": { + "description": "root_common_name: array\nModule: tls.issuance.zerossl\nSelect first chain having a root with one of\nthese common names.\n", + "markdownDescription": "root_common_name: `array` \nModule: `tls.issuance.zerossl` \nSelect first chain having a root with one of\nthese common names. \n", + "type": "array", + "items": { + "description": "Select first chain having a root with one of\nthese common names.\n", + "markdownDescription": "Select first chain having a root with one of\nthese common names. \n", + "type": "string" + } + }, + "smallest": { + "description": "smallest: boolean\nModule: tls.issuance.zerossl\nPrefer chains with the fewest number of bytes.\n", + "markdownDescription": "smallest: `boolean` \nModule: `tls.issuance.zerossl` \nPrefer chains with the fewest number of bytes. \n", + "type": "boolean" + } + } + }, + "test_ca": { + "description": "test_ca: string\nModule: tls.issuance.zerossl\nThe URL to the test CA's ACME directory endpoint.\nThis endpoint is only used during retries if there\nis a failure using the primary CA. Default:\nhttps://acme-staging-v02.api.letsencrypt.org/directory\n", + "markdownDescription": "test_ca: `string` \nModule: `tls.issuance.zerossl` \nThe URL to the test CA's ACME directory endpoint.\nThis endpoint is only used during retries if there\nis a failure using the primary CA. Default:\nhttps://acme-staging-v02.api.letsencrypt.org/directory \n", + "type": "string" + }, + "trusted_roots_pem_files": { + "description": "trusted_roots_pem_files: array\nModule: tls.issuance.zerossl\nAn array of files of CA certificates to accept when connecting to the\nACME CA. Generally, you should only use this if the ACME CA endpoint\nis internal or for development/testing purposes.\n", + "markdownDescription": "trusted_roots_pem_files: `array` \nModule: `tls.issuance.zerossl` \nAn array of files of CA certificates to accept when connecting to the\nACME CA. Generally, you should only use this if the ACME CA endpoint\nis internal or for development/testing purposes. \n", + "type": "array", + "items": { + "description": "An array of files of CA certificates to accept when connecting to the\nACME CA. Generally, you should only use this if the ACME CA endpoint\nis internal or for development/testing purposes.\n", + "markdownDescription": "An array of files of CA certificates to accept when connecting to the\nACME CA. Generally, you should only use this if the ACME CA endpoint\nis internal or for development/testing purposes. \n", + "type": "string" + } + } + } + }, + "tls.stek.distributed": { + "description": "distributed: object\nModule: tls.stek.distributed\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls/distributedstek#Provider\nProvider implements a distributed STEK provider. This\nmodule will obtain STEKs from a storage module instead\nof generating STEKs internally. This allows STEKs to be\ncoordinated, improving TLS session resumption in a cluster.\n\n", + "markdownDescription": "distributed: `object` \nModule: `tls.stek.distributed` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2/modules/caddytls/distributedstek#Provider) \nProvider implements a distributed STEK provider. This\nmodule will obtain STEKs from a storage module instead\nof generating STEKs internally. This allows STEKs to be\ncoordinated, improving TLS session resumption in a cluster.\n \n", + "type": "object", + "properties": { + "storage": { + "description": "storage: object\nModule: caddy.storage\nThe storage module wherein to store and obtain session\nticket keys. If unset, Caddy's default/global-configured\nstorage module will be used.\n", + "markdownDescription": "storage: `object` \nModule: `caddy.storage` \nThe storage module wherein to store and obtain session\nticket keys. If unset, Caddy's default/global-configured\nstorage module will be used. \n", + "type": "object", + "required": [ + "module" + ], + "allOf": [ + { + "if": { + "properties": { + "module": { + "const": "consul" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.storage.consul" + } + }, + { + "if": { + "properties": { + "module": { + "const": "file_system" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.storage.file_system" + } + }, + { + "properties": { + "module": { + "description": "key to identify storage module.\nmodule: string\nModule: caddy.storage", + "markdownDescription": "key to identify `storage` module. \nmodule: `string` \nModule: `caddy.storage`", + "type": "string", + "enum": [ + "consul", + "file_system" + ] + } + } + } + ] + } + } + }, + "tls.stek.standard": { + "description": "standard: object\nModule: tls.stek.standard", + "markdownDescription": "standard: `object` \nModule: `tls.stek.standard`", + "type": "object" + } + }, + "properties": { + "admin": { + "description": "admin: object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminConfig\nAdminConfig configures Caddy's API endpoint, which is used\nto manage Caddy while it is running.\n\n", + "markdownDescription": "admin: `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminConfig) \nAdminConfig configures Caddy's API endpoint, which is used\nto manage Caddy while it is running.\n \n", + "type": "object", + "properties": { + "config": { + "description": "config: object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ConfigSettings\nOptions pertaining to configuration management.\n\n\nConfigSettings configures the management of configuration.\n", + "markdownDescription": "config: `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ConfigSettings) \nOptions pertaining to configuration management.\n\n\nConfigSettings configures the management of configuration. \n", + "type": "object", + "properties": { + "load": { + "description": "load: object\nModule: caddy.config_loaders\nLoads a configuration to use. This is helpful if your configs are\nmanaged elsewhere, and you want Caddy to pull its config dynamically\nwhen it starts. The pulled config completely replaces the current\none, just like any other config load. It is an error if a pulled\nconfig is configured to pull another config.\n\nEXPERIMENTAL: Subject to change.\n", + "markdownDescription": "load: `object` \nModule: `caddy.config_loaders` \nLoads a configuration to use. This is helpful if your configs are\nmanaged elsewhere, and you want Caddy to pull its config dynamically\nwhen it starts. The pulled config completely replaces the current\none, just like any other config load. It is an error if a pulled\nconfig is configured to pull another config.\n\nEXPERIMENTAL: Subject to change. \n", + "type": "object", + "required": [ + "module" + ], + "allOf": [ + { + "if": { + "properties": { + "module": { + "const": "http" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.config_loaders.http" + } + }, + { + "properties": { + "module": { + "description": "key to identify load module.\nmodule: string\nModule: caddy.config_loaders", + "markdownDescription": "key to identify `load` module. \nmodule: `string` \nModule: `caddy.config_loaders`", + "type": "string", + "enum": [ + "http" + ] + } + } + } + ] + }, + "load_delay": { + "description": "load_delay: number", + "markdownDescription": "load_delay: `number`", + "type": "number" + }, + "persist": { + "description": "persist: boolean\nWhether to keep a copy of the active config on disk. Default is true.\nNote that \"pulled\" dynamic configs (using the neighboring \"load\" module)\nare not persisted; only configs that are pushed to Caddy get persisted.\n", + "markdownDescription": "persist: `boolean` \nWhether to keep a copy of the active config on disk. Default is true.\nNote that \"pulled\" dynamic configs (using the neighboring \"load\" module)\nare not persisted; only configs that are pushed to Caddy get persisted. \n", + "type": "boolean" + } + } + }, + "disabled": { + "description": "disabled: boolean\nIf true, the admin endpoint will be completely disabled.\nNote that this makes any runtime changes to the config\nimpossible, since the interface to do so is through the\nadmin endpoint.\n", + "markdownDescription": "disabled: `boolean` \nIf true, the admin endpoint will be completely disabled.\nNote that this makes any runtime changes to the config\nimpossible, since the interface to do so is through the\nadmin endpoint. \n", + "type": "boolean" + }, + "enforce_origin": { + "description": "enforce_origin: boolean\nIf true, CORS headers will be emitted, and requests to the\nAPI will be rejected if their `Host` and `Origin` headers\ndo not match the expected value(s). Use `origins` to\ncustomize which origins/hosts are allowed. If `origins` is\nnot set, the listen address is the only value allowed by\ndefault. Enforced only on local (plaintext) endpoint.\n", + "markdownDescription": "enforce_origin: `boolean` \nIf true, CORS headers will be emitted, and requests to the\nAPI will be rejected if their `Host` and `Origin` headers\ndo not match the expected value(s). Use `origins` to\ncustomize which origins/hosts are allowed. If `origins` is\nnot set, the listen address is the only value allowed by\ndefault. Enforced only on local (plaintext) endpoint. \n", + "type": "boolean" + }, + "identity": { + "description": "identity: object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#IdentityConfig\nOptions that establish this server's identity. Identity refers to\ncredentials which can be used to uniquely identify and authenticate\nthis server instance. This is required if remote administration is\nenabled (but does not require remote administration to be enabled).\nDefault: no identity management.\n\n\nIdentityConfig configures management of this server's identity. An identity\nconsists of credentials that uniquely verify this instance; for example,\nTLS certificates (public + private key pairs).\n", + "markdownDescription": "identity: `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#IdentityConfig) \nOptions that establish this server's identity. Identity refers to\ncredentials which can be used to uniquely identify and authenticate\nthis server instance. This is required if remote administration is\nenabled (but does not require remote administration to be enabled).\nDefault: no identity management.\n\n\nIdentityConfig configures management of this server's identity. An identity\nconsists of credentials that uniquely verify this instance; for example,\nTLS certificates (public + private key pairs). \n", + "type": "object", + "properties": { + "identifiers": { + "description": "identifiers: array\nList of names or IP addresses which refer to this server.\nCertificates will be obtained for these identifiers so\nsecure TLS connections can be made using them.\n", + "markdownDescription": "identifiers: `array` \nList of names or IP addresses which refer to this server.\nCertificates will be obtained for these identifiers so\nsecure TLS connections can be made using them. \n", + "type": "array", + "items": { + "description": "List of names or IP addresses which refer to this server.\nCertificates will be obtained for these identifiers so\nsecure TLS connections can be made using them.\n", + "markdownDescription": "List of names or IP addresses which refer to this server.\nCertificates will be obtained for these identifiers so\nsecure TLS connections can be made using them. \n", + "type": "string" + } + }, + "issuers": { + "description": "issuers: array\nModule: tls.issuance\nIssuers that can provide this admin endpoint its identity\ncertificate(s). Default: ACME issuers configured for\nZeroSSL and Let's Encrypt. Be sure to change this if you\nrequire credentials for private identifiers.\n", + "markdownDescription": "issuers: `array` \nModule: `tls.issuance` \nIssuers that can provide this admin endpoint its identity\ncertificate(s). Default: ACME issuers configured for\nZeroSSL and Let's Encrypt. Be sure to change this if you\nrequire credentials for private identifiers. \n", + "type": "array", + "items": { + "description": "Issuers that can provide this admin endpoint its identity\ncertificate(s). Default: ACME issuers configured for\nZeroSSL and Let's Encrypt. Be sure to change this if you\nrequire credentials for private identifiers.\n", + "markdownDescription": "Issuers that can provide this admin endpoint its identity\ncertificate(s). Default: ACME issuers configured for\nZeroSSL and Let's Encrypt. Be sure to change this if you\nrequire credentials for private identifiers. \n", + "required": [ + "module" + ], + "allOf": [ + { + "if": { + "properties": { + "module": { + "const": "acme" + } + } + }, + "then": { + "$ref": "#/definitions/tls.issuance.acme" + } + }, + { + "if": { + "properties": { + "module": { + "const": "internal" + } + } + }, + "then": { + "$ref": "#/definitions/tls.issuance.internal" + } + }, + { + "if": { + "properties": { + "module": { + "const": "zerossl" + } + } + }, + "then": { + "$ref": "#/definitions/tls.issuance.zerossl" + } + }, + { + "properties": { + "module": { + "description": "key to identify issuers module.\nmodule: string\nModule: tls.issuance", + "markdownDescription": "key to identify `issuers` module. \nmodule: `string` \nModule: `tls.issuance`", + "type": "string", + "enum": [ + "acme", + "internal", + "zerossl" + ] + } + } + } + ] + } + } + } + }, + "listen": { + "description": "listen: string\nThe address to which the admin endpoint's listener should\nbind itself. Can be any single network address that can be\nparsed by Caddy. Default: localhost:2019\n", + "markdownDescription": "listen: `string` \nThe address to which the admin endpoint's listener should\nbind itself. Can be any single network address that can be\nparsed by Caddy. Default: localhost:2019 \n", + "type": "string" + }, + "origins": { + "description": "origins: array\nThe list of allowed origins/hosts for API requests. Only needed\nif accessing the admin endpoint from a host different from the\nsocket's network interface or if `enforce_origin` is true. If not\nset, the listener address will be the default value. If set but\nempty, no origins will be allowed. Enforced only on local\n(plaintext) endpoint.\n", + "markdownDescription": "origins: `array` \nThe list of allowed origins/hosts for API requests. Only needed\nif accessing the admin endpoint from a host different from the\nsocket's network interface or if `enforce_origin` is true. If not\nset, the listener address will be the default value. If set but\nempty, no origins will be allowed. Enforced only on local\n(plaintext) endpoint. \n", + "type": "array", + "items": { + "description": "The list of allowed origins/hosts for API requests. Only needed\nif accessing the admin endpoint from a host different from the\nsocket's network interface or if `enforce_origin` is true. If not\nset, the listener address will be the default value. If set but\nempty, no origins will be allowed. Enforced only on local\n(plaintext) endpoint.\n", + "markdownDescription": "The list of allowed origins/hosts for API requests. Only needed\nif accessing the admin endpoint from a host different from the\nsocket's network interface or if `enforce_origin` is true. If not\nset, the listener address will be the default value. If set but\nempty, no origins will be allowed. Enforced only on local\n(plaintext) endpoint. \n", + "type": "string" + } + }, + "remote": { + "description": "remote: object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#RemoteAdmin\nOptions pertaining to remote administration. By default, remote\nadministration is disabled. If enabled, identity management must\nalso be configured, as that is how the endpoint is secured.\nSee the neighboring \"identity\" object.\n\nEXPERIMENTAL: This feature is subject to change.\n\n\nRemoteAdmin enables and configures remote administration. If enabled,\na secure listener enforcing mutual TLS authentication will be started\non a different port from the standard plaintext admin server.\n\nThis endpoint is secured using identity management, which must be\nconfigured separately (because identity management does not depend\non remote administration). See the admin/identity config struct.\n\nEXPERIMENTAL: Subject to change.\n", + "markdownDescription": "remote: `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#RemoteAdmin) \nOptions pertaining to remote administration. By default, remote\nadministration is disabled. If enabled, identity management must\nalso be configured, as that is how the endpoint is secured.\nSee the neighboring \"identity\" object.\n\nEXPERIMENTAL: This feature is subject to change.\n\n\nRemoteAdmin enables and configures remote administration. If enabled,\na secure listener enforcing mutual TLS authentication will be started\non a different port from the standard plaintext admin server.\n\nThis endpoint is secured using identity management, which must be\nconfigured separately (because identity management does not depend\non remote administration). See the admin/identity config struct.\n\nEXPERIMENTAL: Subject to change. \n", + "type": "object", + "properties": { + "access_control": { + "description": "access_control: array\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminAccess\nList of access controls for this secure admin endpoint.\nThis configures TLS mutual authentication (i.e. authorized\nclient certificates), but also application-layer permissions\nlike which paths and methods each identity is authorized for.\n\n\nAdminAccess specifies what permissions an identity or group\nof identities are granted.\n", + "markdownDescription": "access_control: `array` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminAccess) \nList of access controls for this secure admin endpoint.\nThis configures TLS mutual authentication (i.e. authorized\nclient certificates), but also application-layer permissions\nlike which paths and methods each identity is authorized for.\n\n\nAdminAccess specifies what permissions an identity or group\nof identities are granted. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminAccess\nList of access controls for this secure admin endpoint.\nThis configures TLS mutual authentication (i.e. authorized\nclient certificates), but also application-layer permissions\nlike which paths and methods each identity is authorized for.\n\n\nAdminAccess specifies what permissions an identity or group\nof identities are granted.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminAccess) \nList of access controls for this secure admin endpoint.\nThis configures TLS mutual authentication (i.e. authorized\nclient certificates), but also application-layer permissions\nlike which paths and methods each identity is authorized for.\n\n\nAdminAccess specifies what permissions an identity or group\nof identities are granted. \n", + "type": "object", + "properties": { + "permissions": { + "description": "permissions: array\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminPermissions\nLimits what the associated identities are allowed to do.\nIf unspecified, all permissions are granted.\n\n\nAdminPermissions specifies what kinds of requests are allowed\nto be made to the admin endpoint.\n", + "markdownDescription": "permissions: `array` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminPermissions) \nLimits what the associated identities are allowed to do.\nIf unspecified, all permissions are granted.\n\n\nAdminPermissions specifies what kinds of requests are allowed\nto be made to the admin endpoint. \n", + "type": "array", + "items": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminPermissions\nLimits what the associated identities are allowed to do.\nIf unspecified, all permissions are granted.\n\n\nAdminPermissions specifies what kinds of requests are allowed\nto be made to the admin endpoint.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#AdminPermissions) \nLimits what the associated identities are allowed to do.\nIf unspecified, all permissions are granted.\n\n\nAdminPermissions specifies what kinds of requests are allowed\nto be made to the admin endpoint. \n", + "type": "object", + "properties": { + "methods": { + "description": "methods: array\nThe HTTP methods allowed for the given paths.\n", + "markdownDescription": "methods: `array` \nThe HTTP methods allowed for the given paths. \n", + "type": "array", + "items": { + "description": "The HTTP methods allowed for the given paths.\n", + "markdownDescription": "The HTTP methods allowed for the given paths. \n", + "type": "string" + } + }, + "paths": { + "description": "paths: array\nThe API paths allowed. Paths are simple prefix matches.\nAny subpath of the specified paths will be allowed.\n", + "markdownDescription": "paths: `array` \nThe API paths allowed. Paths are simple prefix matches.\nAny subpath of the specified paths will be allowed. \n", + "type": "array", + "items": { + "description": "The API paths allowed. Paths are simple prefix matches.\nAny subpath of the specified paths will be allowed.\n", + "markdownDescription": "The API paths allowed. Paths are simple prefix matches.\nAny subpath of the specified paths will be allowed. \n", + "type": "string" + } + } + } + } + }, + "public_keys": { + "description": "public_keys: array\nBase64-encoded DER certificates containing public keys to accept.\n(The contents of PEM certificate blocks are base64-encoded DER.)\nAny of these public keys can appear in any part of a verified chain.\n", + "markdownDescription": "public_keys: `array` \nBase64-encoded DER certificates containing public keys to accept.\n(The contents of PEM certificate blocks are base64-encoded DER.)\nAny of these public keys can appear in any part of a verified chain. \n", + "type": "array", + "items": { + "description": "Base64-encoded DER certificates containing public keys to accept.\n(The contents of PEM certificate blocks are base64-encoded DER.)\nAny of these public keys can appear in any part of a verified chain.\n", + "markdownDescription": "Base64-encoded DER certificates containing public keys to accept.\n(The contents of PEM certificate blocks are base64-encoded DER.)\nAny of these public keys can appear in any part of a verified chain. \n", + "type": "string" + } + } + } + } + }, + "listen": { + "description": "listen: string\nThe address on which to start the secure listener.\nDefault: :2021\n", + "markdownDescription": "listen: `string` \nThe address on which to start the secure listener.\nDefault: :2021 \n", + "type": "string" + } + } + } + } + }, + "apps": { + "description": "apps: object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap\nAppsRaw are the apps that Caddy will load and run. The\napp module name is the key, and the app's config is the\nassociated value.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage.\n", + "markdownDescription": "apps: `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#ModuleMap) \nAppsRaw are the apps that Caddy will load and run. The\napp module name is the key, and the app's config is the\nassociated value.\n\n\nModuleMap is a map that can contain multiple modules,\nwhere the map key is the module's name. (The namespace\nis usually read from an associated field's struct tag.)\nBecause the module's name is given as the key in a\nmodule map, the name does not have to be given in the\njson.RawMessage. \n", + "type": "object", + "properties": { + "http": { + "$ref": "#/definitions/http" + }, + "layer4": { + "$ref": "#/definitions/layer4" + }, + "pki": { + "$ref": "#/definitions/pki" + }, + "tls": { + "$ref": "#/definitions/tls" + } + } + }, + "logging": { + "description": "logging: object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#Logging\nLogging facilitates logging within Caddy. The default log is\ncalled \"default\" and you can customize it. You can also define\nadditional logs.\n\nBy default, all logs at INFO level and higher are written to\nstandard error (\"stderr\" writer) in a human-readable format\n(\"console\" encoder if stdout is an interactive terminal, \"json\"\nencoder otherwise).\n\nAll defined logs accept all log entries by default, but you\ncan filter by level and module/logger names. A logger's name\nis the same as the module's name, but a module may append to\nlogger names for more specificity. For example, you can\nfilter logs emitted only by HTTP handlers using the name\n\"http.handlers\", because all HTTP handler module names have\nthat prefix.\n\nCaddy logs (except the sink) are zero-allocation, so they are\nvery high-performing in terms of memory and CPU time. Enabling\nsampling can further increase throughput on extremely high-load\nservers.\n\n", + "markdownDescription": "logging: `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#Logging) \nLogging facilitates logging within Caddy. The default log is\ncalled \"default\" and you can customize it. You can also define\nadditional logs.\n\nBy default, all logs at INFO level and higher are written to\nstandard error (\"stderr\" writer) in a human-readable format\n(\"console\" encoder if stdout is an interactive terminal, \"json\"\nencoder otherwise).\n\nAll defined logs accept all log entries by default, but you\ncan filter by level and module/logger names. A logger's name\nis the same as the module's name, but a module may append to\nlogger names for more specificity. For example, you can\nfilter logs emitted only by HTTP handlers using the name\n\"http.handlers\", because all HTTP handler module names have\nthat prefix.\n\nCaddy logs (except the sink) are zero-allocation, so they are\nvery high-performing in terms of memory and CPU time. Enabling\nsampling can further increase throughput on extremely high-load\nservers.\n \n", + "type": "object", + "properties": { + "logs": { + "description": "logs: object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#CustomLog\nLogs are your logs, keyed by an arbitrary name of your\nchoosing. The default log can be customized by defining\na log called \"default\". You can further define other logs\nand filter what kinds of entries they accept.\n\n\nCustomLog represents a custom logger configuration.\n\nBy default, a log will emit all log entries. Some entries\nwill be skipped if sampling is enabled. Further, the Include\nand Exclude parameters define which loggers (by name) are\nallowed or rejected from emitting in this log. If both Include\nand Exclude are populated, their values must be mutually\nexclusive, and longer namespaces have priority. If neither\nare populated, all logs are emitted.\n", + "markdownDescription": "logs: `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#CustomLog) \nLogs are your logs, keyed by an arbitrary name of your\nchoosing. The default log can be customized by defining\na log called \"default\". You can further define other logs\nand filter what kinds of entries they accept.\n\n\nCustomLog represents a custom logger configuration.\n\nBy default, a log will emit all log entries. Some entries\nwill be skipped if sampling is enabled. Further, the Include\nand Exclude parameters define which loggers (by name) are\nallowed or rejected from emitting in this log. If both Include\nand Exclude are populated, their values must be mutually\nexclusive, and longer namespaces have priority. If neither\nare populated, all logs are emitted. \n", + "type": "object", + "additionalProperties": { + "description": "https://pkg.go.dev/github.com/caddyserver/caddy/v2#CustomLog\nLogs are your logs, keyed by an arbitrary name of your\nchoosing. The default log can be customized by defining\na log called \"default\". You can further define other logs\nand filter what kinds of entries they accept.\n\n\nCustomLog represents a custom logger configuration.\n\nBy default, a log will emit all log entries. Some entries\nwill be skipped if sampling is enabled. Further, the Include\nand Exclude parameters define which loggers (by name) are\nallowed or rejected from emitting in this log. If both Include\nand Exclude are populated, their values must be mutually\nexclusive, and longer namespaces have priority. If neither\nare populated, all logs are emitted.\n", + "markdownDescription": "[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#CustomLog) \nLogs are your logs, keyed by an arbitrary name of your\nchoosing. The default log can be customized by defining\na log called \"default\". You can further define other logs\nand filter what kinds of entries they accept.\n\n\nCustomLog represents a custom logger configuration.\n\nBy default, a log will emit all log entries. Some entries\nwill be skipped if sampling is enabled. Further, the Include\nand Exclude parameters define which loggers (by name) are\nallowed or rejected from emitting in this log. If both Include\nand Exclude are populated, their values must be mutually\nexclusive, and longer namespaces have priority. If neither\nare populated, all logs are emitted. \n", + "properties": { + "encoder": { + "description": "encoder: object\nModule: caddy.logging.encoders\nThe encoder is how the log entries are formatted or encoded.\n", + "markdownDescription": "encoder: `object` \nModule: `caddy.logging.encoders` \nThe encoder is how the log entries are formatted or encoded. \n", + "type": "object", + "required": [ + "format" + ], + "allOf": [ + { + "if": { + "properties": { + "format": { + "const": "console" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.console" + } + }, + { + "if": { + "properties": { + "format": { + "const": "filter" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.filter" + } + }, + { + "if": { + "properties": { + "format": { + "const": "json" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.encoders.json" + } + }, + { + "properties": { + "format": { + "description": "key to identify encoder module.\nformat: string\nModule: caddy.logging.encoders", + "markdownDescription": "key to identify `encoder` module. \nformat: `string` \nModule: `caddy.logging.encoders`", + "type": "string", + "enum": [ + "console", + "filter", + "json" + ] + } + } + } + ] + }, + "exclude": { + "description": "exclude: array\nExclude defines the names of loggers that should be\nskipped by this log. For example, to exclude only\nHTTP access logs, you would exclude \"http.log.access\".\n", + "markdownDescription": "exclude: `array` \nExclude defines the names of loggers that should be\nskipped by this log. For example, to exclude only\nHTTP access logs, you would exclude \"http.log.access\". \n", + "type": "array", + "items": { + "description": "Exclude defines the names of loggers that should be\nskipped by this log. For example, to exclude only\nHTTP access logs, you would exclude \"http.log.access\".\n", + "markdownDescription": "Exclude defines the names of loggers that should be\nskipped by this log. For example, to exclude only\nHTTP access logs, you would exclude \"http.log.access\". \n", + "type": "string" + } + }, + "include": { + "description": "include: array\nInclude defines the names of loggers to emit in this\nlog. For example, to include only logs emitted by the\nadmin API, you would include \"admin.api\".\n", + "markdownDescription": "include: `array` \nInclude defines the names of loggers to emit in this\nlog. For example, to include only logs emitted by the\nadmin API, you would include \"admin.api\". \n", + "type": "array", + "items": { + "description": "Include defines the names of loggers to emit in this\nlog. For example, to include only logs emitted by the\nadmin API, you would include \"admin.api\".\n", + "markdownDescription": "Include defines the names of loggers to emit in this\nlog. For example, to include only logs emitted by the\nadmin API, you would include \"admin.api\". \n", + "type": "string" + } + }, + "level": { + "description": "level: string\nLevel is the minimum level to emit, and is inclusive.\nPossible levels: DEBUG, INFO, WARN, ERROR, PANIC, and FATAL\n", + "markdownDescription": "level: `string` \nLevel is the minimum level to emit, and is inclusive.\nPossible levels: DEBUG, INFO, WARN, ERROR, PANIC, and FATAL \n", + "type": "string" + }, + "sampling": { + "description": "sampling: object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#LogSampling\nSampling configures log entry sampling. If enabled,\nonly some log entries will be emitted. This is useful\nfor improving performance on extremely high-pressure\nservers.\n\n\nLogSampling configures log entry sampling.\n", + "markdownDescription": "sampling: `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#LogSampling) \nSampling configures log entry sampling. If enabled,\nonly some log entries will be emitted. This is useful\nfor improving performance on extremely high-pressure\nservers.\n\n\nLogSampling configures log entry sampling. \n", + "type": "object", + "properties": { + "first": { + "description": "first: number\nLog this many entries within a given level and\nmessage for each interval.\n", + "markdownDescription": "first: `number` \nLog this many entries within a given level and\nmessage for each interval. \n", + "type": "number" + }, + "interval": { + "description": "interval: number\nhttps://pkg.go.dev/time#Duration\nThe window over which to conduct sampling.\n\n\nA Duration represents the elapsed time between two instants\nas an int64 nanosecond count. The representation limits the\nlargest representable duration to approximately 290 years.\n", + "markdownDescription": "interval: `number` \n[godoc](https://pkg.go.dev/time#Duration) \nThe window over which to conduct sampling.\n\n\nA Duration represents the elapsed time between two instants\nas an int64 nanosecond count. The representation limits the\nlargest representable duration to approximately 290 years. \n", + "type": "number" + }, + "thereafter": { + "description": "thereafter: number\nIf more entries with the same level and message\nare seen during the same interval, keep one in\nthis many entries until the end of the interval.\n", + "markdownDescription": "thereafter: `number` \nIf more entries with the same level and message\nare seen during the same interval, keep one in\nthis many entries until the end of the interval. \n", + "type": "number" + } + } + }, + "writer": { + "description": "writer: object\nModule: caddy.logging.writers\nThe writer defines where log entries are emitted.\n", + "markdownDescription": "writer: `object` \nModule: `caddy.logging.writers` \nThe writer defines where log entries are emitted. \n", + "type": "object", + "required": [ + "output" + ], + "allOf": [ + { + "if": { + "properties": { + "output": { + "const": "discard" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.discard" + } + }, + { + "if": { + "properties": { + "output": { + "const": "file" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.file" + } + }, + { + "if": { + "properties": { + "output": { + "const": "net" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.net" + } + }, + { + "if": { + "properties": { + "output": { + "const": "stderr" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.stderr" + } + }, + { + "if": { + "properties": { + "output": { + "const": "stdout" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.stdout" + } + }, + { + "properties": { + "output": { + "description": "key to identify writer module.\noutput: string\nModule: caddy.logging.writers", + "markdownDescription": "key to identify `writer` module. \noutput: `string` \nModule: `caddy.logging.writers`", + "type": "string", + "enum": [ + "discard", + "file", + "net", + "stderr", + "stdout" + ] + } + } + } + ] + } + } + } + }, + "sink": { + "description": "sink: object\nhttps://pkg.go.dev/github.com/caddyserver/caddy/v2#StandardLibLog\nSink is the destination for all unstructured logs emitted\nfrom Go's standard library logger. These logs are common\nin dependencies that are not designed specifically for use\nin Caddy. Because it is global and unstructured, the sink\nlacks most advanced features and customizations.\n\n\nStandardLibLog configures the default Go standard library\nglobal logger in the log package. This is necessary because\nmodule dependencies which are not built specifically for\nCaddy will use the standard logger. This is also known as\nthe \"sink\" logger.\n", + "markdownDescription": "sink: `object` \n[godoc](https://pkg.go.dev/github.com/caddyserver/caddy/v2#StandardLibLog) \nSink is the destination for all unstructured logs emitted\nfrom Go's standard library logger. These logs are common\nin dependencies that are not designed specifically for use\nin Caddy. Because it is global and unstructured, the sink\nlacks most advanced features and customizations.\n\n\nStandardLibLog configures the default Go standard library\nglobal logger in the log package. This is necessary because\nmodule dependencies which are not built specifically for\nCaddy will use the standard logger. This is also known as\nthe \"sink\" logger. \n", + "type": "object", + "properties": { + "writer": { + "description": "writer: object\nModule: caddy.logging.writers\nThe module that writes out log entries for the sink.\n", + "markdownDescription": "writer: `object` \nModule: `caddy.logging.writers` \nThe module that writes out log entries for the sink. \n", + "type": "object", + "required": [ + "output" + ], + "allOf": [ + { + "if": { + "properties": { + "output": { + "const": "net" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.net" + } + }, + { + "if": { + "properties": { + "output": { + "const": "stderr" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.stderr" + } + }, + { + "if": { + "properties": { + "output": { + "const": "stdout" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.stdout" + } + }, + { + "if": { + "properties": { + "output": { + "const": "discard" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.discard" + } + }, + { + "if": { + "properties": { + "output": { + "const": "file" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.logging.writers.file" + } + }, + { + "properties": { + "output": { + "description": "key to identify writer module.\noutput: string\nModule: caddy.logging.writers", + "markdownDescription": "key to identify `writer` module. \noutput: `string` \nModule: `caddy.logging.writers`", + "type": "string", + "enum": [ + "net", + "stderr", + "stdout", + "discard", + "file" + ] + } + } + } + ] + } + } + } + } + }, + "storage": { + "description": "storage: object\nModule: caddy.storage\nStorageRaw is a storage module that defines how/where Caddy\nstores assets (such as TLS certificates). The default storage\nmodule is `caddy.storage.file_system` (the local file system),\nand the default path\n[depends on the OS and environment](/docs/conventions#data-directory).\n", + "markdownDescription": "storage: `object` \nModule: `caddy.storage` \nStorageRaw is a storage module that defines how/where Caddy\nstores assets (such as TLS certificates). The default storage\nmodule is `caddy.storage.file_system` (the local file system),\nand the default path\n[depends on the OS and environment](/docs/conventions#data-directory). \n", + "type": "object", + "required": [ + "module" + ], + "allOf": [ + { + "if": { + "properties": { + "module": { + "const": "consul" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.storage.consul" + } + }, + { + "if": { + "properties": { + "module": { + "const": "file_system" + } + } + }, + "then": { + "$ref": "#/definitions/caddy.storage.file_system" + } + }, + { + "properties": { + "module": { + "description": "key to identify storage module.\nmodule: string\nModule: caddy.storage", + "markdownDescription": "key to identify `storage` module. \nmodule: `string` \nModule: `caddy.storage`", + "type": "string", + "enum": [ + "consul", + "file_system" + ] + } + } + } + ] + } + }, + "additionalItems": true +} diff --git a/modules/terminal-life/.local/share/scripts/base16.sh b/modules/terminal-life/.local/share/scripts/base16.sh new file mode 100644 index 0000000..ee33516 --- /dev/null +++ b/modules/terminal-life/.local/share/scripts/base16.sh @@ -0,0 +1,126 @@ +#!/bin/sh +# base16-shell (https://github.com/chriskempson/base16-shell) +# Base16 Shell template by Chris Kempson (http://chriskempson.com) +# Burn scheme by Benjamin Bädorf + +color00="1a/18/1a" # Base 00 - Black +color01="f8/5e/84" # Base 08 - Red +color02="9e/cd/6f" # Base 0B - Green +color03="e5/c4/63" # Base 0A - Yellow +color04="7a/cc/d7" # Base 0D - Blue +color05="ab/9d/f2" # Base 0E - Magenta +color06="ef/90/62" # Base 0C - Cyan +color07="e3/e1/e4" # Base 05 - White +color08="94/94/94" # Base 03 - Bright Black +color09=$color01 # Base 08 - Bright Red +color10=$color02 # Base 0B - Bright Green +color11=$color03 # Base 0A - Bright Yellow +color12=$color04 # Base 0D - Bright Blue +color13=$color05 # Base 0E - Bright Magenta +color14=$color06 # Base 0C - Bright Cyan +color15="ff/5f/5f" # Base 07 - Bright White +color16="df/59/23" # Base 09 +color17="d7/00/00" # Base 0F +color18="2d/2a/2e" # Base 01 +color19="30/30/30" # Base 02 +color20="d3/d1/d4" # Base 04 +color21="30/30/30" # Base 06 +color_foreground="e3/e1/e4" # Base 05 +color_background="1a/18/1a" # Base 00 + +if [ -n "$TMUX" ]; then + # Tell tmux to pass the escape sequences through + # (Source: http://permalink.gmane.org/gmane.comp.terminal-emulators.tmux.user/1324) + put_template() { printf '\033Ptmux;\033\033]4;%d;rgb:%s\033\033\\\033\\' $@; } + put_template_var() { printf '\033Ptmux;\033\033]%d;rgb:%s\033\033\\\033\\' $@; } + put_template_custom() { printf '\033Ptmux;\033\033]%s%s\033\033\\\033\\' $@; } +elif [ "${TERM%%[-.]*}" = "screen" ]; then + # GNU screen (screen, screen-256color, screen-256color-bce) + put_template() { printf '\033P\033]4;%d;rgb:%s\007\033\\' $@; } + put_template_var() { printf '\033P\033]%d;rgb:%s\007\033\\' $@; } + put_template_custom() { printf '\033P\033]%s%s\007\033\\' $@; } +elif [ "${TERM%%-*}" = "linux" ]; then + put_template() { [ $1 -lt 16 ] && printf "\e]P%x%s" $1 $(echo $2 | sed 's/\///g'); } + put_template_var() { true; } + put_template_custom() { true; } +else + put_template() { printf '\033]4;%d;rgb:%s\033\\' $@; } + put_template_var() { printf '\033]%d;rgb:%s\033\\' $@; } + put_template_custom() { printf '\033]%s%s\033\\' $@; } +fi + +# 16 color space +put_template 0 $color00 +put_template 1 $color01 +put_template 2 $color02 +put_template 3 $color03 +put_template 4 $color04 +put_template 5 $color05 +put_template 6 $color06 +put_template 7 $color07 +put_template 8 $color08 +put_template 9 $color09 +put_template 10 $color10 +put_template 11 $color11 +put_template 12 $color12 +put_template 13 $color13 +put_template 14 $color14 +put_template 15 $color15 + +# 256 color space +put_template 16 $color16 +put_template 17 $color17 +put_template 18 $color18 +put_template 19 $color19 +put_template 20 $color20 +put_template 21 $color21 + +# foreground / background / cursor color +if [ -n "$ITERM_SESSION_ID" ]; then + # iTerm2 proprietary escape codes + put_template_custom Pg e3e1e4 # foreground + put_template_custom Ph 1a181a # background + put_template_custom Pi e3e1e4 # bold color + put_template_custom Pj 303030 # selection color + put_template_custom Pk e3e1e4 # selected text color + put_template_custom Pl e3e1e4 # cursor + put_template_custom Pm 1a181a # cursor text +else + put_template_var 10 $color_foreground + if [ "$BASE16_SHELL_SET_BACKGROUND" != false ]; then + put_template_var 11 $color_background + if [ "${TERM%%-*}" = "rxvt" ]; then + put_template_var 708 $color_background # internal border (rxvt) + fi + fi + put_template_custom 12 ";7" # cursor (reverse video) +fi + +# clean up +unset -f put_template +unset -f put_template_var +unset -f put_template_custom +unset color00 +unset color01 +unset color02 +unset color03 +unset color04 +unset color05 +unset color06 +unset color07 +unset color08 +unset color09 +unset color10 +unset color11 +unset color12 +unset color13 +unset color14 +unset color15 +unset color16 +unset color17 +unset color18 +unset color19 +unset color20 +unset color21 +unset color_foreground +unset color_background diff --git a/modules/terminal-life/bash/default.nix b/modules/terminal-life/bash/default.nix new file mode 100644 index 0000000..df9ee43 --- /dev/null +++ b/modules/terminal-life/bash/default.nix @@ -0,0 +1,114 @@ +{ + config, + flake, + pkgs, + ... +}: let + psCfg = config.pub-solar; + xdg = config.home-manager.users."${psCfg.user.name}".xdg; +in { + enable = true; + + historyControl = ["ignorespace"]; + + # Run when initializing a login shell + profileExtra = '' + [ "$(tty)" = "/dev/tty1" ] && exec ${pkgs.sway-service}/bin/sway-service + ''; + + # Run when initializing an interactive shell + initExtra = '' + # Use fzf's CTRL-R history widget + source ${pkgs.fzf}/share/fzf/key-bindings.bash + # Show current directory at the top in Alacritty + PROMPT_COMMAND='echo -e -n "\e]2;$(basename "$PWD" | sed "s/${psCfg.user.name}/~/")\e\\"' + + # If a command is not found, show me where it is + source ${pkgs.nix-index}/etc/profile.d/command-not-found.bash + + # Helps you navigate directories faster + # https://github.com/gsamokovarov/jump + eval "$(${pkgs.jump}/bin/jump shell --bind=z)" + + eval "$(${pkgs.direnv}/bin/direnv hook bash)" + + bind 'set show-all-if-ambiguous on' + + # Syntax highlighting, auto suggestions, vim modes, etc. + # https://github.com/akinomyoga/ble.sh/wiki/Manual-A1-Installation#user-content-nixpkgs + source "$(blesh-share)"/ble.sh --attach=none + # ctrl + space to accept autocomplete suggestion + ble-bind -m 'auto_complete' -f 'C-@' 'auto_complete/insert-on-end' + # Meta (Alt) + Backspace to delete a word + ble-bind -m 'vi_imap' -f 'M-C-?' 'kill-backward-cword' + # Meta (Alt) + p to jump one word backwards + ble-bind -m 'vi_imap' -f M-p '@nomarked backward-uword' + ble-bind -m 'vi_imap' -f M-left '@nomarked backward-uword' + # Meta (Alt) + n to jump one word forwards + ble-bind -m 'vi_imap' -f M-n '@nomarked forward-uword' + ble-bind -m 'vi_imap' -f M-right '@nomarked forward-uword' + # Arrow up and Ctrl + p searches history for entered input + ble-bind -m 'vi_imap' -f up 'history-search-backward hide-status:immediate-accept:empty=emulate-readline:point=end' + ble-bind -m 'vi_imap' -f C-p 'history-search-backward hide-status:immediate-accept:empty=emulate-readline:point=end' + # Arrow down and Ctrl + n searches history for entered input + ble-bind -m 'vi_imap' -f down 'history-search-forward hide-status:immediate-accept:empty=emulate-readline:point=end' + ble-bind -m 'vi_imap' -f C-n 'history-search-forward hide-status:immediate-accept:empty=emulate-readline:point=end' + + ble-face region_insert='fg=black,bg=navy' + + function my/complete-load-hook { + bleopt complete_auto_delay=250 + } + blehook/eval-after-load complete my/complete-load-hook + + bleopt exec_elapsed_mark= + bleopt exec_errexit_mark= + bleopt filename_ls_colors="$LS_COLORS" + + bleopt complete_menu_style=desc + + # Bash vim mode keybindings + if [[ $- == *i* ]]; then # in interactive session + set -o vi + + ble-bind -m vi_imap -f 'ENTER' 'vi_imap/complete' + ble-bind -m vi_imap -f 'TAB' 'vi_imap/complete' + + ble-bind -m vi_imap -f 'j j' 'vi_imap/normal-mode' + ble-bind -m vi_imap -f 'ESC' 'vi_imap/normal-mode' + + ble-bind -m vi_nmap -f 'h' 'vi_nmap/insert-mode' + ble-bind -m vi_nmap -f 'i' 'vi-command/backward-line' + ble-bind -m vi_nmap -f 'j' 'vi-command/backward-char' + ble-bind -m vi_nmap -f 'k' 'vi-command/forward-line' + ble-bind -m vi_nmap -f 'l' 'vi-command/forward-char' + + ble-bind -m vi_imap -f 'C-c' discard-line + fi + + # end of .bashrc + # Somehow we need to ensure starship starts later than ble.sh + # (possible packaging issue?) + # https://github.com/akinomyoga/ble.sh/issues/333 + eval "$(${pkgs.starship}/bin/starship init bash)" + + [[ ''${BLE_VERSION-} ]] && ble-attach + ''; + + shellAliases = { + nano = "nvim"; + vi = "nvim"; + vim = "nvim"; + mutt = "neomutt"; + ls = "eza"; + la = "eza --group-directories-first -lag"; + wget = "wget --hsts-file=$XDG_CACHE_HOME/wget-hsts"; + irssi = "irssi --config=$XDG_CONFIG_HOME/irssi/config --home=$XDG_DATA_HOME/irssi"; + drone = "DRONE_TOKEN=$(secret-tool lookup drone token) drone"; + no = "manix \"\" | grep '^# ' | sed 's/^# \(.*\) (.*/\1/;s/ (.*//;s/^# //' | fzf --preview=\"manix '{}'\" | xargs manix"; + # fix nixos-option + nixos-option = "nixos-option -I nixpkgs=${flake.self}/lib/compat"; + myip = "dig +short myip.opendns.com @208.67.222.222 2>&1"; + nnn = "nnn -d -e -H -r"; + }; +} diff --git a/modules/terminal-life/default.nix b/modules/terminal-life/default.nix new file mode 100644 index 0000000..43ed55a --- /dev/null +++ b/modules/terminal-life/default.nix @@ -0,0 +1,113 @@ +{ + lib, + config, + pkgs, + flake, + ... +}: +with lib; let + psCfg = config.pub-solar; + cfg = config.pub-solar.terminal-life; +in { + options.pub-solar.terminal-life = { + full = mkOption { + description = '' + Enable a full version, which includes more nvim plugins and lsps. + ''; + default = false; + type = types.bool; + }; + }; + + config = { + programs.command-not-found.enable = false; + programs.nix-index.enable = true; + # We do this manually in modules/terminal-life/bash/default.nix + # until https://github.com/nix-community/nix-index/pull/227 is merged + programs.nix-index.enableBashIntegration = false; + + users.users."${psCfg.user.name}".packages = with pkgs; [ + ack + asciinema + bat + blesh + eza + fd + jump + (nnn.overrideAttrs (o: { + patches = + (o.patches or []) + ++ [ + ./nnn/0001-feat-use-wasd-keybindings-for-jkli.patch + ]; + })) + powerline + screen + silver-searcher + watson + ]; + + home-manager.users."${psCfg.user.name}" = { + xdg.dataFile."scripts/base16.sh".source = .local/share/scripts/base16.sh; + + programs.less = { + enable = true; + keys = '' + k forw-line + i back-line + K forw-scroll + I back-scroll + ''; + }; + + # Starship is a fast and featureful shell prompt + # starship.toml has sane defaults that can be changed there + programs.starship = { + enable = true; + settings = import ./starship.toml.nix; + }; + + programs.bash = import ./bash { + inherit config; + inherit pkgs; + inherit lib; + inherit flake; + }; + + programs.fzf = import ./fzf { + inherit config; + inherit pkgs; + }; + + programs.neovim = import ./nvim { + inherit config; + inherit pkgs; + inherit lib; + }; + # Ensure nvim backup directory gets created + # Workaround for E510: Can't make backup file (add ! to override) + xdg.dataFile."nvim/backup/.keep".text = ""; + xdg.dataFile."nvim/json-schemas/.keep".text = ""; + # Generated with: + # docker run -it --name caddy-json-schema registry.greenbaum.cloud/gc/caddy-l4:2.5.2 caddy json-schema -output /srv/caddy_schema.json + xdg.dataFile."nvim/json-schemas/caddy_schema.json".source = .local/share/nvim/json-schemas/caddy_schema.json; + xdg.dataFile."nvim/templates/.keep".text = ""; + + programs.git = import ./git {}; + xdg.configFile."git/config".text = import ./.config/git/config.nix { + inherit config; + inherit pkgs; + }; + xdg.configFile."git/gitmessage".text = import ./.config/git/gitmessage.nix { + inherit config; + inherit pkgs; + }; + xdg.configFile."git/global_gitignore".text = import ./.config/git/global_gitignore.nix { + inherit config; + inherit pkgs; + }; + + programs.direnv = import ./direnv {}; + }; + }; +} diff --git a/modules/terminal-life/direnv/default.nix b/modules/terminal-life/direnv/default.nix new file mode 100644 index 0000000..dbaa385 --- /dev/null +++ b/modules/terminal-life/direnv/default.nix @@ -0,0 +1,6 @@ +{...}: { + enable = true; + nix-direnv = { + enable = true; + }; +} diff --git a/modules/terminal-life/fzf/default.nix b/modules/terminal-life/fzf/default.nix new file mode 100644 index 0000000..88e6059 --- /dev/null +++ b/modules/terminal-life/fzf/default.nix @@ -0,0 +1,17 @@ +{ + config, + pkgs, + ... +}: { + enable = true; + defaultCommand = "fd --hidden --type f --exclude .git"; + defaultOptions = [ + "--color=bg+:#2d2a2e,bg:#1a181a,spinner:#ef9062,hl:#7accd7" + "--color=fg:#d3d1d4,header:#7accd7,info:#e5c463,pointer:#ef9062" + "--color=marker:#ef9062,fg+:#303030,prompt:#e5c463,hl+:#7accd7" + ]; + # Use ble.sh for completions, see + # modules/terminal-life/bash/default.nix -> bleopt complete_menu_style=desc + # and https://github.com/akinomyoga/ble.sh/wiki/Manual-%C2%A77-Completion + enableBashIntegration = false; +} diff --git a/modules/terminal-life/git/default.nix b/modules/terminal-life/git/default.nix new file mode 100644 index 0000000..13c8720 --- /dev/null +++ b/modules/terminal-life/git/default.nix @@ -0,0 +1,40 @@ +{...}: { + enable = true; + + extraConfig = { + pull.rebase = false; + }; + + aliases = { + a = "add -p"; + co = "checkout"; + cob = "checkout -b"; + f = "fetch -p"; + c = "commit"; + p = "push"; + ba = "branch -a"; + bd = "branch -d"; + bD = "branch -D"; + d = "diff"; + dc = "diff --cached"; + ds = "diff --staged"; + r = "restore"; + rs = "restore --staged"; + st = "status -sb"; + + # reset + soft = "reset --soft"; + hard = "reset --hard"; + s1ft = "soft HEAD~1"; + h1rd = "hard HEAD~1"; + + # logging + lg = "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"; + plog = "log --graph --pretty='format:%C(red)%d%C(reset) %C(yellow)%h%C(reset) %ar %C(green)%aN%C(reset) %s'"; + tlog = "log --stat --since='1 Day Ago' --graph --pretty=oneline --abbrev-commit --date=relative"; + rank = "shortlog -sn --no-merges"; + + # delete merged branches + bdm = "!git branch --merged | grep -v '*' | xargs -n 1 git branch -d"; + }; +} diff --git a/modules/terminal-life/nnn/0001-feat-use-wasd-keybindings-for-jkli.patch b/modules/terminal-life/nnn/0001-feat-use-wasd-keybindings-for-jkli.patch new file mode 100644 index 0000000..f06cb04 --- /dev/null +++ b/modules/terminal-life/nnn/0001-feat-use-wasd-keybindings-for-jkli.patch @@ -0,0 +1,38 @@ +From a81ee68923412c0fb8fab46f2f918a7ec865b384 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Benjamin=20B=C3=A4dorf?= +Date: Sun, 9 Jul 2023 04:19:51 +0200 +Subject: [PATCH] feat: use wasd keybindings for jkli + +--- + src/nnn.h | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/src/nnn.h b/src/nnn.h +index d476ddd2..5f106987 100644 +--- a/src/nnn.h ++++ b/src/nnn.h +@@ -131,7 +131,7 @@ struct key { + static struct key bindings[] = { + /* Back */ + { KEY_LEFT, SEL_BACK }, +- { 'h', SEL_BACK }, ++ { 'j', SEL_BACK }, + /* Inside or select */ + { KEY_ENTER, SEL_OPEN }, + { '\r', SEL_OPEN }, +@@ -139,10 +139,10 @@ static struct key bindings[] = { + { KEY_RIGHT, SEL_NAV_IN }, + { 'l', SEL_NAV_IN }, + /* Next */ +- { 'j', SEL_NEXT }, ++ { 'k', SEL_NEXT }, + { KEY_DOWN, SEL_NEXT }, + /* Previous */ +- { 'k', SEL_PREV }, ++ { 'i', SEL_PREV }, + { KEY_UP, SEL_PREV }, + /* Page down */ + { KEY_NPAGE, SEL_PGDN }, +-- +2.40.1 + diff --git a/modules/terminal-life/nvim/clipboard.vim b/modules/terminal-life/nvim/clipboard.vim new file mode 100644 index 0000000..ee9cd4c --- /dev/null +++ b/modules/terminal-life/nvim/clipboard.vim @@ -0,0 +1,20 @@ +" Wayland clipboard provider that strips carriage returns (GTK3 issue). +" This is needed because currently there's an issue where GTK3 applications on +" Wayland contain carriage returns at the end of the lines (this is a root +" issue that needs to be fixed). +let g:clipboard = { + \ 'name': 'wayland-strip-carriage', + \ 'copy': { + \ '+': 'wl-copy --foreground --type text/plain --trim-newline', + \ '*': 'wl-copy --foreground --type text/plain --primary --trim-newline', + \ }, + \ 'paste': { + \ '+': {-> systemlist('wl-paste --no-newline | tr -d "\r"')}, + \ '*': {-> systemlist('wl-paste --no-newline --primary | tr -d "\r"')}, + \ }, + \ 'cache_enabled': 1, + \ } + +" Copy filenames +nnor yfp :let @+=expand("%:p") " Mnemonic: Yank File path +nnor yfn :let @+=expand("%") " Mnemonic: Yank File name diff --git a/modules/terminal-life/nvim/default.nix b/modules/terminal-life/nvim/default.nix new file mode 100644 index 0000000..717741a --- /dev/null +++ b/modules/terminal-life/nvim/default.nix @@ -0,0 +1,199 @@ +{ + config, + pkgs, + lib, + ... +}: let + psCfg = config.pub-solar; + cfg = config.pub-solar.terminal-life; + xdg = config.home-manager.users."${psCfg.user.name}".xdg; + + preview-file = pkgs.writeShellScriptBin "preview-file" (import ./preview-file.nix pkgs); +in { + enable = true; + + viAlias = true; + vimAlias = true; + vimdiffAlias = true; + + withNodeJs = true; + withRuby = true; + withPython3 = true; + + extraPackages = with pkgs; + lib.mkIf (cfg.full) [ + ansible-language-server + ccls + gopls + nixd + nodejs + nodePackages.bash-language-server + nodePackages.dockerfile-language-server-nodejs + nodePackages.svelte-language-server + nodePackages.typescript + nodePackages.typescript-language-server + nodePackages.vim-language-server + nodePackages.vue-language-server + nodePackages.vscode-langservers-extracted + nodePackages.yaml-language-server + python3Packages.python-lsp-server + python3Full + rust-analyzer + solargraph + terraform-ls + universal-ctags + ]; + + plugins = with pkgs.vimPlugins; + lib.mkIf cfg.full [ + (pkgs.vimPlugins.nvim-treesitter.withPlugins (p: [ + p.ini + p.json + p.json5 + p.markdown + p.nix + p.toml + p.yaml + + p.css + p.graphql + p.html + p.javascript + p.scss + p.tsx + p.typescript + p.vue + + p.c + p.cpp + p.go + p.gomod + p.gosum + p.haskell + p.lua + p.php + p.python + p.ruby + p.rust + + p.vim + p.vimdoc + + p.passwd + p.sql + + p.diff + p.gitcommit + p.gitignore + p.git_config + p.gitattributes + p.git_rebase + + p.bash + p.dockerfile + p.make + p.ninja + p.terraform + ])) + + # Dependencies for nvim-lspconfig + nvim-cmp + cmp-nvim-lsp + cmp_luasnip + luasnip + + # Quickstart configs for neovim LSP + lsp_extensions-nvim + nvim-lspconfig + + # Collaborative editing in Neovim using built-in capabilities + instant-nvim-nvfetcher + + # Search functionality behind :Ack + ack-vim + + # The status bar in the bottom of the screen with the mode indication and file location + vim-airline + + # Automatically load editorconfig files in repos to configure nvim settings + editorconfig-vim + + # File browser. Use n to access + nnn-vim + + # Highlight characters when using f, F, t, and T + quick-scope + + # Get sudo in vim; :SudaWrite + suda-vim + + # Undo history etc. per project + vim-workspace-nvfetcher + + # JSON schemas + SchemaStore-nvim + + # Work with tags files + vim-gutentags + + # Neovim colorschemes / themes + sonokai + vim-hybrid-material + vim-airline-themes + vim-apprentice-nvfetcher + + # Git integrations + # A Git wrapper so awesome, it should be illegal + fugitive + # Shows git diff markers in the sign column + vim-gitgutter + # GitHub extension for fugitive + vim-rhubarb + # Ease your git workflow within Vim + vimagit-nvfetcher + + # FZF fuzzy finder + fzf-vim + fzfWrapper + # Make the yanked region apparent + vim-highlightedyank + + # :Beautify Code beautifier + vim-beautify-nvfetcher + + # Unload, delete or wipe a buffer without closing the window + vim-bufkill + # Defaults everyone can agree on + vim-sensible + + # emmet for vim: http://emmet.io/ + emmet-vim + # Caddyfile syntax support for Vim + vim-caddyfile-nvfetcher + + # Fix TOFU hashes when writing nix derivations without leaving neovim + vim-nixhash + ]; + + extraConfig = builtins.concatStringsSep "\n" [ + '' + " Persistent undo + set undofile + set undodir=${xdg.cacheHome}/nvim/undo + + set backupdir=${xdg.dataHome}/nvim/backup + set directory=${xdg.dataHome}/nvim/swap/ + '' + (builtins.readFile ./init.vim) + (builtins.readFile ./plugins.vim) + (builtins.readFile ./clipboard.vim) + (builtins.readFile ./ui.vim) + (builtins.readFile ./quickfixopenall.vim) + (builtins.readFile ./lsp.vim) + '' + " fzf with file preview + command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, { 'options': ['--keep-right', '--cycle', '--layout', 'reverse', '--preview', '${preview-file}/bin/preview-file {}'] }, 0) + '' + ]; +} diff --git a/modules/terminal-life/nvim/init.vim b/modules/terminal-life/nvim/init.vim new file mode 100644 index 0000000..6cea1bf --- /dev/null +++ b/modules/terminal-life/nvim/init.vim @@ -0,0 +1,108 @@ +set nocompatible " be iMproved, required +filetype indent plugin on " required + +set modeline +set modelines=1 +set nowrap + +set viminfo='100,<100,s20 " vim file history + +set hidden + +set expandtab +set shiftwidth=2 +set number +set relativenumber +set mouse= +set autoindent +set smartindent + +set undolevels=1000 +set undoreload=10000 + +set updatetime=300 + +let mapleader = " " + +nmap :w +imap :w +vmap gv + +noremap y "+y +noremap p "+p + +noremap i +noremap j +noremap k +noremap h i + +vnoremap K L +vnoremap I H +vnoremap H I + +nnoremap K L +nnoremap I H +nnoremap H I + +map i :wincmd k +map j :wincmd h +map k :wincmd j +map l :wincmd l + +map I :wincmd K +map J :wincmd H +map K :wincmd J +map L :wincmd L + +" replay macro for each line of a visual selection +xnoremap @q :normal @q +xnoremap @@ :normal @@ + +" reselect and re-yank any text that is pasted in visual mode +xnoremap p pgvy + +" Escape overwrite +inoremap jj + +" Open new buffer +nmap T :enew + +" Move to the next buffer +nmap l :bnext + +" Move to the previous buffer +nmap j :bprevious + +" Close the current buffer and move to the previous one +" This replicates the idea of closing a tab +nmap q :bp bd # + +" Show all open buffers and their status +nmap bl :ls + +" Mapping selecting mappings +nmap (fzf-maps-n) +xmap (fzf-maps-x) +omap (fzf-maps-o) + +nmap :Files +imap :Files + +" Insert mode completion +imap (fzf-complete-word) +imap (fzf-complete-path) +imap (fzf-complete-file) +imap (fzf-complete-line) + +" Clear quickfix shortcut +nmap c :ccl + +" Remember cursor position +" Vim jumps to the last position when reopening a file +if has("autocmd") + au BufReadPost * if line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g'\"" | endif +endif + +nmap - :NnnPicker % +nmap n :NnnPicker % +nmap N :NnnPicker diff --git a/modules/terminal-life/nvim/lsp.vim b/modules/terminal-life/nvim/lsp.vim new file mode 100644 index 0000000..f0ffcdb --- /dev/null +++ b/modules/terminal-life/nvim/lsp.vim @@ -0,0 +1,258 @@ +" Set completeopt to have a better completion experience +" :help completeopt +" menuone: popup even when there's only one match +" noinsert: Do not insert text until a selection is made +" noselect: Do not select, force user to select one from the menu +set completeopt=menuone,noinsert,noselect + +" Avoid showing extra messages when using completion +set shortmess+=c + +function AddTemplate(tmpl_file) + exe "0read " . a:tmpl_file + set nomodified + 6 +endfunction + +autocmd BufNewFile shell.nix call AddTemplate("$XDG_DATA_HOME/nvim/templates/shell.nix.tmpl") + +" Configure neovim 0.6+ experimental LSPs +" https://github.com/neovim/nvim-lspconfig +" https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md +" https://github.com/neovim/nvim-lspconfig/wiki/UI-Customization +" https://gitlab.com/Iron_E/dotfiles/-/blob/master/.config/nvim/lua/_config/plugin/nvim_lsp.lua +lua <e', 'lua vim.diagnostic.open_float()', opts) + vim.api.nvim_set_keymap('n', 'g[', 'lua vim.diagnostic.goto_prev()', opts) + vim.api.nvim_set_keymap('n', 'g]', 'lua vim.diagnostic.goto_next()', opts) + vim.api.nvim_set_keymap('n', 'dq', 'lua vim.diagnostic.setloclist()', opts) + vim.api.nvim_set_keymap('n', 'f', 'lua vim.lsp.buf.formatting()', opts) + + -- Use an on_attach function to only map the following keys + -- after the language server attaches to the current buffer + local on_attach = function(client, bufnr) + -- Enable completion triggered by + vim.api.nvim_buf_set_option(bufnr, 'omnifunc', 'v:lua.vim.lsp.omnifunc') + + -- Mappings (available if LSP is configured and attached to buffer) + -- See `:help vim.lsp.*` for documentation on any of the below functions + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'gD', 'lua vim.lsp.buf.declaration()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'gd', 'lua vim.lsp.buf.definition()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'K', 'lua vim.lsp.buf.hover()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'gi', 'lua vim.lsp.buf.implementation()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', '', 'lua vim.lsp.buf.signature_help()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'wa', 'lua vim.lsp.buf.add_workspace_folder()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'wr', 'lua vim.lsp.buf.remove_workspace_folder()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'wl', 'lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'D', 'lua vim.lsp.buf.type_definition()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'rn', 'lua vim.lsp.buf.rename()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'ca', 'lua vim.lsp.buf.code_action()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'gr', 'lua vim.lsp.buf.references()', opts) + + -- Show diagnostic popup on cursor hold + vim.api.nvim_create_autocmd("CursorHold", { + buffer = bufnr, + callback = function() + local opts = { + focusable = false, + close_events = { "BufLeave", "CursorMoved", "InsertEnter", "FocusLost" }, + border = 'rounded', + source = 'always', + prefix = ' ', + scope = 'cursor', + } + vim.diagnostic.open_float(nil, opts) + end + }) + + end + + -- Add additional capabilities supported by nvim-cmp + local capabilities = require('cmp_nvim_lsp').default_capabilities() + -- vscode HTML lsp needs this https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#html + capabilities.textDocument.completion.completionItem.snippetSupport = true + + -- vscode HTML lsp needs this https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#html + capabilities.textDocument.completion.completionItem.snippetSupport = true + + local use_denols_for_typescript = not(os.getenv('NVIM_USE_DENOLS') == nil) + + for lsp_key, lsp_settings in pairs({ + 'ansiblels', ---------------------------- Ansible + 'bashls', ------------------------------- Bash + 'ccls', --------------------------------- C / C++ / Objective-C + 'cssls', -------------------------------- CSS / SCSS / LESS + 'dockerls', ----------------------------- Docker + ['gopls'] = { --------------------------- Go + ['settings'] = { + ['gopls'] = { + ['analyses'] = { + ['unusedparams'] = true, + }, + ['staticcheck'] = true + }, + }, + }, + 'html', --------------------------------- HTML + ['jdtls'] = { --------------------------- Java + ['root_dir'] = nvim_lsp.util.root_pattern('.git', 'pom.xml', 'build.xml'), + ['init_options'] = { + ['jvm_args'] = {['java.format.settings.url'] = vim.fn.stdpath('config')..'/eclipse-formatter.xml'}, + ['workspace'] = vim.fn.stdpath('cache')..'/java-workspaces' + } + }, + ['jsonls'] = { -------------------------- JSON + ['settings'] = { + ['json'] = { + ['schemas' ] = vim.list_extend( + { + { + ['description'] = 'JSON schema for Caddy v2', + ['fileMatch'] = { '*caddy*.json' }, + ['name'] = 'caddy_schema.json', + ['url'] = vim.fn.stdpath('data')..'/json-schemas/caddy_schema.json', + }, + }, + require('schemastore').json.schemas() + ), + ['validate'] = { ['enable'] = true } + } + } + }, + 'nixd', --------------------------------- Nix + 'phpactor', ----------------------------- PHP + 'pylsp', -------------------------------- Python + 'solargraph', --------------------------- Ruby + 'rust_analyzer', ------------------------ Rust + ['sqlls'] = { + ['cmd'] = {vim.fn.stdpath('data')..'/nvm/versions/node/v12.19.0/bin/sql-language-server', 'up', '--method', 'stdio'} + }, + ['terraformls'] = { --------------------- Terraform + ['filetypes'] = { 'terraform', 'hcl', 'tf' } + }, + + -- The TS/JS server is chosen depending on an environment variable, + -- since denols is nicer for Deno based projects + ------------------------ Deno TS/JS + ------------------------------------ Typescript / JavaScript + (use_denols_for_typescript and 'denols' or 'tsserver'), + + 'vuels', -------------------------------- Vue + 'svelte', ------------------------------- Svelte + ['yamlls'] = { -------------------------- YAML + ['settings'] = { + ['yaml'] = { + ['schemas'] = { + ['https://json.schemastore.org/github-workflow'] = '.github/workflows/*.{yml,yaml}', + ['https://json.schemastore.org/github-action'] = '.github/action.{yml,yaml}', + ['https://json.schemastore.org/drone'] = '*.drone.{yml,yaml}', + ['https://json.schemastore.org/swagger-2.0'] = 'swagger.{yml,yaml}', + } + } + } + } + }) do -- Setup all of the language servers. † + if type(lsp_key) == 'number' then -- Enable the LSP with defaults. + -- The `lsp` is an index in this case. + nvim_lsp[lsp_settings].setup{ + on_attach = on_attach, + flags = { + debounce_text_changes = 150, + }, + capabilities = capabilities, + } + else -- Use the LSP's configuration. + lsp_settings.on_attach = on_attach + lsp_settings.capabilities = capabilities + + nvim_lsp[lsp_key].setup(lsp_settings) + end + end -- ‡ + + -- configure floating diagnostics appearance, symbols + local signs = { Error = " ", Warn = " ", Hint = " ", Info = " " } + for type, icon in pairs(signs) do + local hl = "DiagnosticSign" .. type + vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = hl }) + end + + -- Set completeopt to have a better completion experience + vim.o.completeopt = 'menuone,noselect' + + -- luasnip setup + local luasnip = require 'luasnip' + + -- nvim-cmp setup + local cmp = require 'cmp' + cmp.setup { + snippet = { + expand = function(args) + require('luasnip').lsp_expand(args.body) + end, + }, + mapping = { + [''] = cmp.mapping.select_prev_item(), + [''] = cmp.mapping.select_next_item(), + [''] = cmp.mapping.scroll_docs(-4), + [''] = cmp.mapping.scroll_docs(4), + [''] = cmp.mapping.complete(), + [''] = cmp.mapping.close(), + [''] = cmp.mapping.confirm { + behavior = cmp.ConfirmBehavior.Replace, + select = true, + }, + [''] = function(fallback) + if cmp.visible() then + cmp.select_next_item() + elseif luasnip.expand_or_jumpable() then + luasnip.expand_or_jump() + else + fallback() + end + end, + [''] = function(fallback) + if cmp.visible() then + cmp.select_prev_item() + elseif luasnip.jumpable(-1) then + luasnip.jump(-1) + else + fallback() + end + end, + }, + sources = { + { name = 'nvim_lsp' }, + { name = 'luasnip' }, + }, + } + + -- https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#denols + vim.g.markdown_fenced_languages = { + "ts=typescript" + } + + -- Configure diagnostics + vim.diagnostic.config({ + virtual_text = false, + signs = true, + underline = true, + update_in_insert = false, + severity_sort = false, + }) + + -- Change diagnostic symbols in the sign column (gutter) + local signs = { Error = " ", Warn = " ", Hint = " ", Info = " " } + for type, icon in pairs(signs) do + local hl = "DiagnosticSign" .. type + vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = hl }) + end +EOF + +" have a fixed column for the diagnostics to appear in +" this removes the jitter when warnings/errors flow in +set signcolumn=yes:2 diff --git a/modules/terminal-life/nvim/plugins.vim b/modules/terminal-life/nvim/plugins.vim new file mode 100644 index 0000000..85891b1 --- /dev/null +++ b/modules/terminal-life/nvim/plugins.vim @@ -0,0 +1,87 @@ +" Happy yaml configuration +au! BufNewFile,BufReadPost *.{yaml,yml} set filetype=yaml +autocmd FileType yaml setlocal ts=2 sts=2 sw=2 expandtab + +let g:gutentags_file_list_command = 'git ls-files' + +" quick-scope +" https://github.com/unblevable/quick-scope +let g:qs_highlight_on_keys = ['f', 'F', 't', 'T'] + +" Golang +" Go test, Def, Decls shortcut +nmap got :GoTest:botright copen +autocmd FileType go nmap gd :GoDef +autocmd FileType go nmap gD :GoDecls + +" Go formatting +autocmd FileType go setlocal noexpandtab shiftwidth=4 tabstop=4 softtabstop=4 nolist + +" Caddyfile indentation +autocmd FileType caddyfile setlocal noexpandtab shiftwidth=8 tabstop=8 softtabstop=8 nolist + +" vim-go disable text-objects +let g:go_textobj_enabled = 0 + +" disable vim-go :GoDef short cut (gd) +" this is handled by LanguageClient [LC] +let g:go_def_mapping_enabled = 0 + +" GitGutter and vim Magit +" inspired by: https://jakobgm.com/posts/vim/git-integration/ +" Don't map gitgutter keys automatically, set them ourselves +let g:gitgutter_map_keys = 0 + +" Jump between hunks +nmap gn (GitGutterNextHunk) " git next +nmap gp (GitGutterPrevHunk) " git previous + +" Hunk-add and hunk-revert for chunk staging +nmap ga (GitGutterStageHunk) " git add (chunk) +nmap gu (GitGutterUndoHunk) " git undo (chunk) + +" Open vimagit pane +nnoremap gs :Magit " git status + +" Push to remote +nnoremap gP :! git push " git Push + +" Quick conflict resolution in git mergetool nvim +" http://vimcasts.org/episodes/fugitive-vim-resolving-merge-conflicts-with-vimdiff/ +nmap [ :diffget //2 +nmap ] :diffget //3 + +" netrw +let g:netrw_fastbrowse=0 + +" Auto-FMT rust code on save +let g:rustfmt_autosave = 1 + +" Indenting in html template tags +let g:html_indent_style1 = "inc" + +" yank highlight duration +let g:highlightedyank_highlight_duration = 200 + +" Markdown options +let g:vim_markdown_folding_disabled = 1 + +" Haskell options +let g:haskell_enable_quantification = 1 " to enable highlighting of `forall` +let g:haskell_enable_recursivedo = 1 " to enable highlighting of `mdo` and `rec` +let g:haskell_enable_arrowsyntax = 1 " to enable highlighting of `proc` +let g:haskell_enable_pattern_synonyms = 1 " to enable highlighting of `pattern` +let g:haskell_enable_typeroles = 1 " to enable highlighting of type roles +let g:haskell_enable_static_pointers = 1 " to enable highlighting of `static` +let g:haskell_backpack = 1 " to enable highlighting of backpack keywords + +" Emmet +let g:user_emmet_leader_key='' + +" Ack +if executable('ag') + let g:ackprg = 'ag --vimgrep' +endif + +" nnn +let g:nnn#command = 'nnn -d -e -H -r' diff --git a/modules/terminal-life/nvim/preview-file.nix b/modules/terminal-life/nvim/preview-file.nix new file mode 100644 index 0000000..2a52bdd --- /dev/null +++ b/modules/terminal-life/nvim/preview-file.nix @@ -0,0 +1,36 @@ +self: +with self; '' + IFS=':' read -r -a INPUT <<< "$1" + FILE=''${INPUT[0]} + CENTER=''${INPUT[1]} + + if [[ "$1" =~ ^[A-Za-z]:\\ ]]; then + FILE=$FILE:''${INPUT[1]} + CENTER=''${INPUT[2]} + fi + + if [[ -n "$CENTER" && ! "$CENTER" =~ ^[0-9] ]]; then + exit 1 + fi + CENTER=''${CENTER/[^0-9]*/} + + FILE="''${FILE/#\~\//$HOME/}" + if [ ! -r "$FILE" ]; then + echo "File not found ''${FILE}" + exit 1 + fi + + if [ -z "$CENTER" ]; then + CENTER=0 + fi + + exec cat "$FILE" \ + | sed -e '/[#|\/\/ ?]-- copyright/,/[#\/\/]++/c\\' \ + | ${pkgs.coreutils}/bin/tr -s '\n' \ + | ${pkgs.bat}/bin/bat \ + --style="''${BAT_STYLE:-numbers}" \ + --color=always \ + --pager=never \ + --file-name="''$FILE" \ + --highlight-line=$CENTER +'' diff --git a/modules/terminal-life/nvim/quickfixopenall.vim b/modules/terminal-life/nvim/quickfixopenall.vim new file mode 100644 index 0000000..6b4d844 --- /dev/null +++ b/modules/terminal-life/nvim/quickfixopenall.vim @@ -0,0 +1,20 @@ +"Usage: +" 1. Perform a vimgrep search +" :vimgrep /def/ *.rb +" 2. Issue QuickFixOpenAll command +" :QuickFixOpenAll +function! QuickFixOpenAll() + if empty(getqflist()) + return + endif + let s:prev_val = "" + for d in getqflist() + let s:curr_val = bufname(d.bufnr) + if (s:curr_val != s:prev_val) + exec "edit " . s:curr_val + endif + let s:prev_val = s:curr_val + endfor +endfunction + +command! QuickFixOpenAll call QuickFixOpenAll() diff --git a/modules/terminal-life/nvim/ui.vim b/modules/terminal-life/nvim/ui.vim new file mode 100644 index 0000000..b3e63a7 --- /dev/null +++ b/modules/terminal-life/nvim/ui.vim @@ -0,0 +1,32 @@ +"let g:base16_shell_path = $XDG_DATA_HOME . "/scripts/base16.sh" +"let base16colorspace = 256 +set termguicolors +"let g:sonokai_style = 'shusia' +"let g:sonokai_enable_italic = 1 +"let g:sonokai_disable_italic_comment = 1 +"let g:sonokai_transparent_background = 1 +set background=dark +colorscheme apprentice + +let g:airline#extensions#tabline#enabled = 1 " Enable the list of buffers +let g:airline#extensions#tabline#fnamemod = ':t' " Show just the filename +let g:airline#extensions#tabline#formatter = 'unique_tail_improved' +let g:airline_powerline_fonts = 1 " Use powerline fonts +let g:airline_theme = 'apprentice' + +" Customize fzf colors to match your color scheme +" - fzf#wrap translates this to a set of `--color` options +let g:fzf_colors = +\ { 'fg': ['fg', 'Normal'], + \ 'bg': ['bg', 'Normal'], + \ 'hl': ['fg', 'Comment'], + \ 'fg+': ['fg', 'CursorLine', 'CursorColumn', 'Normal'], + \ 'bg+': ['bg', 'CursorLine', 'CursorColumn'], + \ 'hl+': ['fg', 'Statement'], + \ 'info': ['fg', 'PreProc'], + \ 'border': ['fg', 'Ignore'], + \ 'prompt': ['fg', 'Conditional'], + \ 'pointer': ['fg', 'Exception'], + \ 'marker': ['fg', 'Keyword'], + \ 'spinner': ['fg', 'Label'], + \ 'header': ['fg', 'Comment'] } diff --git a/modules/terminal-life/starship.toml.nix b/modules/terminal-life/starship.toml.nix new file mode 100644 index 0000000..e05a1f4 --- /dev/null +++ b/modules/terminal-life/starship.toml.nix @@ -0,0 +1,169 @@ +{ + format = "$username$hostname$directory($git_branch$git_commit$git_state$git_status)($c$deno$golang$haskell$nodejs$php$python$ruby$rust$terraform[](fg:#F85E84 bg:#000000))($docker_context[](fg:#06969A))($container)$fill(\${custom.triton})$nix_shell$status[ |](fg:#F85E84)$line_break$character"; + + # Disable the blank line at the start of the prompt + add_newline = false; + + # You can also replace your username with a neat symbol like  to save some space + username = { + style_user = "bg:#000000 fg:#F85E84"; + style_root = "bg:#F85E84 fg:#000000"; + format = ''[$user ]($style)''; + }; + + hostname = { + ssh_symbol = ""; + trim_at = ""; + style = "bg:#000000 fg:#F85E84"; + }; + + character = { + success_symbol = "[❯](bold purple)"; + error_symbol = "[✗](#FF4B00)"; + }; + + status = { + disabled = false; + style = "#FF4B00"; + }; + + fill = { + symbol = "-"; + #style = "bold green"; + style = "black"; + }; + + directory = { + style = "#F85E84"; + truncate_to_repo = false; + fish_style_pwd_dir_length = 1; + truncation_symbol = "…/"; + format = "[](fg:black bg:#F85E84)[$path[$read_only](bg:$style fg:black)](bg:$style fg:black)[](fg:$style)"; + read_only = " "; + }; + + # Here is how you can shorten some long paths by text replacement + # similar to mapped_locations in Oh My Posh: + directory.substitutions = { + "Documents" = " "; + "Downloads" = " "; + "Music" = " "; + "Pictures" = " "; + }; + # Keep in mind that the order matters. For example: + # "Important Documents" = "  " + # will not be replaced, because "Documents" was already substituted before. + # So either put "Important Documents" before "Documents" or use the substituted version: + # "Important  " = "  " + + c = { + symbol = " "; + style = "bg:#86BBD8"; + format = ''[ $symbol ($version) ]($style)''; + }; + + #container = {}; + + custom = { + triton = { + command = "echo $TRITON_PROFILE"; + when = "test $TRITON_PROFILE"; + format = "[✚ ](fg:#F85E84 bg:#1A181A)[$output](fg:#F85E84 bg:#1A181A)"; + description = "The current triton profile"; + }; + }; + + docker_context = { + symbol = " "; + style = "bg:#06969A"; + format = ''[ $symbol $context ]($style) $path''; + }; + + #deno = {}; + + git_branch = { + style = "#E5C463"; + format = "[](fg:black bg:$style)[ $symbol$branch](fg:black bg:$style)[](fg:$style)"; + symbol = " "; + }; + + git_commit = { + style = "#E5C463"; + # ^H is the literal backspace character which renders to \b in the final + # starship config TOML, produced in insert mode via ctrl+v then ctrl+h. + # We use the literal character, because escaping a single \ doesn't work + # with pkgs.formats.toml, see: https://github.com/NixOS/nixpkgs/issues/97310 and + # https://jdhao.github.io/2020/10/07/nvim_insert_unicode_char/ + format = "[ ](bg:$style)[\\($hash$tag\\)](fg:black bg:$style)[](fg:$style)"; + }; + + git_state = { + style = "#E5C463"; + format = "[ ](bg:$style)[ \\($state( $progress_current/$progress_total)\\)](fg:black bg:$style)[](fg:$style)"; + }; + + git_status = { + style = "#E5C463"; + format = "([ ](bg:$style fg:black)$conflicted$staged$modified$renamed$deleted$untracked$stashed$ahead_behind[](fg:$style))"; + conflicted = "[ ](bold fg:88 bg:#E5C463)[  \${count} ](fg:black bg:#E5C463)"; + staged = "[ $count ](fg:black bg:#E5C463)"; + modified = "[ \${count} ](fg:black bg:#E5C463)"; + renamed = "[ \${count} ](fg:black bg:#E5C463)"; + deleted = "[ \${count} ](fg:black bg:#E5C463)"; + untracked = "[?\${count} ](fg:black bg:#E5C463)"; + stashed = "[ \${count} ](fg:black bg:#E5C463)"; + ahead = "[ \${count} ](fg:#523333 bg:#E5C463)"; + behind = "[ \${count} ](fg:black bg:#E5C463)"; + diverged = "[ ](fg:88 bg:#E5C463)[  ](fg:black bg:#E5C463)[ \${ahead_count} ](fg:black bg:#E5C463)[ \${behind_count} ](fg:black bg:#E5C463)"; + }; + + golang = { + symbol = " "; + style = "bg:#86BBD8"; + format = ''[ $symbol ($version) ]($style)''; + }; + + haskell = { + symbol = " "; + style = "bg:#86BBD8"; + format = ''[ $symbol ($version) ]($style)''; + }; + + nix_shell = { + format = ''[$symbol]($style) ''; + symbol = " "; + }; + + nodejs = { + symbol = ""; + style = "bg:#86BBD8"; + format = ''[ $symbol ($version) ]($style)''; + }; + + php = { + symbol = " "; + }; + + python = { + symbol = " "; + }; + + ruby = { + symbol = " "; + }; + + rust = { + symbol = ""; + style = "bg:#86BBD8"; + format = ''[ $symbol ($version) ]($style)''; + }; + + #terraform = {}; + + time = { + disabled = false; + time_format = "%R"; # Hour:Minute Format + style = "bg:#33658A"; + format = ''[ ♥ $time ]($style)''; + }; +} diff --git a/modules/user/.config/dircolors b/modules/user/.config/dircolors new file mode 100644 index 0000000..16b9bb1 --- /dev/null +++ b/modules/user/.config/dircolors @@ -0,0 +1,243 @@ +# Configuration file for dircolors, a utility to help you set the +# LS_COLORS environment variable used by GNU ls with the --color option. + +# Copyright (C) 1996-2014 Free Software Foundation, Inc. +# Copying and distribution of this file, with or without modification, +# are permitted provided the copyright notice and this notice are preserved. + +# The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the +# slackware version of dircolors) are recognized but ignored. + +# You can copy this file to .dir_colors in your $HOME directory to override +# the system defaults. + +# Below, there should be one TERM entry for each termtype that is colorizable +TERM Eterm +TERM ansi +TERM color-xterm +TERM con132x25 +TERM con132x30 +TERM con132x43 +TERM con132x60 +TERM con80x25 +TERM con80x28 +TERM con80x30 +TERM con80x43 +TERM con80x50 +TERM con80x60 +TERM cons25 +TERM console +TERM cygwin +TERM dtterm +TERM eterm-color +TERM gnome +TERM gnome-256color +TERM hurd +TERM jfbterm +TERM konsole +TERM kterm +TERM linux +TERM linux-c +TERM mach-color +TERM mach-gnu-color +TERM mlterm +TERM putty +TERM putty-256color +TERM rxvt +TERM rxvt-256color +TERM rxvt-cygwin +TERM rxvt-cygwin-native +TERM rxvt-unicode +TERM rxvt-unicode-256color +TERM rxvt-unicode256 +TERM screen +TERM screen-256color +TERM screen-256color-bce +TERM screen-bce +TERM screen-w +TERM screen.Eterm +TERM screen.rxvt +TERM screen.linux +TERM st +TERM st-256color +TERM terminator +TERM vt100 +TERM xterm +TERM xterm-16color +TERM xterm-256color +TERM xterm-88color +TERM xterm-color +TERM xterm-debian + +# Below are the color init strings for the basic file types. A color init +# string consists of one or more of the following numeric codes: +# Attribute codes: +# 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed +# Text color codes: +# 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white +# Background color codes: +# 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white +#NORMAL 00 # no color code at all +#FILE 00 # regular file: use no color at all +RESET 0 # reset to "normal" color +DIR 01;34 # directory +LINK 01;36 # symbolic link. (If you set this to 'target' instead of a + # numerical value, the color is as for the file pointed to.) +MULTIHARDLINK 00 # regular file with more than one link +FIFO 40;33 # pipe +SOCK 01;35 # socket +DOOR 01;35 # door +BLK 40;33;01 # block device driver +CHR 40;33;01 # character device driver +ORPHAN 01;05;37;41 # orphaned syminks +MISSING 01;05;37;41 # ... and the files they point to +SETUID 37;41 # file that is setuid (u+s) +SETGID 30;43 # file that is setgid (g+s) +CAPABILITY 30;41 # file with capability +STICKY_OTHER_WRITABLE 30;42 # dir that is sticky and other-writable (+t,o+w) +OTHER_WRITABLE 34;42 # dir that is other-writable (o+w) and not sticky +STICKY 37;44 # dir with the sticky bit set (+t) and not other-writable + +# This is for files with execute permission: +EXEC 01;32 + +# List any file extensions like '.gz' or '.tar' that you would like ls +# to colorize below. Put the extension, a space, and the color init string. +# (and any comments you want to add after a '#') + +# If you use DOS-style suffixes, you may want to uncomment the following: +#.cmd 01;32 # executables (bright green) +#.exe 01;32 +#.com 01;32 +#.btm 01;32 +#.bat 01;32 +# Or if you want to colorize scripts even if they do not have the +# executable bit actually set. +#.sh 01;32 +#.csh 01;32 + +# archives or compressed (bright red) +.tar 01;31 +.tgz 01;31 +.arc 01;31 +.arj 01;31 +.taz 01;31 +.lha 01;31 +.lz4 01;31 +.lzh 01;31 +.lzma 01;31 +.tlz 01;31 +.txz 01;31 +.tzo 01;31 +.t7z 01;31 +.zip 01;31 +.z 01;31 +.Z 01;31 +.dz 01;31 +.gz 01;31 +.lrz 01;31 +.lz 01;31 +.lzo 01;31 +.xz 01;31 +.bz2 01;31 +.bz 01;31 +.tbz 01;31 +.tbz2 01;31 +.tz 01;31 +.deb 01;31 +.rpm 01;31 +.jar 01;31 +.war 01;31 +.ear 01;31 +.sar 01;31 +.rar 01;31 +.alz 01;31 +.ace 01;31 +.zoo 01;31 +.cpio 01;31 +.7z 01;31 +.rz 01;31 +.cab 01;31 + +# image formats +.jpg 01;35 +.jpeg 01;35 +.gif 01;35 +.bmp 01;35 +.pbm 01;35 +.pgm 01;35 +.ppm 01;35 +.tga 01;35 +.xbm 01;35 +.xpm 01;35 +.tif 01;35 +.tiff 01;35 +.png 01;35 +.svg 01;35 +.svgz 01;35 +.mng 01;35 +.pcx 01;35 +.mov 01;35 +.mpg 01;35 +.mpeg 01;35 +.m2v 01;35 +.mkv 01;35 +.webm 01;35 +.ogm 01;35 +.mp4 01;35 +.m4v 01;35 +.mp4v 01;35 +.vob 01;35 +.qt 01;35 +.nuv 01;35 +.wmv 01;35 +.asf 01;35 +.rm 01;35 +.rmvb 01;35 +.flc 01;35 +.avi 01;35 +.fli 01;35 +.flv 01;35 +.gl 01;35 +.dl 01;35 +.xcf 01;35 +.xwd 01;35 +.yuv 01;35 +.cgm 01;35 +.emf 01;35 + +# http://wiki.xiph.org/index.php/MIME_Types_and_File_Extensions +.axv 01;35 +.anx 01;35 +.ogv 01;35 +.ogx 01;35 + +# Document files +.pdf 00;32 +.ps 00;32 +.txt 00;32 +.patch 00;32 +.diff 00;32 +.log 00;32 +.tex 00;32 +.doc 00;32 + +# audio formats +.aac 00;36 +.au 00;36 +.flac 00;36 +.m4a 00;36 +.mid 00;36 +.midi 00;36 +.mka 00;36 +.mp3 00;36 +.mpc 00;36 +.ogg 00;36 +.ra 00;36 +.wav 00;36 + +# http://wiki.xiph.org/index.php/MIME_Types_and_File_Extensions +.axa 00;36 +.oga 00;36 +.spx 00;36 +.xspf 00;36 diff --git a/modules/user/.config/mimeapps.list b/modules/user/.config/mimeapps.list new file mode 100644 index 0000000..e69de29 diff --git a/modules/user/default.nix b/modules/user/default.nix new file mode 100644 index 0000000..aeeb372 --- /dev/null +++ b/modules/user/default.nix @@ -0,0 +1,101 @@ +{ + config, + pkgs, + lib, + ... +}: let + psCfg = config.pub-solar; +in + with lib; { + imports = [ + ./home.nix + ]; + + options.pub-solar = { + user = { + name = mkOption { + description = "User login name"; + type = types.nullOr types.str; + default = "nixos"; + }; + description = mkOption { + description = "User description"; + type = types.nullOr types.str; + default = "The main PubSolarOS user"; + }; + password = mkOption { + description = "User password"; + type = types.nullOr types.str; + default = null; + }; + passwordlessSudo = mkOption { + description = "Whether this user can use sudo without entering a password"; + type = types.bool; + default = false; + }; + publicKeys = mkOption { + description = "User SSH public keys"; + type = types.listOf types.str; + default = []; + }; + fullName = mkOption { + description = "User full name"; + type = types.nullOr types.str; + default = null; + }; + email = mkOption { + description = "User email address"; + type = types.nullOr types.str; + default = null; + }; + gpgKeyId = mkOption { + description = "GPG Key ID"; + type = types.nullOr types.str; + default = null; + }; + }; + }; + + config = { + users = { + mutableUsers = false; + + users."${psCfg.user.name}" = { + # Indicates whether this is an account for a “real” user. + # This automatically sets group to users, createHome to true, + # home to /home/username, useDefaultShell to true, and isSystemUser to false. + isNormalUser = true; + description = psCfg.user.description; + extraGroups = [ + "input" + "lp" + "networkmanager" + "scanner" + "video" + "wheel" + ]; + shell = pkgs.bash; + initialHashedPassword = + if psCfg.user.password != null + then psCfg.user.password + else ""; + openssh.authorizedKeys.keys = + if psCfg.user.publicKeys != null + then psCfg.user.publicKeys + else []; + }; + }; + + security.sudo.extraRules = mkIf psCfg.user.passwordlessSudo [ + { + users = ["${psCfg.user.name}"]; + commands = [ + { + command = "ALL"; + options = ["NOPASSWD"]; + } + ]; + } + ]; + }; + } diff --git a/modules/user/home.nix b/modules/user/home.nix new file mode 100644 index 0000000..ea1e07b --- /dev/null +++ b/modules/user/home.nix @@ -0,0 +1,50 @@ +{ + config, + pkgs, + lib, + ... +}: +with lib; let + psCfg = config.pub-solar; + xdg = config.home-manager.users."${psCfg.user.name}".xdg; +in { + imports = [ + ./session-variables.nix + ]; + + home-manager.users."${psCfg.user.name}" = { + # Let Home Manager install and manage itself. + programs.home-manager.enable = true; + + # Home Manager needs a bit of information about you and the + # paths it should manage. + home.username = psCfg.user.name; + home.homeDirectory = "/home/${psCfg.user.name}"; + home.stateVersion = "22.11"; + + programs.dircolors.enable = true; + + xdg.enable = true; + xdg.mime.enable = true; + xdg.mimeApps = import ./mimeapps.nix; + + xdg.configFile."dircolors".source = ./.config/dircolors; + + xdg.dataFile."shell.nix.tmpl" = { + text = '' + let + unstable = import (fetchTarball https://github.com/nixos/nixpkgs/archive/nixos-unstable.tar.gz) { }; + in + { nixpkgs ? import {} }: + with nixpkgs; mkShell { + buildInputs = [ + ]; + } + ''; + target = "nvim/templates/shell.nix.tmpl"; + }; + + # Allow unfree packages only on a user basis, not on a system-wide basis + xdg.configFile."nixpkgs/config.nix".text = " { allowUnfree = true; } "; + }; +} diff --git a/modules/user/mimeapps.nix b/modules/user/mimeapps.nix new file mode 100644 index 0000000..ab3fd49 --- /dev/null +++ b/modules/user/mimeapps.nix @@ -0,0 +1,27 @@ +{ + enable = true; + defaultApplications = { + "application/octet-stream" = ["firefox.desktop"]; + "application/pdf" = ["org.gnome.Evince.desktop"]; + "application/x-bittorrent" = ["deluge.desktop"]; + "application/x-extension-htm" = ["firefox.desktop"]; + "application/x-extension-html" = ["firefox.desktop"]; + "application/x-extension-shtml" = ["firefox.desktop"]; + "application/x-extension-xhtml" = ["firefox.desktop"]; + "application/x-extension-xht" = ["firefox.desktop"]; + "application/xhtml+xml" = ["firefox.desktop"]; + "image/jpeg" = ["org.gnome.eog.desktop"]; + "image/png" = ["org.gnome.eog.desktop"]; + "message/rfc822" = ["userapp-Thunderbird.desktop"]; + "text/html" = ["firefox.desktop"]; + "text/plain" = ["firefox.desktop"]; + "video/mp4" = ["vlc.desktop"]; + "x-scheme-handler/chrome" = ["firefox.desktop"]; + "x-scheme-handler/ftp" = ["firefox.desktop"]; + "x-scheme-handler/http" = ["firefox.desktop"]; + "x-scheme-handler/https" = ["firefox.desktop"]; + "x-scheme-handler/mailto" = ["userapp-Thunderbird.desktop"]; + "x-scheme-handler/msteams" = ["teams.desktop"]; + "x-scheme-handler/tg" = ["userapp-Telegram Desktop-JBKFU0.desktop"]; + }; +} diff --git a/modules/user/session-variables.nix b/modules/user/session-variables.nix new file mode 100644 index 0000000..ae96e81 --- /dev/null +++ b/modules/user/session-variables.nix @@ -0,0 +1,119 @@ +{ + config, + pkgs, + lib, + ... +}: let + psCfg = config.pub-solar; + xdg = config.home-manager.users."${psCfg.user.name}".xdg; + variables = { + XDG_CONFIG_HOME = xdg.configHome; + XDG_CACHE_HOME = xdg.cacheHome; + XDG_DATA_HOME = xdg.dataHome; + + XDG_CURRENT_DESKTOP = "sway"; + + QT_QPA_PLATFORM = "wayland"; + + # Wayland fixes + ECORE_EVAS_ENGINE = "wayland_egl"; + ELM_ENGINE = "wayland_egl"; + SDL_VIDEODRIVER = "wayland"; + + EDITOR = "/etc/profiles/per-user/${psCfg.user.name}/bin/nvim"; + VISUAL = "/etc/profiles/per-user/${psCfg.user.name}/bin/nvim"; + + # fix "xdg-open fork-bomb" your preferred browser from here + BROWSER = "${pkgs.firefox-wayland}/bin/firefox"; + + # node + NODE_REPL_HISTORY = "${xdg.dataHome}/node_repl_history"; + NVM_DIR = "${xdg.dataHome}/nvm"; + PKG_CACHE_PATH = "${xdg.cacheHome}/pkg-cache"; + + # npm + NPM_CONFIG_USERCONFIG = "${xdg.configHome}/npm/config"; + NPM_CONFIG_CACHE = "${xdg.configHome}/npm"; + # TODO: used to be XDG_RUNTIME_DIR NPM_CONFIG_TMP = "/tmp/npm"; + + # Make sure virsh runs without root + LIBVIRT_DEFAULT_URI = "qemu:///system"; + + # wine + WINEPREFIX = "${xdg.dataHome}/wineprefixes/default"; + + # z + _Z_DATA = "${xdg.dataHome}/z"; + + # wget + WGETRC = "${xdg.configHome}/wgetrc"; + + # rust + RUSTUP_HOME = "${xdg.dataHome}/rustup"; + CARGO_HOME = "${xdg.dataHome}/cargo"; + + # Java + _JAVA_OPTIONS = "-Djava.util.prefs.userRoot='${xdg.configHome}/java'"; + _JAVA_AWT_WM_NONREPARENTING = "1"; + + # docker + DOCKER_CONFIG = "${xdg.configHome}/docker"; + + # experimental wayland in firefox/thunderbird + MOZ_ENABLE_WAYLAND = "1"; + + # chromium / electron on wayland: enable ozone (native wayland mode) + NIXOS_OZONE_WL = "1"; + + # Vagrant + VAGRANT_HOME = "${xdg.dataHome}/vagrant"; + VAGRANT_DEFAULT_PROVIDER = "libvirt"; + + # Android + ANDROID_SDK_ROOT = "${xdg.configHome}/android"; + + ANDROID_AVD_HOME = "${xdg.dataHome}/android"; + ANDROID_EMULATOR_HOME = "${xdg.dataHome}/android"; + ADB_VENDOR_KEY = "${xdg.configHome}/android"; + + # TELEMETRY BS + VUEDX_TELEMETRY = "off"; + + # FZF shell history widget default colors + FZF_DEFAULT_OPTS = lib.mkForce "--color=bg+:#2d2a2e,bg:#1a181a,spinner:#ef9062,hl:#7accd7 --color=fg:#d3d1d4,header:#7accd7,info:#e5c463,pointer:#ef9062 --color=marker:#ef9062,fg+:#d3d1d4,prompt:#e5c463,hl+:#7accd7"; + + # nnn theme colors + NNN_FCOLORS = let + BLK = "04"; + CHR = "04"; + DIR = "04"; + EXE = "02"; + REG = "00"; + HARDLINK = "01"; + SYMLINK = "01"; + MISSING = "01"; + ORPHAN = "07"; + FIFO = "05"; + SOCK = "05"; + OTHER = "02"; + in + BLK + CHR + DIR + EXE + REG + HARDLINK + SYMLINK + MISSING + ORPHAN + FIFO + SOCK + OTHER; + }; + + envListNames = lib.attrsets.mapAttrsToList (name: value: name) variables; + + # Here we merge an extra variable into the attrset called FULL_ENV_LIST. + # It's a list of the variable names defined above. + # We can use this to tell `systemctl import-environment` to import the full list above. + variablesWithMeta = lib.attrsets.zipAttrsWith (name: values: builtins.head values) [ + variables + {IMPORT_ENVIRONMENT_ENV_LIST = lib.lists.foldl (a: b: a + " " + b) "IMPORT_ENVIRONMENT_ENV_LIST" envListNames;} + ]; +in { + home-manager.users."${psCfg.user.name}" = { + home.sessionVariables = variablesWithMeta; + systemd.user.sessionVariables = variablesWithMeta; + }; + + environment.variables = variablesWithMeta; +} diff --git a/modules/virtualisation/default.nix b/modules/virtualisation/default.nix new file mode 100644 index 0000000..892667b --- /dev/null +++ b/modules/virtualisation/default.nix @@ -0,0 +1,55 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; +in { + boot.kernelParams = [ + "amd_iommu=on" + "intel_iommu=on" + "iommu=pt" + ]; + + virtualisation.libvirtd = { + enable = true; + qemu.ovmf.enable = true; + }; + users.users."${psCfg.user.name}" = { + extraGroups = ["libvirtd"]; + }; + + environment.systemPackages = with pkgs; [ + libvirt + libvirt-glib + qemu + virt-manager + python3Packages.libvirt + gvfs + edk2 + OVMF + win-virtio + looking-glass-client + lgcl + ]; + + home-manager.users."${psCfg.user.name}" = { + xdg.dataFile."libvirt/.keep".text = "# this file is here to generate the directory"; + home.packages = [pkgs.obs-studio-plugins.looking-glass-obs]; + }; + + systemd.tmpfiles.rules = [ + "f /dev/shm/looking-glass 0660 ${psCfg.user.name} kvm" + ]; + #networking.bridges.virbr1.interfaces = []; + #networking.interfaces.virbr1 = { + # ipv4.addresses = [ + # { + # address = "192.168.123.1"; + # prefixLength = 24; + # } + # ]; + #}; +} diff --git a/modules/wireguard-client/default.nix b/modules/wireguard-client/default.nix new file mode 100644 index 0000000..b919828 --- /dev/null +++ b/modules/wireguard-client/default.nix @@ -0,0 +1,54 @@ +{ + lib, + config, + pkgs, + ... +}: +with lib; let + psCfg = config.pub-solar; + cfg = config.pub-solar.wireguard-client; +in { + options.pub-solar.wireguard-client = { + ownIPs = mkOption { + description = '' + Internal ips in wireguard used for cluster control-plane communication. + ''; + type = types.listOf types.str; + }; + + wireguardPrivateKeyFile = mkOption { + description = '' + Location of private key file + ''; + type = types.path; + }; + }; + + config = { + networking.firewall.allowedUDPPorts = [51899]; + + networking.wg-quick.interfaces = { + wg0 = { + listenPort = 51899; + address = cfg.ownIPs; + dns = [ + "10.0.1.2" + "fd00:b12f:acab:1312:acab:2::" + ]; + privateKeyFile = cfg.wireguardPrivateKeyFile; + peers = [ + { + # frikandel + publicKey = "p6YKNYBlySKfhTN+wbSsKdoNjzko/XSAiTAlCJzP1jA="; + allowedIPs = [ + "10.0.1.0/24" + "fd00:b12f:acab:1312::/64" + ]; + endpoint = "[2a01:4f8:c2c:b60::]:51899"; + persistentKeepalive = 25; + } + ]; + }; + }; + }; +} diff --git a/overlays/blesh.nix b/overlays/blesh.nix new file mode 100644 index 0000000..f29c29e --- /dev/null +++ b/overlays/blesh.nix @@ -0,0 +1,32 @@ +final: prev: { + blesh = prev.blesh.overrideAttrs (oldAttrs: rec { + inherit (prev.sources.blesh-nvfetcher) version src; + + dontBuild = false; + buildInputs = [prev.git]; + patchPhase = '' + substituteInPlace GNUmakefile \ + --replace "git submodule update --init --recursive" "" + ''; + nativeCheckInputs = oldAttrs.nativeCheckInputs ++ [prev.busybox]; + + installPhase = '' + runHook preInstall + + mkdir -p "$out/share/blesh/lib" + + cat <"$out/share/blesh/lib/_package.sh" + _ble_base_package_type=nix + + function ble/base/package:nix/update { + echo "Ble.sh is installed by Nix. You can update it there." >&2 + return 1 + } + EOF + + make install INSDIR=$out/share/blesh + + runHook postInstall + ''; + }); +} diff --git a/overlays/default.nix b/overlays/default.nix new file mode 100644 index 0000000..2227aee --- /dev/null +++ b/overlays/default.nix @@ -0,0 +1,35 @@ +{ + self, + lib, + inputs, + ... +}: { + flake = { + nixosModules = rec { + overlays = {...}: { + nixpkgs.overlays = [ + (final: prev: let + unstable = import inputs.unstable { + system = prev.system; + }; + master = import inputs.master { + system = prev.system; + }; + in { + direnv = unstable.direnv; + nix-direnv = unstable.nix-direnv; + #vimPlugins = prev.vimPlugins // {inherit (unstable.vimPlugins) nvim-lspconfig;}; + }) + + inputs.erpnext.overlays.default + inputs.erpnext.overlays.pythonOverlay + + (import ../pkgs) + (import ./blesh.nix) + (import ./nix-index.nix) + (import ./neovim-plugins.nix) + ]; + }; + }; + }; +} diff --git a/overlays/neovim-plugins.nix b/overlays/neovim-plugins.nix new file mode 100644 index 0000000..1bb2c39 --- /dev/null +++ b/overlays/neovim-plugins.nix @@ -0,0 +1,24 @@ +final: prev: { + vimPlugins = + prev.vimPlugins + // { + instant-nvim-nvfetcher = prev.vimUtils.buildVimPlugin { + inherit (prev.sources.instant-nvim-nvfetcher) pname version src; + }; + vimagit-nvfetcher = prev.vimUtils.buildVimPlugin { + inherit (prev.sources.vimagit-nvfetcher) pname version src; + }; + vim-caddyfile-nvfetcher = prev.vimUtils.buildVimPlugin { + inherit (prev.sources.vim-caddyfile-nvfetcher) pname version src; + }; + vim-workspace-nvfetcher = prev.vimUtils.buildVimPlugin { + inherit (prev.sources.vim-workspace-nvfetcher) pname version src; + }; + vim-beautify-nvfetcher = prev.vimUtils.buildVimPlugin { + inherit (prev.sources.vim-beautify-nvfetcher) pname version src; + }; + vim-apprentice-nvfetcher = prev.vimUtils.buildVimPlugin { + inherit (prev.sources.vim-apprentice-nvfetcher) pname version src; + }; + }; +} diff --git a/overlays/nix-index.nix b/overlays/nix-index.nix new file mode 100644 index 0000000..2d91564 --- /dev/null +++ b/overlays/nix-index.nix @@ -0,0 +1,24 @@ +final: prev: { + nix-index-unwrapped = prev.nix-index-unwrapped.overrideAttrs (oldAttrs: rec { + inherit (oldAttrs) pname; + src = prev.fetchFromGitHub { + owner = "teutat3s"; + repo = "nix-index"; + rev = "e2d1917f474083f6d5a2c3368a6073f6427c19e4"; + hash = "sha256-3nTphxyqI6Hci7yJ2bKLcgdRl2qOY3BzUqoIl1YmmsA="; + }; + version = "unstable-2023-11-25"; + + cargoDeps = oldAttrs.cargoDeps.overrideAttrs (prev.lib.const { + name = "${pname}-vendor.tar.gz"; + inherit src; + outputHash = "sha256-x4oejbS1/L3WkN2S6PzvJni9UasRTP3TVVp3Ur9ge8U="; + }); + + postInstall = '' + substituteInPlace etc/command-not-found.* \ + --subst-var out + install -Dm444 etc/command-not-found.* -t $out/etc/profile.d + ''; + }); +} diff --git a/pkgs/_sources/generated.nix b/pkgs/_sources/generated.nix new file mode 100644 index 0000000..c37dc1a --- /dev/null +++ b/pkgs/_sources/generated.nix @@ -0,0 +1,114 @@ +# This file was generated by nvfetcher, please do not modify it manually. +{ fetchgit, fetchurl, fetchFromGitHub, dockerTools }: +{ + blesh-nvfetcher = { + pname = "blesh-nvfetcher"; + version = "9641c3b8ef6c792912b58209281b77619c177637"; + src = fetchFromGitHub { + owner = "akinomyoga"; + repo = "ble.sh"; + rev = "9641c3b8ef6c792912b58209281b77619c177637"; + fetchSubmodules = true; + deepClone = false; + leaveDotGit = true; + sha256 = "sha256-y+lfSK5iVA1qNO10uqXFsuaJEKQqqT9rSdm/UQ3cWgs="; + }; + date = "2024-01-05"; + }; + instant-nvim-nvfetcher = { + pname = "instant-nvim-nvfetcher"; + version = "294b6d08143b3db8f9db7f606829270149e1a786"; + src = fetchFromGitHub { + owner = "jbyuki"; + repo = "instant.nvim"; + rev = "294b6d08143b3db8f9db7f606829270149e1a786"; + fetchSubmodules = false; + sha256 = "sha256-DXJWji/NR8ZCxe014rD51v3EHJHMhRQeOoI3SsY8mR4="; + }; + date = "2022-06-25"; + }; + manix = { + pname = "manix"; + version = "d08e7ca185445b929f097f8bfb1243a8ef3e10e4"; + src = fetchFromGitHub { + owner = "mlvzk"; + repo = "manix"; + rev = "d08e7ca185445b929f097f8bfb1243a8ef3e10e4"; + fetchSubmodules = false; + sha256 = "sha256-GqPuYscLhkR5E2HnSFV4R48hCWvtM3C++3zlJhiK/aw="; + }; + date = "2021-04-20"; + }; + rnix-lsp-nvfetcher = { + pname = "rnix-lsp-nvfetcher"; + version = "95d40673fe43642e2e1144341e86d0036abd95d9"; + src = fetchFromGitHub { + owner = "nix-community"; + repo = "rnix-lsp"; + rev = "95d40673fe43642e2e1144341e86d0036abd95d9"; + fetchSubmodules = false; + sha256 = "sha256-F0s0m62S5bHNVWNHLZD6SeHiLrsDx98VQbRjDyIu+qQ="; + }; + date = "2022-11-27"; + }; + vim-apprentice-nvfetcher = { + pname = "vim-apprentice-nvfetcher"; + version = "59ad13661fa15edaf72c62218903c7817b5a3691"; + src = fetchFromGitHub { + owner = "romainl"; + repo = "Apprentice"; + rev = "59ad13661fa15edaf72c62218903c7817b5a3691"; + fetchSubmodules = false; + sha256 = "sha256-03B9tmU9+6t2hxhOgZxBqJr9r41CAqhHLUkHYvFdcks="; + }; + date = "2023-02-15"; + }; + vim-beautify-nvfetcher = { + pname = "vim-beautify-nvfetcher"; + version = "e0691483927dc5a0c051433602397419f9628623"; + src = fetchFromGitHub { + owner = "zeekay"; + repo = "vim-beautify"; + rev = "e0691483927dc5a0c051433602397419f9628623"; + fetchSubmodules = false; + sha256 = "sha256-QPTCl6KaGcAjTS5yVDov9yxmv0fDaFoPLMsrtVIG6GQ="; + }; + date = "2018-12-27"; + }; + vim-caddyfile-nvfetcher = { + pname = "vim-caddyfile-nvfetcher"; + version = "24fe0720551883e407cb70ae1d7c03f162d1d5a0"; + src = fetchFromGitHub { + owner = "isobit"; + repo = "vim-caddyfile"; + rev = "24fe0720551883e407cb70ae1d7c03f162d1d5a0"; + fetchSubmodules = false; + sha256 = "sha256-rRYv3vnt31g7hNTxttTD6BWdv5JJ+ko3rPNyDUEOZ9o="; + }; + date = "2022-05-09"; + }; + vim-workspace-nvfetcher = { + pname = "vim-workspace-nvfetcher"; + version = "c0d1e4332a378f58bfdf363b4957168fa78e79b4"; + src = fetchFromGitHub { + owner = "thaerkh"; + repo = "vim-workspace"; + rev = "c0d1e4332a378f58bfdf363b4957168fa78e79b4"; + fetchSubmodules = false; + sha256 = "sha256-2Brx098dk5THiieBiW71FG9mUUwS1CSY9mpOPWA/Tq4="; + }; + date = "2023-05-28"; + }; + vimagit-nvfetcher = { + pname = "vimagit-nvfetcher"; + version = "06afe48439d0118a77d622ef06eff0f7cd7d62ab"; + src = fetchFromGitHub { + owner = "jreybert"; + repo = "vimagit"; + rev = "06afe48439d0118a77d622ef06eff0f7cd7d62ab"; + fetchSubmodules = false; + sha256 = "sha256-2kugFr32lZINgpmDyfTyBp5lNa2/dculKmcFGa2q/io="; + }; + date = "2024-01-04"; + }; +} diff --git a/pkgs/default.nix b/pkgs/default.nix new file mode 100644 index 0000000..6655356 --- /dev/null +++ b/pkgs/default.nix @@ -0,0 +1,24 @@ +final: prev: +with final; { + # keep sources this first + sources = prev.callPackage (import ./_sources/generated.nix) {}; + # then, call packages with `final.callPackage` + import-gtk-settings = writeShellScriptBin "import-gtk-settings" (import ./import-gtk-settings.nix final); + lgcl = writeShellScriptBin "lgcl" (import ./lgcl.nix final); + mailto-mutt = writeShellScriptBin "mailto-mutt" (import ./mailto-mutt.nix final); + mopidy-jellyfin = import ./mopidy-jellyfin.nix final; + mu = writeShellScriptBin "mu" (import ./mu.nix final); + psos = writeShellScriptBin "psos" (import ./psos.nix final); + psos-docs = import ./psos-docs.nix final; + s = writeShellScriptBin "s" (import ./s.nix final); + sway-launcher = writeScriptBin "sway-launcher" (import ./sway-launcher.nix final); + sway-service = writeShellScriptBin "sway-service" (import ./sway-service.nix final); + swaylock-bg = writeShellScriptBin "swaylock-bg" (import ./swaylock-bg.nix final); + toggle-kbd-layout = writeShellScriptBin "toggle-kbd-layout" (import ./toggle-kbd-layout.nix final); + uhk-agent = import ./uhk-agent.nix final; + wcwd = writeShellScriptBin "wcwd" (import ./wcwd.nix final); + drone-docker-runner = writeShellScriptBin "drone-docker-runner" (import ./drone-docker-runner.nix final); + record-screen = writeShellScriptBin "record-screen" (import ./record-screen.nix final); + + # ps-fixes +} diff --git a/pkgs/drone-docker-runner.nix b/pkgs/drone-docker-runner.nix new file mode 100644 index 0000000..bb3e8b8 --- /dev/null +++ b/pkgs/drone-docker-runner.nix @@ -0,0 +1,33 @@ +self: +with self; '' + case $1 in + start) + ${self.docker}/bin/docker run --detach \ + --volume=/var/run/docker.sock:/var/run/docker.sock \ + --env=DRONE_RPC_PROTO=$DRONE_RPC_PROTO \ + --env=DRONE_RPC_HOST=$DRONE_RPC_HOST \ + --env=DRONE_RPC_SECRET=$(${self.libsecret}/bin/secret-tool lookup drone rpc-secret) \ + --env=DRONE_RUNNER_CAPACITY=8 \ + --env=DRONE_RUNNER_NAME=$(${self.inetutils}/bin/hostname) \ + --publish=3000:3000 \ + --restart=always \ + --name=drone-runner \ + drone/drone-runner-docker:1 + ;; + + stop) + ${self.docker}/bin/docker stop drone-runner + ${self.docker}/bin/docker rm drone-runner + ;; + + logs) + ${self.docker}/bin/docker logs drone-runner + ;; + + *) + echo "Usage: drone-docker-runner " + exit 1; + ;; + esac + +'' diff --git a/pkgs/import-gtk-settings.nix b/pkgs/import-gtk-settings.nix new file mode 100644 index 0000000..2a4bf0f --- /dev/null +++ b/pkgs/import-gtk-settings.nix @@ -0,0 +1,12 @@ +self: +with self; '' + # usage: import-gsettings : : ... + + expression="" + for pair in "$@"; do + IFS=:; set -- $pair + expressions="$expressions -e 's/^$2=(.*)$/gsettings set org.gnome.desktop.interface $1 \1/e'" + done + IFS= + eval exec sed -E $expressions "$XDG_CONFIG_HOME"/gtk-3.0/settings.ini >/dev/null +'' diff --git a/pkgs/lgcl.nix b/pkgs/lgcl.nix new file mode 100644 index 0000000..73f9112 --- /dev/null +++ b/pkgs/lgcl.nix @@ -0,0 +1,8 @@ +self: +with self; let + looking-glass-client = self.looking-glass-client.overrideAttrs (old: { + meta.platforms = ["x86_64-linux" "aarch64-linux"]; + }); +in '' + ${looking-glass-client}/bin/looking-glass-client -f /dev/shm/looking-glass input:ignoreWindowsKeys=yes input:grabKeyboardOnFocus=no +'' diff --git a/pkgs/mailto-mutt.nix b/pkgs/mailto-mutt.nix new file mode 100644 index 0000000..7e014e0 --- /dev/null +++ b/pkgs/mailto-mutt.nix @@ -0,0 +1,11 @@ +self: +with self; '' + mkdir -p $XDG_CACHE_HOME/log + + LOGFILE=$XDG_CACHE_HOME/log/mailto.log + echo "$@" >> $LOGFILE + + EDITOR=/etc/profiles/per-user/$USER/bin/nvim + + ${alacritty}/bin/alacritty -e neomutt -- "$@" +'' diff --git a/pkgs/mopidy-jellyfin.nix b/pkgs/mopidy-jellyfin.nix new file mode 100644 index 0000000..b507ba1 --- /dev/null +++ b/pkgs/mopidy-jellyfin.nix @@ -0,0 +1,29 @@ +self: +with self; let + websocket-client = python3.pkgs.buildPythonPackage rec { + pname = "websocket-client"; + version = "1.2.1"; + doCheck = false; + src = python3.pkgs.fetchPypi { + inherit pname version; + sha256 = "sha256-jftxXYqZL1cS//jIQ62ulOIrIqmbLF5rDsShqYHMTg0="; + }; + }; +in + python3.pkgs.buildPythonPackage rec { + pname = "Mopidy-Jellyfin"; + version = "1.0.2"; + doCheck = false; + propagatedBuildInputs = with python3.pkgs; [ + unidecode + websocket-client + requests + setuptools + pykka + mopidy + ]; + src = python3.pkgs.fetchPypi { + inherit pname version; + sha256 = "sha256-5XimIIQSpvNyQbSOFtSTkA0jhA0V68BbyQEQNnov+0g="; + }; + } diff --git a/pkgs/mu.nix b/pkgs/mu.nix new file mode 100644 index 0000000..3b4c351 --- /dev/null +++ b/pkgs/mu.nix @@ -0,0 +1,4 @@ +self: +with self; '' + exec ${alacritty}/bin/alacritty --class mu_vimpc --option dimensions.columns=120 --option dimensions.lines=80 -e vimpc -- "$@" +'' diff --git a/pkgs/prison-break-url.patch b/pkgs/prison-break-url.patch new file mode 100644 index 0000000..42f60b6 --- /dev/null +++ b/pkgs/prison-break-url.patch @@ -0,0 +1,15 @@ +diff --git a/prisonbreak/plugins/wifionice.py b/prisonbreak/plugins/wifionice.py +index 1cee64d..e152903 100644 +--- a/prisonbreak/plugins/wifionice.py ++++ b/prisonbreak/plugins/wifionice.py +@@ -58,8 +58,8 @@ def accept(resp: requests.Response, s: requests.Session) -> bool: + log.debug(f"data: {postdata}") + + # TODO: detect the correct URL to query based on form path and url +- # The URL changed from http to http, and wifionice.de is now wifi.bahn.de +- resp = s.post("https://wifi.bahn.de/de/?url=http%3A%2F%2Fkrebsco.de%2Fsecret", data=postdata) ++ # The URL changed from wifi.bahn.de to login.wifionice.de ++ resp = s.post("https://login.wifionice.de/de/?url=http%3A%2F%2Fkrebsco.de%2Fsecret", data=postdata) + log.debug(f"Return code: {resp.status_code}") + log.debug(resp.headers) + return resp.ok diff --git a/pkgs/prison-break.nix b/pkgs/prison-break.nix new file mode 100644 index 0000000..482aa13 --- /dev/null +++ b/pkgs/prison-break.nix @@ -0,0 +1,49 @@ +self: +with self; let + straight-plugin = python3.pkgs.buildPythonPackage rec { + pname = "straight-plugin"; + version = "1.5.0"; + + src = fetchPypi { + pname = "straight.plugin"; + inherit version; + hash = "sha256-gYp2QQaJMu1kNtCvCju3e7veKd8KcULIvRoknnwvDTg="; + }; + + meta = with lib; { + description = "A simple namespaced plugin facility"; + homepage = https://github.com/ironfroggy/straight.plugin; + license = licenses.mit; + maintainers = [maintainers.makefu]; + }; + }; +in + python3.pkgs.buildPythonPackage { + name = "prison-break"; + version = "1.5.0"; + src = fetchFromGitHub { + owner = "makefu"; + repo = "prison-break"; + rev = "1.5.0"; + hash = "sha256-9Z60TxfvUAkp04fkb8VujLhBKjrJ1NZm00x/mGZ5Zz4="; + }; + propagatedBuildInputs = with python3.pkgs; [ + docopt + requests + beautifulsoup4 + notify2 + straight-plugin + ]; + patches = [ + ./prison-break-url.patch + ]; + + checkInputs = [python3.pkgs.black]; + + meta = with lib; { + description = "No Terms of Service (AGBs) every time you connect to a captive portal"; + homepage = https://github.com/makefu/prison-break; + license = licenses.mit; + maintainers = [maintainers.makefu]; + }; + } diff --git a/pkgs/psos-docs.nix b/pkgs/psos-docs.nix new file mode 100644 index 0000000..24e86bf --- /dev/null +++ b/pkgs/psos-docs.nix @@ -0,0 +1,27 @@ +self: +with self; + stdenv.mkDerivation rec { + pname = "psos-docs"; + version = "0.0.1"; + buildInputs = [ + mdbook + mdbook-pdf + ]; + + src = ../docs/..; # wut + + phases = ["buildPhase" "installPhase"]; + + buildPhase = '' + cp -r $src/doc ./doc + cp $src/README.md ./README.md + chmod ug+w -R . + ls -la . + mdbook build doc + ''; + + installPhase = '' + mkdir -p $out/lib/ + cp -r doc/book $out/lib/html + ''; + } diff --git a/pkgs/psos.nix b/pkgs/psos.nix new file mode 100644 index 0000000..7846f80 --- /dev/null +++ b/pkgs/psos.nix @@ -0,0 +1,34 @@ +self: +with self; '' + case $1 in + rebuild) + shift; + exec sudo nixos-rebuild switch --flake "/etc/nixos#installed-host" $@ + ;; + update) + shift; + cd /etc/nixos + git pull + exec nix flake update + ;; + option) + shift; + exec nixos-option -I nixpkgs=/etc/nixos/lib/compat $@ + ;; + help) + shift; + exec xdg-open http://help.local/ + ;; + *) + if [[ "$@" != "" ]]; then + echo "Unknown command: psos $@" + echo "" + fi + echo "Usage: psos [COMMAND]" + echo " rebuild Rebuild the configuration and switch to it" + echo " update Pull git and update flake.lock" + echo " option [path] See the current value for an option in the flake config. Example: psos option nix.nixPath" + exit 1 + ;; + esac +'' diff --git a/pkgs/record-screen.nix b/pkgs/record-screen.nix new file mode 100644 index 0000000..eb2d0bf --- /dev/null +++ b/pkgs/record-screen.nix @@ -0,0 +1,11 @@ +self: +with self; '' + mkdir -p "$HOME/Videos/Screenrecordings" + GEOMETRY="$(slurp -d -b \#ffffff11)" + RESOLUTION="$(echo $GEOMETRY | awk '{print $2}')" + FILE_LOCATION="$HOME/Videos/Screenrecordings/$(${coreutils}/bin/date +%Y%m%d_%Hh%Mm%Ss)_$RESOLUTION.mp4" + echo "Recording $GEOMETRY into $FILE_LOCATION" + ${alacritty}/bin/alacritty \ + --class screen-recorder \ + -e ${wf-recorder}/bin/wf-recorder -g "$GEOMETRY" -f "$FILE_LOCATION" +'' diff --git a/pkgs/s.nix b/pkgs/s.nix new file mode 100644 index 0000000..1b003b6 --- /dev/null +++ b/pkgs/s.nix @@ -0,0 +1,40 @@ +self: +with self; '' + case $1 in + d) + shift; + URL="https://duckduckgo.com?q=$@" + ;; + no) + shift; + URL="https://search.nixos.org/options?query=$@" + ;; + np) + shift; + URL="https://search.nixos.org/packages?query=$@" + ;; + rs) + shift; + URL="https://doc.rust-lang.org/std/index.html?search=$@" + ;; + rsc) + shift; + URL="https://docs.rs/releases/search?query=$@" + ;; + mdn) + shift; + URL="https://developer.mozilla.org/en-US/search?q=$@" + ;; + w) + shift; + URL="https://en.wikipedia.org/w/index.php?search=$@" + ;; + *) + URL="https://search.b12f.io?q=$@" + ;; + esac + + + ${firefox-wayland}/bin/firefox --new-tab "$URL" + ${sway}/bin/swaymsg '[app_id="firefox"]' focus +'' diff --git a/pkgs/sources.toml b/pkgs/sources.toml new file mode 100644 index 0000000..929cecb --- /dev/null +++ b/pkgs/sources.toml @@ -0,0 +1,38 @@ +# nvfetcher.toml +[manix] +src.git = "https://github.com/mlvzk/manix" +fetch.github = "mlvzk/manix" + +[rnix-lsp-nvfetcher] +src.git = "https://github.com/nix-community/rnix-lsp" +fetch.github = "nix-community/rnix-lsp" + +[vimagit-nvfetcher] +src.git = "https://github.com/jreybert/vimagit" +fetch.github = "jreybert/vimagit" + +[instant-nvim-nvfetcher] +src.git = "https://github.com/jbyuki/instant.nvim" +fetch.github = "jbyuki/instant.nvim" + +[vim-caddyfile-nvfetcher] +src.git = "https://github.com/isobit/vim-caddyfile" +fetch.github = "isobit/vim-caddyfile" + +[vim-workspace-nvfetcher] +src.git = "https://github.com/thaerkh/vim-workspace" +fetch.github = "thaerkh/vim-workspace" + +[vim-beautify-nvfetcher] +src.git = "https://github.com/zeekay/vim-beautify" +fetch.github = "zeekay/vim-beautify" + +[vim-apprentice-nvfetcher] +src.git = "https://github.com/romainl/Apprentice" +fetch.github = "romainl/Apprentice" + +[blesh-nvfetcher] +src.git = "https://github.com/akinomyoga/ble.sh" +fetch.github = "akinomyoga/ble.sh" +git.fetchSubmodules = true +git.leaveDotGit = true diff --git a/pkgs/sway-launcher.nix b/pkgs/sway-launcher.nix new file mode 100644 index 0000000..8eddd85 --- /dev/null +++ b/pkgs/sway-launcher.nix @@ -0,0 +1,65 @@ +self: +with self; '' + #!/usr/bin/env bash + # terminal application launcher for sway, using fzf + # original command: + # Based on: https://github.com/swaywm/sway/issues/1367 + # bindsym $altkey+space exec termite --name=launcher -e \ + # "bash -c 'compgen -c | sort -u | fzf --no-extended --print-query | \ + # tail -n1 | xargs -r swaymsg -t command exec'" + + HIST_FILE="''${XDG_CACHE_HOME:-$HOME/.cache}/sway-launcher-history.txt" + + # Get shell command list + # This may include the occasional non-executable file + command_list=$({ compgen -c | sed 's/:[^:]*$//'; }) + + # read existing command history + if [ -f "$HIST_FILE" ]; then + command_history=$(cat "$HIST_FILE") + else + command_history="" + fi + + # search command list + command_str=$(printf "%s\n" "''${command_history}" "''${command_list}" | \ + sed -E 's/^[0-9]+ (.+)$/\1/' | \ + fzf --color=16 --exact --no-extended --print-query --no-sort | \ + tail -n1) || exit 1 + + if [ "$command_str" = "" ]; then + exit 1 + fi + # echo "Command: $command_str" + + # using \E flag from perl regex + test "''${command_str#*\\E}" != "$command_str" && echo "command can't contain '\E'" + test "''${command_str#*\\E}" != "$command_str" && exit 1 + + # get full line from history (with count number) + hist_line=$(echo "$command_history" | grep -Pe "^[0-9]+ \Q$command_str\E$") + # echo "Hist Line: $hist_line" + + if [ "$hist_line" = "" ]; then + hist_count=1 + else + # Increment usage count + hist_count=$(echo "$hist_line" | sed -E 's/^([0-9]+) .+$/\1/') + hist_count=$((hist_count + 1)) + # delete line, to add updated later + # echo "Hist Before: $command_history" + command_history=$(echo "$command_history" | \ + grep --invert-match -Pe "^[0-9]+ \Q$command_str\E$") + # echo "Hist After: $command_history" + fi + + # update history + update_line="''${hist_count} ''${command_str}" + printf "%s\n" "''${update_line}" "''${command_history}" | \ + sort --numeric-sort --reverse > "$HIST_FILE" + # echo "$update_line" + + # execute command + echo "$command_str" + ${sway}/bin/swaymsg -t command exec "$command_str" +'' diff --git a/pkgs/sway-service.nix b/pkgs/sway-service.nix new file mode 100644 index 0000000..9ba8bb1 --- /dev/null +++ b/pkgs/sway-service.nix @@ -0,0 +1,7 @@ +self: +with self; '' + # first import environment variables from the login manager + systemctl --user import-environment; + # then start the service + exec systemctl --wait --user start sway.service +'' diff --git a/pkgs/swaylock-bg.nix b/pkgs/swaylock-bg.nix new file mode 100644 index 0000000..78a9681 --- /dev/null +++ b/pkgs/swaylock-bg.nix @@ -0,0 +1,20 @@ +self: +with self; '' + # Dependencies: + # swaylock + + # Make sure we aren't running twice + RUNNING=$(${procps}/bin/pgrep -c ${swaylock}/bin/swaylock) + if [ "$RUNNING" -ne 0 ]; then + exit 0 + fi + + IMAGE="$XDG_CONFIG_HOME/wallpaper.jpg" + LOCKARGS="" + + for OUTPUT in $(${sway}/bin/swaymsg -t get_outputs | ${jq}/bin/jq -r '.[].name') + do + LOCKARGS="''${LOCKARGS} --image ''${OUTPUT}:''${IMAGE}" + done + exec ${swaylock}/bin/swaylock $LOCKARGS +'' diff --git a/pkgs/toggle-kbd-layout.nix b/pkgs/toggle-kbd-layout.nix new file mode 100644 index 0000000..a35de23 --- /dev/null +++ b/pkgs/toggle-kbd-layout.nix @@ -0,0 +1,16 @@ +self: +with self; '' + set -e + + current_layout=$(${sway}/bin/swaymsg -t get_inputs | ${jq}/bin/jq -r '.[] | select(.type == "keyboard") | .xkb_active_layout_index' | head -1) + total_layouts=$(${sway}/bin/swaymsg -t get_inputs | ${jq}/bin/jq -r '.[] | select(.type == "keyboard") | .xkb_layout_names | length' | head -1) + + next_layout=$(expr $current_layout + 1); + + if [ $next_layout -ge $total_layouts ]; then + next_layout=0; + fi + + ${libnotify}/bin/notify-send "$next_layout" + ${sway}/bin/swaymsg input '*' xkb_switch_layout "$next_layout" +'' diff --git a/pkgs/uhk-agent.nix b/pkgs/uhk-agent.nix new file mode 100644 index 0000000..1293fc4 --- /dev/null +++ b/pkgs/uhk-agent.nix @@ -0,0 +1,44 @@ +self: +with self; let + uhk-agent-bin = stdenv.mkDerivation rec { + pname = "uhk-agent-bin"; + version = "1.5.14"; + src = builtins.fetchurl { + url = "https://github.com/UltimateHackingKeyboard/agent/releases/download/v1.5.14/UHK.Agent-1.5.14-linux-x86_64.AppImage"; + sha256 = "sha256:1yzh4ixy0cqg02xf84vcqj3h67mkxyzs6jf1h935ay582n70nyqg"; + }; + phases = ["installPhase" "patchPhase"]; + installPhase = '' + mkdir -p $out/bin + cp $src $out/bin/uhk-agent + chmod +x $out/bin/uhk-agent + ''; + }; + + script = '' + #!${bash}/bin/bash + + ${appimage-run}/bin/appimage-run ${uhk-agent-bin}/bin/uhk-agent + ''; +in + stdenv.mkDerivation rec { + pname = "uhk-agent"; + version = "1.5.14"; + buildInputs = [ + bash + uhk-agent-bin + appimage-run + ]; + + phases = ["buildPhase" "installPhase" "patchPhase"]; + + buildPhase = '' + echo "${script}" >> uhk-agent + ''; + + installPhase = '' + mkdir -p $out/bin + cp uhk-agent $out/bin/uhk-agent + chmod +x $out/bin/uhk-agent + ''; + } diff --git a/pkgs/wcwd.nix b/pkgs/wcwd.nix new file mode 100644 index 0000000..3f5e676 --- /dev/null +++ b/pkgs/wcwd.nix @@ -0,0 +1,6 @@ +self: +with self; '' + pid=$(${sway}/bin/swaymsg -t get_tree | jq '.. | select(.type?) | select(.type=="con") | select(.focused==true).pid') + ppid=$(pgrep --newest --parent ''${pid}) + readlink /proc/''${ppid}/cwd || echo $HOME +'' diff --git a/secrets/erpnext-admin-password.age b/secrets/erpnext-admin-password.age new file mode 100644 index 0000000..319ec1d --- /dev/null +++ b/secrets/erpnext-admin-password.age @@ -0,0 +1,29 @@ +age-encryption.org/v1 +-> ssh-ed25519 uYcDNw 88HhrQ8027RZCO/s3syfJ+p1pTLu1+BD9vNTeR5wilw +0HB76zuOmanHmJ7Q5SrroyCB86uZivYrBCBMxCw4dRs +-> ssh-rsa kFDS0A +lNeBDYSX/0z5mEQNiEmjbExNVkhsAxEq+f0VHX/GmQq6ueSaYKtfbQNmyH+9kWt8 +m27qP+aH+SD/d1cSk5rq/Eq4qAuYUs8S0IT6QyCXg2KEQ9z7A18HUrKj0PrIXFs6 +KyUPJZjjoplyFLTLe8DpgG7WSUns3T/wmDWlbzGEpUUVaNmDoaywUHVlGYAQHSPS +gLFnmv1WU30HfH4A/s6y/R6+mozk3eReogRBa2QUD0YGb0eZ2LKRhzHA362lCrkG +0r8C4Cxj7D1/5t+sFS/qglxjko6nAAWME5xtvc0C1YgiFo6qnK+TwzAETViwXhhR +L+sQQzpm2F9r/AUpVRNVOVQ59Vwi9wzVopq+8Y9/lp1hbd1JIot9RMjUBpl3Cqph +mcZWOEmyDZo3JI1eGucNYb//raN9TwTiQtdCkzAPWQz08istNZeWZEKHipM46oZE +0JqYWh+nRItk4A8bIaNCd21QNeBG2qAh4x4c6ISvCFHXGaKye/73MTouPCWyAEuw +obPu2kGSezXc5C8qSXj7GGnqnSTCMd6I4ZT0trRrccXNQIG1C2R47/9a0xvzDefo +ZJZDcViZk2r1nBjVZcQnd+TrLVap1t3DM0qOTh5TKMg+ThWNEhfNP18WEvgheavs +8K517p+lc6Y2yL+SDefeD68GUjfMXyBvyKHnRetlC+k +-> ssh-ed25519 hPyiJw mH7iJLzUqd6d2Emkxzf7zDeMNMZzd1+w501ew9zW/CI +Ur/uvRyTjYGfsYO3wz1i3SksipnoNt8APVFG0XJS5ww +-> ssh-ed25519 YFSOsg HZkD6H6inmpQCXgCM7YRY8aCuEKitTr9lux3d8K3vzg +qN7dxXnOvZcvu0UcJVHa0Nil0m2rDveGu1PefbtRbRI +-> ssh-ed25519 iHV63A rwNrmU2Wlt8ws9tFZk9MeZEXVKKXQYkIylc2TGdvDwo +a0duEvHTn0uoW4bon70q/KgOdPoh7aQzhB2EFpV01NM +-> ssh-ed25519 FuRdVg 5nUX068LeAwZ5aIUmKMF6NNuMAgQIpEnUbzlYvnKmHg +ji90oliDxdeLy6+xU5G2JyE+uw02DwbODcfqj8MB7PQ +-> ssh-ed25519 BVsyTA G/HcUWR3/2O6ZMrAU0SW3nnMlxRNXzEhGnYXQjtMBmk +Xkb9eX8fKXYdGq7T5tDZ4ZVc9lVnswz9qSypsRyGU6Y +-> ,q*oT-grease 18 eH/Tc P`5j O" +4Qy4tc85qC/W1N+sLJOVBUuo +--- 5UFLhvauoxBdZMuJy6PNF8wa2CBxqU2cDwvrC9+5BJk +9-sX 5.- 2/>RwL3Q Ǿ/,;Yjc \ No newline at end of file diff --git a/secrets/erpnext-db-root-password.age b/secrets/erpnext-db-root-password.age new file mode 100644 index 0000000..5911c92 --- /dev/null +++ b/secrets/erpnext-db-root-password.age @@ -0,0 +1,31 @@ +age-encryption.org/v1 +-> ssh-ed25519 uYcDNw DGmlYNPgz9u8ptvCW7capt+d/TolEC5rZuA/8QzRVXA +aD6zo+3HExznAyB9NshQ+wlicQzHAQEePiuT0NkbPLg +-> ssh-rsa kFDS0A +D/+sv54EAe2FFHK8xPoyxo+msqwB3snJrieOz6tgOz+HFp/bKMkLDW56sBKep+Du +hiAR03q4uDl8r89aJf9sHyLW+qFxqsqIoqmgOhmAcJhNbYQnyfZ3KRQ+PPXrh1We +epSO/Td3WRB5XcHtwm09gnlWEb4oADOV0DysNDJIsAfEck+nREa2I3vgjoS/6vuX +vt7M/wyMItqBvteUIhvcYL01h7b/+FYmA7NiMJxbtcqKQMjwbhj8J59na01ObPH+ +kzlKa80OYji125nzo/q46BxS5igpgodUSoBR5a4q0wSFDZJRYkOsu2A+Gk/C3iGu +V8mHjjkO38XkOHLkR/zaige35D2KklpXJ1gE92N3fzPNTMzwRLXqLgZtz2p51nw3 +MV/A3TuU1Uohf0ztmbz755AnuuXzNHF9UUYriGh8X+8ZMsbVSiHbpJfe7+hzCLjv +vikjfCvP0EttYqksyF0c1yhx5XRsm0Ab0BIRO3KWBGSwbrfgKN1Ni5K+3A+DWqDV +o5w54fpVr2fZ9yv8D12yZFFJmnOoRoponhbb8CQWq2lQ7VBwuluDLJbgvNGkfrvu +YnnLu9Fj83A6lI6KXYNwf56LdF+d4miSlocEvPHyGe2gzqjNiw+aDaqI6jeuhRK5 +FmHX3YO/zZSiRCCewUyCex88M8Rrz7igEZomnNMcxAQ +-> ssh-ed25519 hPyiJw bqfqVyh0Olxs+MIkYiVPWykFVkIscHIXrSJ11IVfEzQ +YNxR1ySsqO6hUpM9HDLrK9w4NDbDZkqu3pbejg4Hsk4 +-> ssh-ed25519 YFSOsg RgqgD4Rx0Nm+A4OC2MLPNabwXjntusSFCm5juDSbRks +qaSEwkBA0qIkfE7X0gzkDaEPeLid9D6jheAx2Qk89eo +-> ssh-ed25519 iHV63A Y0x1ZtORMMOspem9OOHZCT2iggTdckzOhXAMHAJNTU4 +ZG4Fg1wyWS21LysKhwEBWreT1KlUOc7nYsBadbyN82g +-> ssh-ed25519 FuRdVg Qy5joH+FrKoQGAZGaAC3gDA+GCh1/PuAX8CvyVc9qCY +xtEv2qsJe6CSrI0b+4iFw84LYWEOjvkRZCmbY2OLgZo +-> ssh-ed25519 BVsyTA m9ltg/MxSqyJ8YlgjiIFIuPiLEtAZ4Us56W8fE9tKiw +ky/DdgBXc0pWEWR3mk4mWjsl6DNQTG3q57cnRoNptYM +-> EoettRjt-grease F @g +pFQRo2TqYj1dx9+b2+r6OR8t0cWAiNdcRQF+VPkwCTyX7x5BsWTlQ6vqm/4PXp0K +3t+b3p7sBGshgoQnqv51vs0TRb397X8 +--- 6BVAgRY3BiCpM3KuS1OwyfD8/ua87JrEmIYFFUUCLfc +4޼}" +00fq>>HDR ssh-ed25519 uYcDNw Ibu+78045LD4FdOIHoaX9KuDTKwnKmFKKpyG0jUXGxU +4r1ACHQ88bQx/ceTJK6TpNvbP3nrG541SnX0CVJEwQc +-> ssh-rsa kFDS0A +PepcMWrjxYsN2j+b0cS3Q7/ivIbrPfga8X8nQgHNm3ia2Lf0WAVAPeffW/ip88LF +U14IwdlBt0uK6IDygiCAzdHNhxgDM4eJLkS0rzdyEEArto0pot97u1lZUkXC3eel +OIGUjGDu3xV7LAOzGIcXBc4ZKMoYP/peJMu1kxA34C2YCKERdiufgIs1/svDb/N1 +GEA/0f44m5ZuTlmCjFDloakoUCdsaISWj0LUUWypmA8q9AQczuubEsgi6xmXFQ7Y +q4mLmTFPUv+yij+4Qo473tfvrojgt7ylVPnbif1ZwYi7scOGbblp4AnzdgtubH4Q +D002rF6SS0NyB2LBTus8KCxAApGfL3llrcGweLQ8uk2pAMrvydFiPWW/JA5qEkmF +FZ5FVjJXs6tQFNOQrlJbXKLICIlz7nCfhoWTz333aO96FNOPMFsfNOUSedu7g4aI +wZMmd1l/B1ywUwpTNwPk7YS+Crd0pOl3eAg2TnecWXdtlCjumlQ2XMzvFWDAn75Y +jAON5OXbCglel05JCDjKAu/5+jQk8/6WbgFwJ8OWygRpm9Sc1Pjio0g9rxlDshxM +Jjpc5OmIddn+PDOWjPIMP+gX7WxkaszfPeqe2BdwRncS+aygossQ1MubBwpDZYlG +qkhIKNqaMplfJw2/F6h+6YdC2oIVCN/f9pIuJfDerFM +-> ssh-ed25519 hPyiJw TNkdmVMb2q6Xwp8BK1XDDESKcTUVP3/U2CxgVkSeskM +SVQo+HGrV+pxQyVAZ3yNz7AbSwl0pcOVBV5wDbnDCQo +-> ssh-ed25519 YFSOsg y1eWoyZ5+zBRvS4rhLjT7uDoV5tK2CPKrG/kPJqXtwQ +Eu2Hhr5S/J+SC5cYGXmR2RXI7u/r7JHa2tiE7+kvM4Q +-> ssh-ed25519 iHV63A Rt3RtT0X/CsIu0CDOgwUI5tvtqPRxi9oe4qbq7bBhF0 +Q9H192GZM8IUIC1XGn2CYvzWYcewYn0l6L8x7+QDfjc +-> ssh-ed25519 FuRdVg J4XF2+jC7UIhvbLkp3x1G5UvCL4+9JKgwkLtcnp2NgE +jUZKRQlnEk71GeSyUUPxcTDPGh6YRbHCULXL3IPSrY0 +-> ssh-ed25519 BVsyTA s2Z5lJOuKnzt1HWBtG3XhsotHe1FRP/1dZG+c4D0Qlc +6GDXbJFyojR2d/vnaqpQzEHmJfmkRo0FttBeoH1fHmk +-> R-~x-grease +yQmd3Mi+ZUG8euTmcWOsjO4nUwQ +--- 60WtnpLhUTtwPFKsAGnEOxc+mZac00PXnIBplXxiAdg +RV$^\׻ԋa49=h1'FЍwŽV3@#$T헐 \ No newline at end of file diff --git a/secrets/keycloak-database-password.age b/secrets/keycloak-database-password.age new file mode 100644 index 0000000000000000000000000000000000000000..7affc35c6da7d40fabe25ee3fa7623b1ce6205e9 GIT binary patch literal 1617 zcmZY8%j@h083tfCA`L>3LQ%VL>_%w#nMpFa3`YvdLmL3^$*Vr;R*r?~19ILa8=&MO;&YrQ<1sxx}~ZYt;)^xhM96 zp;IDouJx0Z?YH!rWkWl1Cf->MbRwEK%^F#8RG6!G%+eLa`I**s?k3|HZA$?Z!%Q}> z%$kJ9MT57QsA2VyI&jTAr7KG7DTh^eZdP@nX&L9<2^YgOb|UK5Cb)$lK&a?Ygtv@h zk#1A5R^+=Y43z9`jgHD}gFr5QjS-sPN`<@_p* zCKkrT)(b6;%=BY~8ye>tL@+uDqUmvWheoG$1|2P1xEbxc%VArbk9g2Oc2?jv#Z zwYo8q$)cRO-b0Lb>5F7>SFK(YW;bfLn!WlmnVZA8En(KqQb1^rNT4pv3Rpw#|1Co9Ug?)nuIyrC)#iI2>1m|?X z!+Cp5n0wMJS$*JdGXvIAy--Hv@EnwzV<^Q+4bnhgN}xSSSGYUQ;l0RtzR(>izM&%3 z8y;>S*u5HKYLFsF`V8^hbSxrXZj?bl)!A_sVC`H8GcQNp)D&twQMoP|b0(sv+`5b1 zIKb6t9#gd)E$G5odto@-ru1p-9VEwY(6GRSO5~Vvpa&cH*bTPpYI%X9Le}O1SU~nE z>J8l<%(5F7hQ82}BCncoodmPEkt41HAcQ#xOWG_3wgQo7pq&*BPa-!s8whZX&0K`W z=61N!?6W_9wwhR7lH;^FV!fgD;Jw6py^1mjRrVykc>7My*8|@u7oiI$vANA#AD|;E za(rudv}Uib4G{_zz6fJg73cZs2vLOE%B(`6k(WKM-8fC@qD{RRRS@9|!3nX`8t0@W zd|4`R|ByjPV+wR^u#w}vyW2b9goJVthNj0w@`+fH0&8mBJ5YSOuzY@|=-TpS#`gW1 zd|pcg6Gy4dlC69T!}bB%RTDF49pX}bwQUiNfMBH3_HftPqXBN8YA(3eQctGYL8bJI zowl4n@2zsjBI*tAiayX}Y45UPwftX`+;9!dXmeS$ZK`35l1zsy$bi_2Ipxt8tX}lvO&CHf^c|IF$c8gAJ zD3`GA_XN`#M668hqzhMKJ#b-|D6*}FDwU$D&g}{vz5tb&9_du8d9z~y? zKlA>N-b&H@w?BK2_>S_=4?g_dJ753mx4!!+