{
  lib,
  flake-parts-lib,
}:
let
  inherit (lib) mkOption types;
  inherit (flake-parts-lib) mkPerSystemModule;
in {
  options.perSystem = mkPerSystemModule ({ pkgs, system, config', ... }: {

    kbdConfigurations = {
      firmware = {
        qmk_firmware = mkOption {
          type = types.path;
          default = pkgs.qmk_firmware;
          description = "Default qmk_firmware to use";
        };
      };

      kbds = mkOption {
        default = {};
        type = types.attrsOf <| types.submodule (args: {
          options = {
            firmware = {
              type = mkOption {
                type = types.enum [ "qmk" ];
                default = "qmk";
                description = "Keyboard firmware type. Extensible for other firmwares";
              };

              qmk_firmware = mkOption {
                type = types.path;
                default = config'.kbdConfigurations.qmk_firmware;
                description = "qmk_firmware to use";
              };
            };

            qmk = {
              keyboard = {
                name = mkOption {
                  type = types.str;
                  description = "path to keyboard";
                };

                revision = mkOption {
                  type = types.nullOr types.str;
                  description = "keyboard revision";
                };

                _path = mkOption {
                  type = types.str;
                  default = lib.concatStringsSep "/" ([ args.config.name ] ++ optional (args.config.revision != null) args.config.revision);
                };

                _keymapsPath = mkOption {
                  type = types.str;
                  default = lib.concatStringsSep [ args.config.qmk.keyboard._path "keymaps" ];
                };
              };

              keymap = {
                name = mkOption {
                  type = types.str;
                };

                _path = mkOption {
                  type = types.str;
                  default = "${args.config.qmk.keyboard._path}/keymaps/${args.config.qmk.keymap.name}";
                };

                src = mkOption {
                  type = types.nullOr types.path;
                  default = null;
                };
              };

              build = {
                bin = mkOption {
                  type = types.path;
                  default = let
                    ksrc = args.config.keymap.src;
                  in pkgs.stdenv.mkDerivation {
                      name = "qmk:${args.config.qmk.keyboard._path}:${args.config.qmk.keymap.name}";
                      srcs = [
                        {
                          name = "qmk_firmware";
                          src = args.config.firmware.qmk_firmware;
                        }
                      ] ++ lib.optional (ksrc != null) {
                          name = "keymap";
                          src = ksrc;
                        };

                      sourceRoot = "qmk_firmware";

                      nativeBuildImports = [
                        pkgs.qmk
                      ];

                      postUnpack = lib.optionalString (ksrc != null) ''
                        mkdir -pv "keyboards/${args.config.keymap._path}"
                        cp -rv ../keymap/* "keyboards/${args.config.keymap._path}"
                      '';

                      buildPhase = ''
                        SKIP_GIT=yes SKIP_VERSION=yes \
                          make "keyboards/${args.config.keyboard._path}:${args.config.keymap.name}"
                      '';

                      installPhase = ''
                        mkdir -p $out
                        cp -v *.{bin,hex} $out/
                      '';


                    };
                };

                flash = mkOption {
                  type = types.package;
                };
              };

            };

          };
        });
      };



    };
  })
}