diff --git a/lib/libelectronic-id b/lib/libelectronic-id
index f85a8921..dfb29b8e 160000
--- a/lib/libelectronic-id
+++ b/lib/libelectronic-id
@@ -1 +1 @@
-Subproject commit f85a89216ecd9738b36e701b5a86da4d5152d3c4
+Subproject commit dfb29b8eef499507b5ea9858ea61a835e48bf308
diff --git a/src/controller/application.cpp b/src/controller/application.cpp
index 2832cdf9..7af1df26 100644
--- a/src/controller/application.cpp
+++ b/src/controller/application.cpp
@@ -185,12 +185,12 @@ CommandWithArgumentsPtr Application::parseArgs()
 void Application::registerMetatypes()
 {
     qRegisterMetaType<electronic_id::AutoSelectFailed::Reason>();
-    qRegisterMetaType<electronic_id::CardInfo::ptr>();
-    qRegisterMetaType<std::vector<electronic_id::CardInfo::ptr>>();
+    qRegisterMetaType<electronic_id::ElectronicID::ptr>();
+    qRegisterMetaType<std::vector<electronic_id::ElectronicID::ptr>>();
     qRegisterMetaType<electronic_id::VerifyPinFailed::Status>();
 
-    qRegisterMetaType<CardCertificateAndPinInfo>();
-    qRegisterMetaType<std::vector<CardCertificateAndPinInfo>>();
+    qRegisterMetaType<EidCertificateAndPinInfo>();
+    qRegisterMetaType<std::vector<EidCertificateAndPinInfo>>();
 
     qRegisterMetaType<RetriableError>();
 }
diff --git a/src/controller/certandpininfo.hpp b/src/controller/certandpininfo.hpp
index e3a659a5..9af08570 100644
--- a/src/controller/certandpininfo.hpp
+++ b/src/controller/certandpininfo.hpp
@@ -48,13 +48,13 @@ struct PinInfo
     static constexpr int PIN_PAD_PIN_ENTRY_TIMEOUT = pcsc_cpp::PIN_PAD_PIN_ENTRY_TIMEOUT;
 };
 
-struct CardCertificateAndPinInfo
+struct EidCertificateAndPinInfo
 {
-    electronic_id::CardInfo::ptr cardInfo;
+    electronic_id::ElectronicID::ptr eid;
     QByteArray certificateBytesInDer;
     QSslCertificate certificate {};
     CertificateInfo certInfo;
     PinInfo pinInfo;
 };
 
-Q_DECLARE_METATYPE(CardCertificateAndPinInfo)
+Q_DECLARE_METATYPE(EidCertificateAndPinInfo)
diff --git a/src/controller/command-handlers/authenticate.cpp b/src/controller/command-handlers/authenticate.cpp
index 904d30d1..285613a1 100644
--- a/src/controller/command-handlers/authenticate.cpp
+++ b/src/controller/command-handlers/authenticate.cpp
@@ -118,20 +118,20 @@ Authenticate::Authenticate(const CommandWithArguments& cmd) : CertificateReader(
 }
 
 QVariantMap Authenticate::onConfirm(WebEidUI* window,
-                                    const CardCertificateAndPinInfo& cardCertAndPin)
+                                    const EidCertificateAndPinInfo& certAndPinInfo)
 {
     try {
         const auto signatureAlgorithm =
-            QString::fromStdString(cardCertAndPin.cardInfo->eid().authSignatureAlgorithm());
+            QString::fromStdString(certAndPinInfo.eid->authSignatureAlgorithm());
         pcsc_cpp::byte_vector pin;
         // Reserve space for APDU overhead (5 bytes) + PIN padding (16 bytes) to prevent PIN memory
         // reallocation. The 16-byte limit comes from the max PIN length of 12 bytes across all card
         // implementations in lib/libelectronic-id/src/electronic-ids/pcsc/.
         pin.reserve(5 + 16);
-        getPin(pin, cardCertAndPin.cardInfo->eid(), window);
-        const auto signature = createSignature(origin.url(), challengeNonce,
-                                               cardCertAndPin.cardInfo->eid(), std::move(pin));
-        return createAuthenticationToken(signatureAlgorithm, cardCertAndPin.certificateBytesInDer,
+        getPin(pin, *certAndPinInfo.eid, window);
+        const auto signature =
+            createSignature(origin.url(), challengeNonce, *certAndPinInfo.eid, std::move(pin));
+        return createAuthenticationToken(signatureAlgorithm, certAndPinInfo.certificateBytesInDer,
                                          signature);
 
     } catch (const VerifyPinFailed& failure) {
diff --git a/src/controller/command-handlers/authenticate.hpp b/src/controller/command-handlers/authenticate.hpp
index 2034198c..c40e0c1d 100644
--- a/src/controller/command-handlers/authenticate.hpp
+++ b/src/controller/command-handlers/authenticate.hpp
@@ -33,7 +33,7 @@ class Authenticate : public CertificateReader
 
     void connectSignals(const WebEidUI* window) override;
     QVariantMap onConfirm(WebEidUI* window,
-                          const CardCertificateAndPinInfo& cardCertAndPin) override;
+                          const EidCertificateAndPinInfo& certAndPinInfo) override;
 
 signals:
     void verifyPinFailed(const electronic_id::VerifyPinFailed::Status status,
diff --git a/src/controller/command-handlers/certificatereader.cpp b/src/controller/command-handlers/certificatereader.cpp
index e48f2722..42e5a78c 100644
--- a/src/controller/command-handlers/certificatereader.cpp
+++ b/src/controller/command-handlers/certificatereader.cpp
@@ -31,17 +31,17 @@ using namespace electronic_id;
 namespace
 {
 
-CardCertificateAndPinInfo getCertificateWithStatusAndInfo(const CardInfo::ptr& card,
-                                                          const CertificateType certificateType)
+EidCertificateAndPinInfo getCertificateWithStatusAndInfo(const ElectronicID::ptr& eid,
+                                                         const CertificateType certificateType)
 {
-    const auto certificateBytes = card->eid().getCertificate(certificateType);
+    const auto certificateBytes = eid->getCertificate(certificateType);
 
     QByteArray certificateDer(reinterpret_cast<const char*>(certificateBytes.data()),
                               int(certificateBytes.size()));
     QSslCertificate certificate(certificateDer, QSsl::Der);
     if (certificate.isNull()) {
         THROW(SmartCardChangeRequiredError,
-              "Invalid certificate returned by electronic ID " + card->eid().name());
+              "Invalid certificate returned by electronic ID " + eid->name());
     }
 
     auto subject = certificate.subjectInfo(QSslCertificate::CommonName).join(' ');
@@ -61,16 +61,16 @@ CardCertificateAndPinInfo getCertificateWithStatusAndInfo(const CardInfo::ptr& c
     CertificateInfo certInfo {
         certificateType, certificate.expiryDate() < QDateTime::currentDateTimeUtc(),
         certificate.effectiveDate() > QDateTime::currentDateTimeUtc(), std::move(subject)};
-    PinInfo pinInfo {certificateType.isAuthentication() ? card->eid().authPinMinMaxLength()
-                                                        : card->eid().signingPinMinMaxLength(),
-                     certificateType.isAuthentication() ? card->eid().authPinRetriesLeft()
-                                                        : card->eid().signingPinRetriesLeft(),
-                     card->eid().smartcard().readerHasPinPad()};
+    PinInfo pinInfo {certificateType.isAuthentication() ? eid->authPinMinMaxLength()
+                                                        : eid->signingPinMinMaxLength(),
+                     certificateType.isAuthentication() ? eid->authPinRetriesLeft()
+                                                        : eid->signingPinRetriesLeft(),
+                     eid->smartcard().readerHasPinPad()};
     if (pinInfo.pinRetriesCount.first == 0) {
         pinInfo.pinIsBlocked = true;
     }
 
-    return {card, std::move(certificateDer), certificate, std::move(certInfo), std::move(pinInfo)};
+    return {eid, std::move(certificateDer), certificate, std::move(certInfo), std::move(pinInfo)};
 }
 
 } // namespace
@@ -83,27 +83,27 @@ CertificateReader::CertificateReader(const CommandWithArguments& cmd) : CommandH
     }
 }
 
-void CertificateReader::run(const std::vector<CardInfo::ptr>& cards)
+void CertificateReader::run(const std::vector<ElectronicID::ptr>& eids)
 {
-    REQUIRE_NOT_EMPTY_CONTAINS_NON_NULL_PTRS(cards)
+    REQUIRE_NOT_EMPTY_CONTAINS_NON_NULL_PTRS(eids)
 
     certificateType = command.first == CommandType::AUTHENTICATE ? CertificateType::AUTHENTICATION
                                                                  : CertificateType::SIGNING;
 
-    std::vector<CardCertificateAndPinInfo> certInfos;
-    certInfos.reserve(cards.size());
-    for (const auto& card : cards) {
+    std::vector<EidCertificateAndPinInfo> certAndPinInfos;
+    certAndPinInfos.reserve(eids.size());
+    for (const auto& eid : eids) {
         try {
-            certInfos.push_back(getCertificateWithStatusAndInfo(card, certificateType));
+            certAndPinInfos.push_back(getCertificateWithStatusAndInfo(eid, certificateType));
         } catch (const WrongCertificateTypeError&) {
             // Ignore eIDs that don't support the given ceritifcate type.
         }
     }
 
-    if (certInfos.empty()) {
+    if (certAndPinInfos.empty()) {
         emit retry(RetriableError::NO_VALID_CERTIFICATE_AVAILABLE);
     } else {
-        emitCertificatesReady(certInfos);
+        emitCertificatesReady(certAndPinInfos);
     }
 }
 
@@ -117,12 +117,12 @@ void CertificateReader::connectSignals(const WebEidUI* window)
 }
 
 void CertificateReader::emitCertificatesReady(
-    const std::vector<CardCertificateAndPinInfo>& certInfos)
+    const std::vector<EidCertificateAndPinInfo>& certAndPinInfos)
 {
-    if (certInfos.size() == 1) {
-        emit singleCertificateReady(origin, certInfos[0]);
+    if (certAndPinInfos.size() == 1) {
+        emit singleCertificateReady(origin, certAndPinInfos[0]);
     } else {
-        emit multipleCertificatesReady(origin, certInfos);
+        emit multipleCertificatesReady(origin, certAndPinInfos);
     }
 }
 
diff --git a/src/controller/command-handlers/certificatereader.hpp b/src/controller/command-handlers/certificatereader.hpp
index 8d006c8c..8a3930ba 100644
--- a/src/controller/command-handlers/certificatereader.hpp
+++ b/src/controller/command-handlers/certificatereader.hpp
@@ -33,12 +33,12 @@ class CertificateReader : public CommandHandler
 public:
     explicit CertificateReader(const CommandWithArguments& cmd);
 
-    void run(const std::vector<electronic_id::CardInfo::ptr>& cards) override;
+    void run(const std::vector<electronic_id::ElectronicID::ptr>& eids) override;
     void connectSignals(const WebEidUI* window) override;
 
 protected:
     virtual void
-    emitCertificatesReady(const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos);
+    emitCertificatesReady(const std::vector<EidCertificateAndPinInfo>& certAndPinInfos);
     void validateAndStoreOrigin(const QVariantMap& arguments);
 
     electronic_id::CertificateType certificateType = electronic_id::CertificateType::NONE;
diff --git a/src/controller/command-handlers/getcertificate.cpp b/src/controller/command-handlers/getcertificate.cpp
index f51a168a..41502e57 100644
--- a/src/controller/command-handlers/getcertificate.cpp
+++ b/src/controller/command-handlers/getcertificate.cpp
@@ -47,12 +47,12 @@ GetCertificate::GetCertificate(const CommandWithArguments& cmd) : CertificateRea
 }
 
 QVariantMap GetCertificate::onConfirm(WebEidUI* /* window */,
-                                      const CardCertificateAndPinInfo& cardCertAndPin)
+                                      const EidCertificateAndPinInfo& certAndPinInfo)
 {
     // Quoting https://tools.ietf.org/html/rfc7515#section-4.1.6:
     // Each string in the array is a Base64-encoded (Section 4 of [RFC4648] -- not
     // Base64url-encoded) DER [ITU.X690.2008] PKIX certificate value.
-    auto certPem = cardCertAndPin.certificateBytesInDer.toBase64();
-    auto algos = supportedSigningAlgos(cardCertAndPin.cardInfo->eid());
+    auto certPem = certAndPinInfo.certificateBytesInDer.toBase64();
+    auto algos = supportedSigningAlgos(*certAndPinInfo.eid);
     return {{"certificate", QString(certPem)}, {"supportedSignatureAlgorithms", algos}};
 }
diff --git a/src/controller/command-handlers/getcertificate.hpp b/src/controller/command-handlers/getcertificate.hpp
index 440fb279..1b0d90ea 100644
--- a/src/controller/command-handlers/getcertificate.hpp
+++ b/src/controller/command-handlers/getcertificate.hpp
@@ -32,5 +32,5 @@ class GetCertificate : public CertificateReader
     GetCertificate(const CommandWithArguments& cmd);
 
     QVariantMap onConfirm(WebEidUI* window,
-                          const CardCertificateAndPinInfo& cardCertAndPin) override;
+                          const EidCertificateAndPinInfo& certAndPinInfo) override;
 };
diff --git a/src/controller/command-handlers/sign.cpp b/src/controller/command-handlers/sign.cpp
index 28736cfd..87c81ee5 100644
--- a/src/controller/command-handlers/sign.cpp
+++ b/src/controller/command-handlers/sign.cpp
@@ -69,14 +69,14 @@ Sign::Sign(const CommandWithArguments& cmd) : CertificateReader(cmd)
     validateAndStoreOrigin(arguments);
 }
 
-void Sign::emitCertificatesReady(const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos)
+void Sign::emitCertificatesReady(const std::vector<EidCertificateAndPinInfo>& certAndPinInfos)
 {
-    const CardCertificateAndPinInfo* cardWithCertificateFromArgs = nullptr;
+    const EidCertificateAndPinInfo* cardWithCertificateFromArgs = nullptr;
 
-    for (const auto& cardCertAndPin : cardCertAndPinInfos) {
+    for (const auto& certAndPinInfo : certAndPinInfos) {
         // Check if the certificate read from the eID matches the certificate provided as argument.
-        if (cardCertAndPin.certificate.toDer() == userEidCertificateFromArgs) {
-            cardWithCertificateFromArgs = &cardCertAndPin;
+        if (certAndPinInfo.certificate.toDer() == userEidCertificateFromArgs) {
+            cardWithCertificateFromArgs = &certAndPinInfo;
         }
     }
 
@@ -86,16 +86,16 @@ void Sign::emitCertificatesReady(const std::vector<CardCertificateAndPinInfo>& c
         return;
     }
 
-    if (!cardWithCertificateFromArgs->cardInfo->eid().isSupportedSigningHashAlgorithm(hashAlgo)) {
+    if (!cardWithCertificateFromArgs->eid->isSupportedSigningHashAlgorithm(hashAlgo)) {
         THROW(ArgumentFatalError,
-              "Electronic ID " + cardWithCertificateFromArgs->cardInfo->eid().name()
+              "Electronic ID " + cardWithCertificateFromArgs->eid->name()
                   + " does not support hash algorithm " + std::string(hashAlgo));
     }
 
     emit singleCertificateReady(origin, *cardWithCertificateFromArgs);
 }
 
-QVariantMap Sign::onConfirm(WebEidUI* window, const CardCertificateAndPinInfo& cardCertAndPin)
+QVariantMap Sign::onConfirm(WebEidUI* window, const EidCertificateAndPinInfo& certAndPinInfo)
 {
     try {
         pcsc_cpp::byte_vector pin;
@@ -103,11 +103,10 @@ QVariantMap Sign::onConfirm(WebEidUI* window, const CardCertificateAndPinInfo& c
         // reallocation. The 16-byte limit comes from the max PIN length of 12 bytes across all card
         // implementations in lib/libelectronic-id/src/electronic-ids/pcsc/.
         pin.reserve(5 + 16);
-        getPin(pin, cardCertAndPin.cardInfo->eid(), window);
-        const auto signature =
-            signHash(cardCertAndPin.cardInfo->eid(), std::move(pin), docHash, hashAlgo);
-        return {{QStringLiteral("signature"), signature.first},
-                {QStringLiteral("signatureAlgorithm"), signature.second}};
+        getPin(pin, *certAndPinInfo.eid, window);
+        auto signature = signHash(*certAndPinInfo.eid, std::move(pin), docHash, hashAlgo);
+        return {{QStringLiteral("signature"), std::move(signature.first)},
+                {QStringLiteral("signatureAlgorithm"), std::move(signature.second)}};
 
     } catch (const VerifyPinFailed& failure) {
         switch (failure.status()) {
diff --git a/src/controller/command-handlers/sign.hpp b/src/controller/command-handlers/sign.hpp
index 08211538..4058908d 100644
--- a/src/controller/command-handlers/sign.hpp
+++ b/src/controller/command-handlers/sign.hpp
@@ -33,7 +33,7 @@ class Sign : public CertificateReader
 
     void connectSignals(const WebEidUI* window) override;
     QVariantMap onConfirm(WebEidUI* window,
-                          const CardCertificateAndPinInfo& cardCertAndPin) override;
+                          const EidCertificateAndPinInfo& certAndPinInfo) override;
 
 signals:
     void signingCertificateMismatch();
@@ -41,8 +41,8 @@ class Sign : public CertificateReader
                          const qint8 retriesLeft);
 
 private:
-    void emitCertificatesReady(
-        const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos) override;
+    void
+    emitCertificatesReady(const std::vector<EidCertificateAndPinInfo>& certAndPinInfos) override;
     void validateAndStoreDocHashAndHashAlgo(const QVariantMap& args);
 
     QByteArray docHash;
diff --git a/src/controller/commandhandler.hpp b/src/controller/commandhandler.hpp
index b1b04608..4a6136d0 100644
--- a/src/controller/commandhandler.hpp
+++ b/src/controller/commandhandler.hpp
@@ -33,20 +33,18 @@ class CommandHandler : public QObject
 public:
     using ptr = std::unique_ptr<CommandHandler>;
 
-    virtual void run(const std::vector<electronic_id::CardInfo::ptr>& cards) = 0;
+    virtual void run(const std::vector<electronic_id::ElectronicID::ptr>& eids) = 0;
     virtual void connectSignals(const WebEidUI* window) = 0;
     virtual QVariantMap onConfirm(WebEidUI* window,
-                                  const CardCertificateAndPinInfo& cardCertAndPin) = 0;
+                                  const EidCertificateAndPinInfo& certAndPinInfo) = 0;
 
     CommandType commandType() const { return command.first; }
 
 signals:
     void retry(const RetriableError error);
-    void
-    multipleCertificatesReady(const QUrl& origin,
-                              const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos);
-    void singleCertificateReady(const QUrl& origin,
-                                const CardCertificateAndPinInfo& cardCertAndPinInfo);
+    void multipleCertificatesReady(const QUrl& origin,
+                                   const std::vector<EidCertificateAndPinInfo>& certAndPinInfos);
+    void singleCertificateReady(const QUrl& origin, const EidCertificateAndPinInfo& certAndPinInfo);
 
 protected:
     CommandHandler(const CommandWithArguments& cmd) : command(cmd) {}
diff --git a/src/controller/controller.cpp b/src/controller/controller.cpp
index 5894e103..f40836b0 100644
--- a/src/controller/controller.cpp
+++ b/src/controller/controller.cpp
@@ -163,17 +163,18 @@ void Controller::connectOkCancelWaitingForPinPad()
     connect(window, &WebEidUI::waitingForPinPad, this, &Controller::onConfirmCommandHandler);
 }
 
-void Controller::onCardsAvailable(const std::vector<electronic_id::CardInfo::ptr>& availableCards)
+void Controller::onCardsAvailable(
+    const std::vector<electronic_id::ElectronicID::ptr>& availableEids)
 {
     try {
         REQUIRE_NON_NULL(commandHandler)
         REQUIRE_NON_NULL(window)
-        REQUIRE_NOT_EMPTY_CONTAINS_NON_NULL_PTRS(availableCards)
+        REQUIRE_NOT_EMPTY_CONTAINS_NON_NULL_PTRS(availableEids)
 
-        for (const auto& card : availableCards) {
+        for (const auto& card : availableEids) {
             const auto protocol =
-                card->eid().smartcard().protocol() == SmartCard::Protocol::T0 ? "T=0" : "T=1";
-            qInfo() << "Card" << card->eid().name() << "in reader" << card->reader().name
+                card->smartcard().protocol() == SmartCard::Protocol::T0 ? "T=0" : "T=1";
+            qInfo() << "Card" << card->name() << "in reader" << card->smartcard().readerName()
                     << "using protocol" << protocol;
         }
 
@@ -181,18 +182,18 @@ void Controller::onCardsAvailable(const std::vector<electronic_id::CardInfo::ptr
 
         commandHandler->connectSignals(window);
 
-        runCommandHandler(availableCards);
+        runCommandHandler(availableEids);
 
     } catch (const std::exception& error) {
         onCriticalFailure(error.what());
     }
 }
 
-void Controller::runCommandHandler(const std::vector<electronic_id::CardInfo::ptr>& availableCards)
+void Controller::runCommandHandler(const std::vector<ElectronicID::ptr>& availableEids)
 {
     try {
         CommandHandlerRunThread* commandHandlerRunThread =
-            new CommandHandlerRunThread(this, *commandHandler, availableCards);
+            new CommandHandlerRunThread(this, *commandHandler, availableEids);
         saveChildThreadPtrAndConnectFailureFinish(commandHandlerRunThread);
         connectRetry(commandHandlerRunThread);
 
@@ -247,13 +248,13 @@ void Controller::disposeUI()
     }
 }
 
-void Controller::onConfirmCommandHandler(const CardCertificateAndPinInfo& cardCertAndPinInfo)
+void Controller::onConfirmCommandHandler(const EidCertificateAndPinInfo& certAndPinInfo)
 {
     stopCardEventMonitorThread();
 
     try {
         CommandHandlerConfirmThread* commandHandlerConfirmThread =
-            new CommandHandlerConfirmThread(this, *commandHandler, window, cardCertAndPinInfo);
+            new CommandHandlerConfirmThread(this, *commandHandler, window, certAndPinInfo);
         connect(commandHandlerConfirmThread, &CommandHandlerConfirmThread::completed, this,
                 &Controller::onCommandHandlerConfirmCompleted);
         saveChildThreadPtrAndConnectFailureFinish(commandHandlerConfirmThread);
@@ -317,10 +318,10 @@ void Controller::connectRetry(const ControllerChildThread* childThread)
     connect(window, &WebEidUI::retry, this, &Controller::onRetry);
 }
 
-void Controller::onDialogOK(const CardCertificateAndPinInfo& cardCertAndPinInfo)
+void Controller::onDialogOK(const EidCertificateAndPinInfo& certAndPinInfo)
 {
     if (commandHandler) {
-        onConfirmCommandHandler(cardCertAndPinInfo);
+        onConfirmCommandHandler(certAndPinInfo);
     } else {
         // This should not happen, and when it does, OK should be equivalent to cancel.
         onPinPadCancel();
diff --git a/src/controller/controller.hpp b/src/controller/controller.hpp
index e4af4828..565cf708 100644
--- a/src/controller/controller.hpp
+++ b/src/controller/controller.hpp
@@ -47,13 +47,13 @@ class Controller : public QObject
     void run();
 
     // Called either directly from run() or from the monitor thread when cards are available.
-    void onCardsAvailable(const std::vector<electronic_id::CardInfo::ptr>& availableCards);
+    void onCardsAvailable(const std::vector<electronic_id::ElectronicID::ptr>& availableEids);
 
     // Called when CommandHandlerRunThread finishes execution.
     void onCertificatesLoaded();
 
     // Called either directly from onDialogOK().
-    void onConfirmCommandHandler(const CardCertificateAndPinInfo& cardCertAndPinInfo);
+    void onConfirmCommandHandler(const EidCertificateAndPinInfo& certAndPinInfo);
 
     // Called from CommandHandlerConfirm thread.
     void onCommandHandlerConfirmCompleted(const QVariantMap& result);
@@ -62,7 +62,7 @@ class Controller : public QObject
     void onRetry();
 
     // User events from the dialog.
-    void onDialogOK(const CardCertificateAndPinInfo& cardCertAndPinInfo);
+    void onDialogOK(const EidCertificateAndPinInfo& certAndPinInfo);
     void onDialogCancel();
 
     // Called when user presses cancel on PIN pad.
@@ -73,7 +73,7 @@ class Controller : public QObject
 
 private:
     void startCommandExecution();
-    void runCommandHandler(const std::vector<electronic_id::CardInfo::ptr>& availableCards);
+    void runCommandHandler(const std::vector<electronic_id::ElectronicID::ptr>& availableEids);
     void connectOkCancelWaitingForPinPad();
     void connectRetry(const ControllerChildThread* childThread);
     void saveChildThreadPtrAndConnectFailureFinish(ControllerChildThread* childThread);
diff --git a/src/controller/qeid.hpp b/src/controller/qeid.hpp
index 06c22093..8ee76fa0 100644
--- a/src/controller/qeid.hpp
+++ b/src/controller/qeid.hpp
@@ -27,6 +27,6 @@
 #include <QMetaType>
 
 Q_DECLARE_METATYPE(electronic_id::AutoSelectFailed::Reason)
-Q_DECLARE_METATYPE(electronic_id::CardInfo::ptr)
-Q_DECLARE_METATYPE(std::vector<electronic_id::CardInfo::ptr>)
+Q_DECLARE_METATYPE(electronic_id::ElectronicID::ptr)
+Q_DECLARE_METATYPE(std::vector<electronic_id::ElectronicID::ptr>)
 Q_DECLARE_METATYPE(electronic_id::VerifyPinFailed::Status)
diff --git a/src/controller/threads/cardeventmonitorthread.hpp b/src/controller/threads/cardeventmonitorthread.hpp
index f1087030..2dfe81a0 100644
--- a/src/controller/threads/cardeventmonitorthread.hpp
+++ b/src/controller/threads/cardeventmonitorthread.hpp
@@ -29,11 +29,11 @@ class CardEventMonitorThread : public ControllerChildThread
     Q_OBJECT
 
 public:
-    using card_ptr = electronic_id::CardInfo::ptr;
-    using card_ptr_vector = std::vector<electronic_id::CardInfo::ptr>;
+    using eid_ptr = electronic_id::ElectronicID::ptr;
+    using eid_ptr_vector = std::vector<electronic_id::ElectronicID::ptr>;
 
-    CardEventMonitorThread(QObject* parent, const std::string& commandType) :
-        ControllerChildThread(parent), cmdType(commandType)
+    CardEventMonitorThread(QObject* parent, std::string commandType) :
+        ControllerChildThread(parent), cmdType(std::move(commandType))
     {
     }
 
@@ -50,7 +50,7 @@ class CardEventMonitorThread : public ControllerChildThread
 
             waitForControllerNotify.wait(&controllerChildThreadMutex, ONE_SECOND);
 
-            card_ptr_vector updatedCards {};
+            eid_ptr_vector updatedCards {};
 
             try {
                 updatedCards = electronic_id::availableSupportedCards();
@@ -83,7 +83,7 @@ class CardEventMonitorThread : public ControllerChildThread
         // Unused as run() has been overriden.
     }
 
-    card_ptr_vector getSupportedCardsIgnoringExceptions()
+    eid_ptr_vector getSupportedCardsIgnoringExceptions()
     {
         while (!isInterruptionRequested()) {
             try {
@@ -98,24 +98,24 @@ class CardEventMonitorThread : public ControllerChildThread
         return {};
     }
 
-    void sortByReaderNameAndAtr(card_ptr_vector& a)
+    static void sortByReaderNameAndAtr(eid_ptr_vector& a)
     {
-        std::sort(a.begin(), a.end(), [](const card_ptr& c1, const card_ptr& c2) {
-            if (c1->reader().name != c2->reader().name) {
-                return c1->reader().name < c2->reader().name;
+        std::sort(a.begin(), a.end(), [](const eid_ptr& c1, const eid_ptr& c2) {
+            if (c1->smartcard().readerName() != c2->smartcard().readerName()) {
+                return c1->smartcard().readerName() < c2->smartcard().readerName();
             }
-            return c1->reader().cardAtr < c2->reader().cardAtr;
+            return c1->smartcard().atr() < c2->smartcard().atr();
         });
     }
 
-    bool areEqualByReaderNameAndAtr(const card_ptr_vector& a, const card_ptr_vector& b)
+    static bool areEqualByReaderNameAndAtr(const eid_ptr_vector& a, const eid_ptr_vector& b)
     {
         // std::equal requires that second range is not shorter than first, so compare size first.
         return a.size() == b.size()
             && std::equal(a.cbegin(), a.cend(), b.cbegin(),
-                          [](const card_ptr& c1, const card_ptr& c2) {
-                              return c1->reader().name == c2->reader().name
-                                  && c1->reader().cardAtr == c2->reader().cardAtr;
+                          [](const eid_ptr& c1, const eid_ptr& c2) {
+                              return c1->smartcard().readerName() == c2->smartcard().readerName()
+                                  && c1->smartcard().atr() == c2->smartcard().atr();
                           });
     }
 
diff --git a/src/controller/threads/commandhandlerconfirmthread.hpp b/src/controller/threads/commandhandlerconfirmthread.hpp
index f1621546..fed1edde 100644
--- a/src/controller/threads/commandhandlerconfirmthread.hpp
+++ b/src/controller/threads/commandhandlerconfirmthread.hpp
@@ -30,9 +30,9 @@ class CommandHandlerConfirmThread : public ControllerChildThread
 
 public:
     CommandHandlerConfirmThread(QObject* parent, CommandHandler& handler, WebEidUI* w,
-                                const CardCertificateAndPinInfo& cardCertAndPin) :
+                                const EidCertificateAndPinInfo& certAndPin) :
         ControllerChildThread(parent), commandHandler(handler),
-        cmdType(commandHandler.commandType()), window(w), cardCertAndPinInfo(cardCertAndPin)
+        cmdType(commandHandler.commandType()), window(w), certAndPinInfo(certAndPin)
     {
     }
 
@@ -42,8 +42,8 @@ class CommandHandlerConfirmThread : public ControllerChildThread
 private:
     void doRun() override
     {
-        const auto result = commandHandler.onConfirm(window, cardCertAndPinInfo);
-        cardCertAndPinInfo.cardInfo->eid().release();
+        const auto result = commandHandler.onConfirm(window, certAndPinInfo);
+        certAndPinInfo.eid->release();
         emit completed(result);
     }
 
@@ -52,5 +52,5 @@ class CommandHandlerConfirmThread : public ControllerChildThread
     CommandHandler& commandHandler;
     const std::string cmdType;
     WebEidUI* window;
-    CardCertificateAndPinInfo cardCertAndPinInfo;
+    EidCertificateAndPinInfo certAndPinInfo;
 };
diff --git a/src/controller/threads/commandhandlerrunthread.hpp b/src/controller/threads/commandhandlerrunthread.hpp
index 898a5a0a..2ea25b35 100644
--- a/src/controller/threads/commandhandlerrunthread.hpp
+++ b/src/controller/threads/commandhandlerrunthread.hpp
@@ -30,20 +30,20 @@ class CommandHandlerRunThread : public ControllerChildThread
 
 public:
     CommandHandlerRunThread(QObject* parent, CommandHandler& handler,
-                            const std::vector<electronic_id::CardInfo::ptr>& cs) :
+                            const std::vector<electronic_id::ElectronicID::ptr>& eids) :
         ControllerChildThread(parent), commandHandler(handler),
-        cmdType(commandHandler.commandType()), cards(cs)
+        cmdType(commandHandler.commandType()), eids(eids)
     {
         // Connect retry signal to retry signal to pass it up from the command handler.
         connect(&commandHandler, &CommandHandler::retry, this, &ControllerChildThread::retry);
     }
 
 private:
-    void doRun() override { commandHandler.run(cards); }
+    void doRun() override { commandHandler.run(eids); }
 
     const std::string& commandType() const override { return cmdType; }
 
     CommandHandler& commandHandler;
     const std::string cmdType;
-    std::vector<electronic_id::CardInfo::ptr> cards;
+    std::vector<electronic_id::ElectronicID::ptr> eids;
 };
diff --git a/src/controller/threads/waitforcardthread.hpp b/src/controller/threads/waitforcardthread.hpp
index 81458903..8d64399a 100644
--- a/src/controller/threads/waitforcardthread.hpp
+++ b/src/controller/threads/waitforcardthread.hpp
@@ -32,7 +32,7 @@ class WaitForCardThread : public ControllerChildThread
     explicit WaitForCardThread(QObject* parent) : ControllerChildThread(parent) {}
 
 signals:
-    void cardsAvailable(const std::vector<electronic_id::CardInfo::ptr>& cardInfo);
+    void cardsAvailable(const std::vector<electronic_id::ElectronicID::ptr>& eids);
     void statusUpdate(const RetriableError status);
 
 private:
diff --git a/src/controller/ui.hpp b/src/controller/ui.hpp
index e90bb46f..1c4b380b 100644
--- a/src/controller/ui.hpp
+++ b/src/controller/ui.hpp
@@ -52,18 +52,19 @@ class WebEidUI : public QDialog
     virtual QString getPin() = 0;
 
 signals:
-    void waitingForPinPad(const CardCertificateAndPinInfo& cardCertAndPinInfo);
-    void accepted(const CardCertificateAndPinInfo& cardCertAndPinInfo);
+    void waitingForPinPad(const EidCertificateAndPinInfo& certAndPinInfo);
+    void accepted(const EidCertificateAndPinInfo& certAndPinInfo);
     void retry();
     void failure(const QString& error);
 
 public: // slots
     virtual void quit() = 0;
     virtual void onSmartCardStatusUpdate(const RetriableError status) = 0;
-    virtual void onMultipleCertificatesReady(
-        const QUrl& origin, const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos) = 0;
+    virtual void
+    onMultipleCertificatesReady(const QUrl& origin,
+                                const std::vector<EidCertificateAndPinInfo>& certAndPinInfos) = 0;
     virtual void onSingleCertificateReady(const QUrl& origin,
-                                          const CardCertificateAndPinInfo& cardCertAndPinInfo) = 0;
+                                          const EidCertificateAndPinInfo& certAndPinInfo) = 0;
 
     virtual void onRetry(const RetriableError error) = 0;
 
diff --git a/src/ui/certificatewidget.cpp b/src/ui/certificatewidget.cpp
index af787a67..5414171b 100644
--- a/src/ui/certificatewidget.cpp
+++ b/src/ui/certificatewidget.cpp
@@ -71,7 +71,7 @@ CertificateWidgetInfo::CertificateWidgetInfo(QWidget* self) :
     layout->addItem(warnLayout);
 }
 
-CardCertificateAndPinInfo CertificateWidgetInfo::certificateInfo() const
+EidCertificateAndPinInfo CertificateWidgetInfo::certificateInfo() const
 {
     return certAndPinInfo;
 }
@@ -94,7 +94,7 @@ void CertificateWidgetInfo::drawWarnIcon()
     warnIcon->style()->drawItemPixmap(&p, cr, Qt::AlignCenter, warnIcon->pixmap());
 }
 
-void CertificateWidgetInfo::setCertificateInfo(const CardCertificateAndPinInfo& cardCertPinInfo)
+void CertificateWidgetInfo::setCertificateInfo(const EidCertificateAndPinInfo& cardCertPinInfo)
 {
     warn->setText(CertificateWidget::tr("Pin locked"));
     certAndPinInfo = cardCertPinInfo;
@@ -147,7 +147,7 @@ void CertificateWidget::paintEvent(QPaintEvent* /*event*/)
     style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
 }
 
-CertificateButton::CertificateButton(const CardCertificateAndPinInfo& cardCertPinInfo,
+CertificateButton::CertificateButton(const EidCertificateAndPinInfo& cardCertPinInfo,
                                      QWidget* parent) :
     QAbstractButton(parent), CertificateWidgetInfo(this)
 {
@@ -167,7 +167,7 @@ bool CertificateButton::eventFilter(QObject* object, QEvent* event)
     return QAbstractButton::eventFilter(object, event);
 }
 
-void CertificateButton::setCertificateInfo(const CardCertificateAndPinInfo& cardCertPinInfo)
+void CertificateButton::setCertificateInfo(const EidCertificateAndPinInfo& cardCertPinInfo)
 {
     CertificateWidgetInfo::setCertificateInfo(cardCertPinInfo);
     auto [subject, issuer, effectiveDate, expiryDate] = certData();
diff --git a/src/ui/certificatewidget.hpp b/src/ui/certificatewidget.hpp
index 51264541..906f81d6 100644
--- a/src/ui/certificatewidget.hpp
+++ b/src/ui/certificatewidget.hpp
@@ -33,8 +33,8 @@ class CertificateWidgetInfo
 {
 public:
     virtual ~CertificateWidgetInfo() = default;
-    CardCertificateAndPinInfo certificateInfo() const;
-    virtual void setCertificateInfo(const CardCertificateAndPinInfo& cardCertPinInfo);
+    EidCertificateAndPinInfo certificateInfo() const;
+    virtual void setCertificateInfo(const EidCertificateAndPinInfo& certAndPinInfo);
     void languageChange();
 
 protected:
@@ -48,7 +48,7 @@ class CertificateWidgetInfo
     QLabel* info;
     QLabel* warnIcon;
     QLabel* warn;
-    CardCertificateAndPinInfo certAndPinInfo;
+    EidCertificateAndPinInfo certAndPinInfo;
 };
 
 class CertificateWidget final : public QWidget, public CertificateWidgetInfo
@@ -68,10 +68,10 @@ class CertificateButton final : public QAbstractButton, public CertificateWidget
     Q_OBJECT
 
 public:
-    CertificateButton(const CardCertificateAndPinInfo& cardCertPinInfo, QWidget* parent);
+    CertificateButton(const EidCertificateAndPinInfo& certAndPinInfo, QWidget* parent);
 
 private:
     bool eventFilter(QObject* object, QEvent* event) final;
-    void setCertificateInfo(const CardCertificateAndPinInfo& cardCertPinInfo) final;
+    void setCertificateInfo(const EidCertificateAndPinInfo& certAndPinInfo) final;
     void paintEvent(QPaintEvent* event) final;
 };
diff --git a/src/ui/webeiddialog.cpp b/src/ui/webeiddialog.cpp
index dd30e2d0..63761bae 100644
--- a/src/ui/webeiddialog.cpp
+++ b/src/ui/webeiddialog.cpp
@@ -318,10 +318,10 @@ void WebEidDialog::onSmartCardStatusUpdate(const RetriableError status)
  * authenticate continues to onSingleCertificateReady().
  */
 void WebEidDialog::onMultipleCertificatesReady(
-    const QUrl& origin, const std::vector<CardCertificateAndPinInfo>& certificateAndPinInfos)
+    const QUrl& origin, const std::vector<EidCertificateAndPinInfo>& certAndPinInfos)
 {
     ui->selectCertificateOriginLabel->setText(fromPunycode(origin));
-    setupCertificateAndPinInfo(certificateAndPinInfos);
+    setupCertificateAndPinInfo(certAndPinInfos);
 
     switch (currentCommand) {
     case CommandType::GET_SIGNING_CERTIFICATE:
@@ -338,12 +338,12 @@ void WebEidDialog::onMultipleCertificatesReady(
         break;
     case CommandType::AUTHENTICATE:
         ui->selectAnotherCertificate->disconnect();
-        ui->selectAnotherCertificate->setVisible(certificateAndPinInfos.size() > 1);
+        ui->selectAnotherCertificate->setVisible(certAndPinInfos.size() > 1);
         connect(ui->selectAnotherCertificate, &QPushButton::clicked, this,
-                [this, origin, certificateAndPinInfos] {
+                [this, origin, certAndPinInfos] {
                     // We set pinInput to empty text instead of clear() to also reset undo buffer
                     ui->pinInput->setText({});
-                    onMultipleCertificatesReady(origin, certificateAndPinInfos);
+                    onMultipleCertificatesReady(origin, certAndPinInfos);
                 });
         setupOK([this, origin] {
             ui->okButton->setDisabled(true);
@@ -372,24 +372,24 @@ void WebEidDialog::onMultipleCertificatesReady(
  * All of the commands exit the flow on OK with the selected certificate from here.
  */
 void WebEidDialog::onSingleCertificateReady(const QUrl& origin,
-                                            const CardCertificateAndPinInfo& certAndPin)
+                                            const EidCertificateAndPinInfo& certAndPinInfo)
 {
     ui->selectCertificateOriginLabel->setText(fromPunycode(origin));
     ui->pinInputOriginLabel->setText(ui->selectCertificateOriginLabel->text());
-    const bool useExternalPinDialog = certAndPin.cardInfo->eid().providesExternalPinDialog();
+    const bool useExternalPinDialog = certAndPinInfo.eid->providesExternalPinDialog();
 
     switch (currentCommand) {
     case CommandType::GET_SIGNING_CERTIFICATE:
-        setupCertificateAndPinInfo({certAndPin});
-        setupOK([this, certAndPin] {
+        setupCertificateAndPinInfo({certAndPinInfo});
+        setupOK([this, certAndPinInfo] {
             ui->okButton->setDisabled(true);
-            emit accepted(certAndPin);
+            emit accepted(certAndPinInfo);
         });
         ui->selectionGroup->buttons().at(0)->click();
         ui->pageStack->setCurrentIndex(int(Page::SELECT_CERTIFICATE));
         return;
     case CommandType::AUTHENTICATE:
-        ui->pinInputCertificateInfo->setCertificateInfo(certAndPin);
+        ui->pinInputCertificateInfo->setCertificateInfo(certAndPinInfo);
         setTrText(ui->pinInputPageTitleLabel, QT_TR_NOOP("Authenticate"));
         setTrText(ui->pinInputDescriptionLabel,
                   QT_TR_NOOP("By authenticating, I agree to the transfer of my name and personal "
@@ -402,7 +402,7 @@ void WebEidDialog::onSingleCertificateReady(const QUrl& origin,
                 : QT_TR_NOOP("Enter PIN1 for authentication"));
         break;
     case CommandType::SIGN:
-        ui->pinInputCertificateInfo->setCertificateInfo(certAndPin);
+        ui->pinInputCertificateInfo->setCertificateInfo(certAndPinInfo);
         setTrText(ui->pinInputPageTitleLabel, QT_TR_NOOP("Signing"));
         setTrText(
             ui->pinInputDescriptionLabel,
@@ -419,17 +419,17 @@ void WebEidDialog::onSingleCertificateReady(const QUrl& origin,
         return;
     }
 
-    if (certAndPin.pinInfo.pinIsBlocked) {
+    if (certAndPinInfo.pinInfo.pinIsBlocked) {
         displayPinBlockedError();
-    } else if (certAndPin.certInfo.isExpired || certAndPin.certInfo.notEffective) {
+    } else if (certAndPinInfo.certInfo.isExpired || certAndPinInfo.certInfo.notEffective) {
         ui->pinTitleLabel->hide();
     } else if (useExternalPinDialog) {
-        connectOkToCachePinAndEmitSelectedCertificate(certAndPin);
+        connectOkToCachePinAndEmitSelectedCertificate(certAndPinInfo);
         ui->okButton->setEnabled(true);
-    } else if (certAndPin.pinInfo.readerHasPinPad) {
-        setupPinPadProgressBarAndEmitWait(certAndPin);
+    } else if (certAndPinInfo.pinInfo.readerHasPinPad) {
+        setupPinPadProgressBarAndEmitWait(certAndPinInfo);
     } else {
-        setupPinInput(certAndPin);
+        setupPinInput(certAndPinInfo);
     }
 
     ui->pageStack->setCurrentIndex(int(Page::PIN_INPUT));
@@ -552,7 +552,7 @@ void WebEidDialog::setTrText(QWidget* label, Text text) const
 }
 
 void WebEidDialog::connectOkToCachePinAndEmitSelectedCertificate(
-    const CardCertificateAndPinInfo& certAndPin)
+    const EidCertificateAndPinInfo& certAndPin)
 {
     setupOK([this, certAndPin] {
         ui->pinInput->hide();
@@ -578,10 +578,10 @@ void WebEidDialog::connectOkToCachePinAndEmitSelectedCertificate(
 }
 
 void WebEidDialog::setupCertificateAndPinInfo(
-    const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos)
+    const std::vector<EidCertificateAndPinInfo>& cardCertAndPinInfos)
 {
     qDeleteAll(ui->selectCertificatePage->findChildren<CertificateButton*>());
-    for (const CardCertificateAndPinInfo& certAndPin : cardCertAndPinInfos) {
+    for (const EidCertificateAndPinInfo& certAndPin : cardCertAndPinInfos) {
         QWidget* previous = ui->selectCertificateOriginLabel;
         if (!ui->selectionGroup->buttons().isEmpty()) {
             previous = ui->selectionGroup->buttons().last();
@@ -614,7 +614,7 @@ void WebEidDialog::setupPinPrompt(PinInfo pinInfo)
     }
 }
 
-void WebEidDialog::setupPinPadProgressBarAndEmitWait(const CardCertificateAndPinInfo& certAndPin)
+void WebEidDialog::setupPinPadProgressBarAndEmitWait(const EidCertificateAndPinInfo& certAndPin)
 {
     setupPinPrompt(certAndPin.pinInfo);
     hide();
@@ -641,9 +641,9 @@ void WebEidDialog::setupPinPadProgressBarAndEmitWait(const CardCertificateAndPin
     emit waitingForPinPad(certAndPin);
 }
 
-void WebEidDialog::setupPinInput(const CardCertificateAndPinInfo& certAndPin)
+void WebEidDialog::setupPinInput(const EidCertificateAndPinInfo& certAndPinInfo)
 {
-    setupPinPrompt(certAndPin.pinInfo);
+    setupPinPrompt(certAndPinInfo.pinInfo);
     // The allowed character ranges are from the SafeNet eToken guide:
     // 1. English uppercase letters (ASCII 0x41...0x5A).
     // 2. English lowercase letters (ASCII 0x61...0x7A).
@@ -652,16 +652,16 @@ void WebEidDialog::setupPinInput(const CardCertificateAndPinInfo& certAndPin)
     //    (ASCII 0x20...0x2F, space../ + 0x3A...0x40, :..@ + 0x5B...0x60, [..` + 0x7B...0x7F, {..~).
     // 5. We additionally allow uppercase and lowercase Unicode letters.
     const auto& regexpWithOrWithoutLetters =
-        certAndPin.cardInfo->eid().allowsUsingLettersAndSpecialCharactersInPin()
+        certAndPinInfo.eid->allowsUsingLettersAndSpecialCharactersInPin()
         ? QStringLiteral("[0-9 -/:-@[-`{-~\\p{L}]{%1,%2}")
         : QStringLiteral("[0-9]{%1,%2}");
     const QRegularExpression numericMinMaxRegexp(
-        regexpWithOrWithoutLetters.arg(certAndPin.pinInfo.pinMinMaxLength.first)
-            .arg(certAndPin.pinInfo.pinMinMaxLength.second));
+        regexpWithOrWithoutLetters.arg(certAndPinInfo.pinInfo.pinMinMaxLength.first)
+            .arg(certAndPinInfo.pinInfo.pinMinMaxLength.second));
     ui->pinInputValidator->setRegularExpression(numericMinMaxRegexp);
-    ui->pinInput->setMaxLength(int(certAndPin.pinInfo.pinMinMaxLength.second));
+    ui->pinInput->setMaxLength(int(certAndPinInfo.pinInfo.pinMinMaxLength.second));
     ui->pinInput->setFocus();
-    connectOkToCachePinAndEmitSelectedCertificate(certAndPin);
+    connectOkToCachePinAndEmitSelectedCertificate(certAndPinInfo);
 }
 
 template <typename Func>
diff --git a/src/ui/webeiddialog.hpp b/src/ui/webeiddialog.hpp
index 308632a7..07021f63 100644
--- a/src/ui/webeiddialog.hpp
+++ b/src/ui/webeiddialog.hpp
@@ -56,11 +56,11 @@ class WebEidDialog final : public WebEidUI
 
     // slots
     void onSmartCardStatusUpdate(const RetriableError status) final;
-    void onMultipleCertificatesReady(
-        const QUrl& origin,
-        const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos) final;
+    void
+    onMultipleCertificatesReady(const QUrl& origin,
+                                const std::vector<EidCertificateAndPinInfo>& certAndPinInfos) final;
     void onSingleCertificateReady(const QUrl& origin,
-                                  const CardCertificateAndPinInfo& cardCertAndPinInfo) final;
+                                  const EidCertificateAndPinInfo& certAndPinInfo) final;
 
     void onRetry(const RetriableError error) final;
 
@@ -90,17 +90,18 @@ class WebEidDialog final : public WebEidUI
         }
     }
 
-    void connectOkToCachePinAndEmitSelectedCertificate(const CardCertificateAndPinInfo& certAndPin);
+    void
+    connectOkToCachePinAndEmitSelectedCertificate(const EidCertificateAndPinInfo& certAndPinInfo);
 
     template <typename Text>
     void onRetryImpl(Text text);
     template <typename Text>
     void setTrText(QWidget* label, Text text) const;
     void
-    setupCertificateAndPinInfo(const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos);
+    setupCertificateAndPinInfo(const std::vector<EidCertificateAndPinInfo>& cardCertAndPinInfos);
     void setupPinPrompt(PinInfo pinInfo);
-    void setupPinPadProgressBarAndEmitWait(const CardCertificateAndPinInfo& certAndPin);
-    void setupPinInput(const CardCertificateAndPinInfo& certAndPin);
+    void setupPinPadProgressBarAndEmitWait(const EidCertificateAndPinInfo& certAndPinInfo);
+    void setupPinInput(const EidCertificateAndPinInfo& certAndPinInfo);
     template <typename Func>
     void setupOK(Func func, const char* text = {}, bool enabled = false);
     void displayPinBlockedError();
diff --git a/tests/mock-ui/mock-ui.hpp b/tests/mock-ui/mock-ui.hpp
index edc0796d..300cb057 100644
--- a/tests/mock-ui/mock-ui.hpp
+++ b/tests/mock-ui/mock-ui.hpp
@@ -41,12 +41,12 @@ class MockUI : public WebEidUI
 
 public: // slots
     void onMultipleCertificatesReady(
-        const QUrl&, const std::vector<CardCertificateAndPinInfo>& cardCertAndPin) override
+        const QUrl&, const std::vector<EidCertificateAndPinInfo>& cardCertAndPin) override
     {
         emit accepted(cardCertAndPin[0]);
     }
     void onSingleCertificateReady(const QUrl&,
-                                  const CardCertificateAndPinInfo& cardCertAndPin) override
+                                  const EidCertificateAndPinInfo& cardCertAndPin) override
     {
         emit accepted(cardCertAndPin);
     }
diff --git a/tests/tests/changecertificatevaliduntil.hpp b/tests/tests/changecertificatevaliduntil.hpp
index 97e01ab6..97c2cee6 100644
--- a/tests/tests/changecertificatevaliduntil.hpp
+++ b/tests/tests/changecertificatevaliduntil.hpp
@@ -87,12 +87,12 @@ inline PcscMock::ApduScript replaceCertValidUntilYear(const PcscMock::ApduScript
 
 inline PcscMock::ApduScript replaceCertValidUntilTo2010(const PcscMock::ApduScript& script)
 {
-    return replaceCertValidUntilYear(script, 3, "10");
+    return replaceCertValidUntilYear(script, 2, "10");
 }
 
 inline PcscMock::ApduScript replaceCertValidUntilToNextYear(const PcscMock::ApduScript& script)
 {
     // UTCDateTime needs 2-digit year since 2000, add +1 for next year
-    return replaceCertValidUntilYear(script, 3,
+    return replaceCertValidUntilYear(script, 2,
                                      std::to_string(QDate::currentDate().year() - 2000 + 1));
 }
diff --git a/tests/tests/main.cpp b/tests/tests/main.cpp
index 89f19e2f..270164c5 100644
--- a/tests/tests/main.cpp
+++ b/tests/tests/main.cpp
@@ -50,7 +50,7 @@ namespace
 CertificateInfo getCertAndPinInfoFromSignalSpy(const QSignalSpy& certificateReadySpy)
 {
     const auto certInfosArgument =
-        qvariant_cast<CardCertificateAndPinInfo>(certificateReadySpy.first().at(1));
+        qvariant_cast<EidCertificateAndPinInfo>(certificateReadySpy.first().at(1));
     return certInfosArgument.certInfo;
 }