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

#import <Foundation/Foundation.h>
#import <NitroModules/HybridObjectRegistry.hpp>

#import <type_traits>

#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"

@interface QuickCryptoAutolinking : NSObject
@end

@implementation QuickCryptoAutolinking

+ (void) load {
  using namespace margelo::nitro;
  using namespace margelo::nitro::crypto;

  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>();
    }
  );
}

@end
