///
/// QuickCryptoOnLoad.cpp
/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
/// https://github.com/mrousavy/nitro
/// Copyright © Marc Rousavy @ Margelo
///

#ifndef BUILDING_QUICKCRYPTO_WITH_GENERATED_CMAKE_PROJECT
#error QuickCryptoOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
#endif

#include "QuickCryptoOnLoad.hpp"

#include <jni.h>
#include <fbjni/fbjni.h>
#include <NitroModules/HybridObjectRegistry.hpp>

#include "HybridArgon2.hpp"
#include "HybridBlake3.hpp"
#include "HybridCertificate.hpp"
#include "HybridCipher.hpp"
#include "HybridCipherFactory.hpp"
#include "HybridDhKeyPair.hpp"
#include "HybridDiffieHellman.hpp"
#include "HybridDsaKeyPair.hpp"
#include "HybridECDH.hpp"
#include "HybridEcKeyPair.hpp"
#include "HybridEdKeyPair.hpp"
#include "HybridHash.hpp"
#include "HybridHkdf.hpp"
#include "HybridHmac.hpp"
#include "HybridKmac.hpp"
#include "HybridKeyObjectHandle.hpp"
#include "HybridMlDsaKeyPair.hpp"
#include "HybridMlKemKeyPair.hpp"
#include "HybridSlhDsaKeyPair.hpp"
#include "HybridPbkdf2.hpp"
#include "HybridPrime.hpp"
#include "HybridRandom.hpp"
#include "HybridRsaCipher.hpp"
#include "HybridRsaKeyPair.hpp"
#include "HybridScrypt.hpp"
#include "HybridSignHandle.hpp"
#include "HybridTurboShake.hpp"
#include "HybridUtils.hpp"
#include "HybridVerifyHandle.hpp"
#include "HybridX509Certificate.hpp"

namespace margelo::nitro::crypto {

int initialize(JavaVM* vm) {
  using namespace margelo::nitro;
  using namespace margelo::nitro::crypto;
  using namespace facebook;

  return facebook::jni::initialize(vm, [] {
    // Register native JNI methods
    

    // Register Nitro Hybrid Objects
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Argon2",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridArgon2>,
                      "The HybridObject \"HybridArgon2\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridArgon2>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Blake3",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridBlake3>,
                      "The HybridObject \"HybridBlake3\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridBlake3>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Certificate",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridCertificate>,
                      "The HybridObject \"HybridCertificate\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridCertificate>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Cipher",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridCipher>,
                      "The HybridObject \"HybridCipher\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridCipher>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "CipherFactory",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridCipherFactory>,
                      "The HybridObject \"HybridCipherFactory\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridCipherFactory>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "DhKeyPair",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridDhKeyPair>,
                      "The HybridObject \"HybridDhKeyPair\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridDhKeyPair>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "DiffieHellman",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridDiffieHellman>,
                      "The HybridObject \"HybridDiffieHellman\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridDiffieHellman>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "DsaKeyPair",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridDsaKeyPair>,
                      "The HybridObject \"HybridDsaKeyPair\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridDsaKeyPair>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "ECDH",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridECDH>,
                      "The HybridObject \"HybridECDH\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridECDH>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "EcKeyPair",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridEcKeyPair>,
                      "The HybridObject \"HybridEcKeyPair\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridEcKeyPair>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "EdKeyPair",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridEdKeyPair>,
                      "The HybridObject \"HybridEdKeyPair\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridEdKeyPair>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Hash",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridHash>,
                      "The HybridObject \"HybridHash\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridHash>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Hkdf",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridHkdf>,
                      "The HybridObject \"HybridHkdf\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridHkdf>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Hmac",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridHmac>,
                      "The HybridObject \"HybridHmac\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridHmac>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Kmac",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridKmac>,
                      "The HybridObject \"HybridKmac\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridKmac>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "KeyObjectHandle",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridKeyObjectHandle>,
                      "The HybridObject \"HybridKeyObjectHandle\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridKeyObjectHandle>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "MlDsaKeyPair",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridMlDsaKeyPair>,
                      "The HybridObject \"HybridMlDsaKeyPair\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridMlDsaKeyPair>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "MlKemKeyPair",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridMlKemKeyPair>,
                      "The HybridObject \"HybridMlKemKeyPair\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridMlKemKeyPair>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "SlhDsaKeyPair",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridSlhDsaKeyPair>,
                      "The HybridObject \"HybridSlhDsaKeyPair\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridSlhDsaKeyPair>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Pbkdf2",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridPbkdf2>,
                      "The HybridObject \"HybridPbkdf2\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridPbkdf2>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Prime",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridPrime>,
                      "The HybridObject \"HybridPrime\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridPrime>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Random",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridRandom>,
                      "The HybridObject \"HybridRandom\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridRandom>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "RsaCipher",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridRsaCipher>,
                      "The HybridObject \"HybridRsaCipher\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridRsaCipher>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "RsaKeyPair",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridRsaKeyPair>,
                      "The HybridObject \"HybridRsaKeyPair\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridRsaKeyPair>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Scrypt",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridScrypt>,
                      "The HybridObject \"HybridScrypt\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridScrypt>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "SignHandle",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridSignHandle>,
                      "The HybridObject \"HybridSignHandle\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridSignHandle>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "TurboShake",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridTurboShake>,
                      "The HybridObject \"HybridTurboShake\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridTurboShake>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "Utils",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridUtils>,
                      "The HybridObject \"HybridUtils\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridUtils>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "VerifyHandle",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridVerifyHandle>,
                      "The HybridObject \"HybridVerifyHandle\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridVerifyHandle>();
      }
    );
    HybridObjectRegistry::registerHybridObjectConstructor(
      "X509CertificateHandle",
      []() -> std::shared_ptr<HybridObject> {
        static_assert(std::is_default_constructible_v<HybridX509Certificate>,
                      "The HybridObject \"HybridX509Certificate\" is not default-constructible! "
                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
        return std::make_shared<HybridX509Certificate>();
      }
    );
  });
}

} // namespace margelo::nitro::crypto