diff --git a/include/faker-cxx/Helper.h b/include/faker-cxx/Helper.h
index 353102e0a..fafd760ea 100644
--- a/include/faker-cxx/Helper.h
+++ b/include/faker-cxx/Helper.h
@@ -9,6 +9,7 @@
 
 namespace faker
 {
+// TODO: Add error handling if data empty
 class Helper
 {
 public:
@@ -29,6 +30,11 @@ class Helper
     template <class T>
     static T arrayElement(std::span<const T> data)
     {
+        if (data.empty())
+        {
+            throw std::invalid_argument{"Data is empty."};
+        }
+
         const auto index = Number::integer<size_t>(data.size() - 1);
 
         return data[index];
@@ -37,11 +43,57 @@ class Helper
     template <class T>
     static T arrayElement(const std::vector<T>& data)
     {
+        if (data.empty())
+        {
+            throw std::invalid_argument{"Data is empty."};
+        }
+
         const auto index = Number::integer<size_t>(data.size() - 1);
 
         return data[index];
     }
 
+    template <class T>
+    struct WeightedElement
+    {
+        unsigned weight;
+        T value;
+    };
+
+    template <class T>
+    static T weightedArrayElement(const std::vector<WeightedElement<T>>& data)
+    {
+        if (data.empty())
+        {
+            throw std::invalid_argument{"Data is empty."};
+        }
+
+        const auto sumOfWeights =
+            std::accumulate(data.begin(), data.end(), 0u,
+                            [](size_t sum, const WeightedElement<T>& element) { return sum + element.weight; });
+
+        if (sumOfWeights == 0)
+        {
+            throw std::invalid_argument{"Sum of weights is zero."};
+        }
+
+        const std::integral auto targetWeightValue = Number::integer<unsigned>(sumOfWeights);
+
+        unsigned currentSum = 0;
+
+        for (const auto& element : data)
+        {
+            currentSum += element.weight;
+
+            if (targetWeightValue <= currentSum)
+            {
+                return element.value;
+            }
+        }
+
+        return data.at(data.size() - 1).value;
+    }
+
     /**
      * @brief Returns shuffled STL container.
      *
diff --git a/include/faker-cxx/Person.h b/include/faker-cxx/Person.h
index ea8e687ea..243a9e347 100644
--- a/include/faker-cxx/Person.h
+++ b/include/faker-cxx/Person.h
@@ -31,6 +31,7 @@ class Person
      * @brief Returns a random last name.
      *
      * @param language The local name language. Defaults to `Language::English`.
+     * @param sex The optional sex to use.
      *
      * @returns Last name starting with a capital letter.
      *
@@ -40,10 +41,24 @@ class Person
      */
     static std::string lastName(Language language = Language::English, std::optional<Sex> = std::nullopt);
 
+    /**
+     * @brief Returns a random middle name.
+     *
+     * @param sex The optional sex to use.
+     *
+     * @returns Middle name starting with a capital letter.
+     *
+     * @code
+     * Person::middleName() // "Васильевич"
+     * @endcode
+     */
+    static std::string middleName(std::optional<Sex> = std::nullopt);
+
     /**
      * @brief Returns a random full name.
      *
      * @param language The local name language. Defaults to `Language::English`.
+     * @param sex The optional sex to use.
      *
      * @returns Full name starting with first name.
      *
@@ -70,6 +85,17 @@ class Person
      */
     static std::string prefix(std::optional<Sex> = std::nullopt);
 
+    /**
+     * @brief Returns a random name suffix.
+     *
+     * @returns Name suffix.
+     *
+     * @code
+     * Person::suffix() // "Jr."
+     * @endcode
+     */
+    static std::string suffix();
+
     /**
      * @brief Returns a sex.
      *
diff --git a/include/faker-cxx/types/Sex.h b/include/faker-cxx/types/Sex.h
index 465e6e09b..4f4ad4363 100644
--- a/include/faker-cxx/types/Sex.h
+++ b/include/faker-cxx/types/Sex.h
@@ -7,4 +7,16 @@ enum class Sex
     Male,
     Female,
 };
+
+inline std::string toString(Sex sex)
+{
+    std::map<Sex, std::string> sexToStringMapping{{Sex::Male, "Male"}, {Sex::Female, "Female"}};
+
+    return sexToStringMapping.at(sex);
+}
+
+inline std::ostream& operator<<(std::ostream& os, Sex sex)
+{
+    return os << toString(sex);
+}
 }
diff --git a/src/modules/company/Company.cpp b/src/modules/company/Company.cpp
index c21d707c8..5d5cb83a1 100644
--- a/src/modules/company/Company.cpp
+++ b/src/modules/company/Company.cpp
@@ -15,6 +15,8 @@
 
 namespace faker
 {
+// TODO: add internalization
+
 std::string Company::name()
 {
     std::string companyName;
diff --git a/src/modules/company/CompanyTest.cpp b/src/modules/company/CompanyTest.cpp
index f51e3b571..5980c5950 100644
--- a/src/modules/company/CompanyTest.cpp
+++ b/src/modules/company/CompanyTest.cpp
@@ -5,8 +5,7 @@
 #include "gtest/gtest.h"
 
 #include "../../common/StringHelper.h"
-#include "../person/data/english/EnglishFirstNamesFemales.h"
-#include "../person/data/english/EnglishFirstNamesMales.h"
+#include "../person/data/english/EnglishFirstNames.h"
 #include "../person/data/english/EnglishLastNames.h"
 #include "../person/data/JobTitles.h"
 #include "data/BuzzAdjectives.h"
@@ -33,10 +32,10 @@ TEST_F(CompanyTest, shouldGenerateCompanyName)
 
     const auto companyNameElements = StringHelper::split(companyName, " ");
 
-    std::vector<std::string> expectedFirstNames{englishFirstNamesMales};
+    std::vector<std::string> expectedFirstNames{englishMalesFirstNames};
 
-    expectedFirstNames.insert(expectedFirstNames.end(), englishFirstNamesFemales.begin(),
-                              englishFirstNamesFemales.end());
+    expectedFirstNames.insert(expectedFirstNames.end(), englishFemalesFirstNames.begin(),
+                              englishFemalesFirstNames.end());
 
     if (companyNameElements.size() == 2)
     {
diff --git a/src/modules/internet/Internet.cpp b/src/modules/internet/Internet.cpp
index 633ba64db..d74179003 100644
--- a/src/modules/internet/Internet.cpp
+++ b/src/modules/internet/Internet.cpp
@@ -52,6 +52,7 @@ const std::map<EmojiType, std::vector<std::string>> emojiTypeToEmojisMapping{
 };
 }
 
+// TODO: add internalization
 std::string Internet::username(std::optional<std::string> firstNameInit, std::optional<std::string> lastNameInit)
 {
     const auto firstName = firstNameInit ? *firstNameInit : Person::firstName();
diff --git a/src/modules/internet/InternetTest.cpp b/src/modules/internet/InternetTest.cpp
index fa768be84..d800aefba 100644
--- a/src/modules/internet/InternetTest.cpp
+++ b/src/modules/internet/InternetTest.cpp
@@ -7,8 +7,7 @@
 #include "gtest/gtest.h"
 
 #include "../../common/StringHelper.h"
-#include "../person/data/english/EnglishFirstNamesFemales.h"
-#include "../person/data/english/EnglishFirstNamesMales.h"
+#include "../person/data/english/EnglishFirstNames.h"
 #include "../person/data/english/EnglishLastNames.h"
 #include "../string/data/Characters.h"
 #include "../word/data/Adjectives.h"
@@ -102,9 +101,9 @@ class InternetTest : public Test
 
 TEST_F(InternetTest, shouldGenerateUsername)
 {
-    std::vector<std::string> firstNames{englishFirstNamesMales};
+    std::vector<std::string> firstNames{englishMalesFirstNames};
 
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     const auto username = Internet::username();
 
@@ -127,9 +126,9 @@ TEST_F(InternetTest, shouldGenerateUsernameWithFirstNameProvided)
 
 TEST_F(InternetTest, shouldGenerateUsernameWithLastNameProvided)
 {
-    std::vector<std::string> firstNames{englishFirstNamesMales};
+    std::vector<std::string> firstNames{englishMalesFirstNames};
 
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     const auto lastName = "Cieslar";
 
@@ -154,9 +153,9 @@ TEST_F(InternetTest, shouldGenerateUsernameWithFullNameProvided)
 
 TEST_F(InternetTest, shouldGenerateEmail)
 {
-    std::vector<std::string> firstNames{englishFirstNamesMales};
+    std::vector<std::string> firstNames{englishMalesFirstNames};
 
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     const auto email = Internet::email();
 
@@ -197,9 +196,9 @@ TEST_F(InternetTest, shouldGenerateEmailWithFirstName)
 
 TEST_F(InternetTest, shouldGenerateEmailWithLastName)
 {
-    std::vector<std::string> firstNames{englishFirstNamesMales};
+    std::vector<std::string> firstNames{englishMalesFirstNames};
 
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     const auto lastName = "Howard";
 
@@ -221,9 +220,9 @@ TEST_F(InternetTest, shouldGenerateEmailWithLastName)
 
 TEST_F(InternetTest, shouldGenerateEmailWithFullName)
 {
-    std::vector<std::string> firstNames{englishFirstNamesMales};
+    std::vector<std::string> firstNames{englishMalesFirstNames};
 
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     const auto firstName = "Cindy";
 
@@ -246,9 +245,9 @@ TEST_F(InternetTest, shouldGenerateEmailWithFullName)
 
 TEST_F(InternetTest, shouldGenerateEmailWithSpecifiedEmailHost)
 {
-    std::vector<std::string> firstNames{englishFirstNamesMales};
+    std::vector<std::string> firstNames{englishMalesFirstNames};
 
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     const auto emailHost = "example.com";
 
@@ -270,9 +269,9 @@ TEST_F(InternetTest, shouldGenerateEmailWithSpecifiedEmailHost)
 
 TEST_F(InternetTest, shouldGenerateExampleEmail)
 {
-    std::vector<std::string> firstNames{englishFirstNamesMales};
+    std::vector<std::string> firstNames{englishMalesFirstNames};
 
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     const auto email = Internet::exampleEmail();
 
@@ -313,9 +312,9 @@ TEST_F(InternetTest, shouldGenerateExampleEmailWithFirstName)
 
 TEST_F(InternetTest, shouldGenerateExampleEmailWithLastName)
 {
-    std::vector<std::string> firstNames{englishFirstNamesMales};
+    std::vector<std::string> firstNames{englishMalesFirstNames};
 
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     const auto lastName = "Wilkinson";
 
@@ -337,9 +336,9 @@ TEST_F(InternetTest, shouldGenerateExampleEmailWithLastName)
 
 TEST_F(InternetTest, shouldGenerateExampleEmailWithFullName)
 {
-    std::vector<std::string> firstNames{englishFirstNamesMales};
+    std::vector<std::string> firstNames{englishMalesFirstNames};
 
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     const auto firstName = "Walter";
 
diff --git a/src/modules/location/Location.cpp b/src/modules/location/Location.cpp
index b1565c19b..81568d1c9 100644
--- a/src/modules/location/Location.cpp
+++ b/src/modules/location/Location.cpp
@@ -30,6 +30,7 @@ namespace faker
 {
 namespace
 {
+// TODO: Refactor
 const std::map<Country, std::vector<std::string>> countryToCitiesMapping{{Country::Usa, usaCities},
                                                                          {Country::Russia, russiaCities},
                                                                          {Country::Poland, polandCities},
@@ -124,6 +125,8 @@ std::string Location::streetAddress(Country country)
 
 std::string Location::street(Country country)
 {
+    // TODO: add internalization
+
     const auto& streetFormats = countryToStreetFormatsMapping.at(country);
 
     const auto streetFormat = Helper::arrayElement<std::string>(streetFormats);
diff --git a/src/modules/location/LocationTest.cpp b/src/modules/location/LocationTest.cpp
index 51dfd77cb..79344111b 100644
--- a/src/modules/location/LocationTest.cpp
+++ b/src/modules/location/LocationTest.cpp
@@ -1,13 +1,11 @@
 #include "faker-cxx/Location.h"
 
 #include <algorithm>
-#include <charconv>
 
 #include "gtest/gtest.h"
 
 #include "../../common/StringHelper.h"
-#include "../person/data/english/EnglishFirstNamesFemales.h"
-#include "../person/data/english/EnglishFirstNamesMales.h"
+#include "../person/data/english/EnglishFirstNames.h"
 #include "../person/data/english/EnglishLastNames.h"
 #include "../string/data/Characters.h"
 #include "data/Countries.h"
@@ -19,7 +17,6 @@
 #include "data/poland/PolandStreetNames.h"
 #include "data/poland/PolandStreetPrefixes.h"
 #include "data/russia/RussiaCities.h"
-#include "data/russia/RussiaStreetPrefixes.h"
 #include "data/States.h"
 #include "data/TimeZones.h"
 #include "data/usa/UsaCities.h"
@@ -114,8 +111,8 @@ TEST_F(LocationTest, shouldGenerateUsaStreet)
     const auto& generatedFirstOrLastName = generatedStreetElements[0];
     const auto& generatedStreetSuffix = generatedStreetElements[1];
 
-    std::vector<std::string> firstNames{englishFirstNamesMales};
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    std::vector<std::string> firstNames{englishMalesFirstNames};
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     ASSERT_EQ(generatedStreetElements.size(), 2);
     ASSERT_TRUE(std::ranges::any_of(firstNames, [generatedFirstOrLastName](const std::string& firstName)
@@ -136,8 +133,8 @@ TEST_F(LocationTest, shouldGenerateUsaStreetAddress)
     const auto& generatedFirstOrLastName = generatedStreetAddressElements[1];
     const auto& generatedStreetSuffix = generatedStreetAddressElements[2];
 
-    std::vector<std::string> firstNames{englishFirstNamesMales};
-    firstNames.insert(firstNames.end(), englishFirstNamesFemales.begin(), englishFirstNamesFemales.end());
+    std::vector<std::string> firstNames{englishMalesFirstNames};
+    firstNames.insert(firstNames.end(), englishFemalesFirstNames.begin(), englishFemalesFirstNames.end());
 
     ASSERT_EQ(generatedStreetAddressElements.size(), 3);
     ASSERT_TRUE(generatedBuildingNumber.size() >= 3 && generatedBuildingNumber.size() <= 5);
@@ -170,7 +167,7 @@ TEST_F(LocationTest, shouldGenerateRussiaBuildingNumber)
 {
     const auto generatedBuildingNumber = Location::buildingNumber(Country::Russia);
 
-    ASSERT_TRUE(generatedBuildingNumber.size() >= 1 && generatedBuildingNumber.size() <= 3);
+    ASSERT_TRUE(!generatedBuildingNumber.empty() && generatedBuildingNumber.size() <= 3);
     ASSERT_TRUE(checkIfAllCharactersAreNumeric(generatedBuildingNumber));
 }
 
@@ -194,7 +191,7 @@ TEST_F(LocationTest, shouldGeneratePolandBuildingNumber)
 {
     const auto generatedBuildingNumber = Location::buildingNumber(Country::Poland);
 
-    ASSERT_TRUE(generatedBuildingNumber.size() >= 1 && generatedBuildingNumber.size() <= 3);
+    ASSERT_TRUE(!generatedBuildingNumber.empty() && generatedBuildingNumber.size() <= 3);
     ASSERT_TRUE(checkIfAllCharactersAreNumeric(generatedBuildingNumber));
 }
 
@@ -224,7 +221,7 @@ TEST_F(LocationTest, shouldGeneratePolandStreetAddress)
     const auto& generatedBuildingNumber = generatedStreetAddressElements.back();
     const auto& generatedStreetPrefix = generatedStreetAddressElements.front();
 
-    ASSERT_TRUE(generatedBuildingNumber.size() >= 1 && generatedBuildingNumber.size() <= 3);
+    ASSERT_TRUE(!generatedBuildingNumber.empty() && generatedBuildingNumber.size() <= 3);
     ASSERT_TRUE(checkIfAllCharactersAreNumeric(generatedBuildingNumber));
     ASSERT_TRUE(std::ranges::any_of(polandStreetPrefixes, [generatedStreetPrefix](const std::string& prefix)
                                     { return prefix == generatedStreetPrefix; }));
@@ -252,7 +249,7 @@ TEST_F(LocationTest, shouldGenerateFranceBuildingNumber)
 {
     const auto generatedBuildingNumber = Location::buildingNumber(Country::France);
 
-    ASSERT_TRUE(generatedBuildingNumber.size() >= 1 && generatedBuildingNumber.size() <= 4);
+    ASSERT_TRUE(!generatedBuildingNumber.empty() && generatedBuildingNumber.size() <= 4);
     ASSERT_TRUE(checkIfAllCharactersAreNumeric(generatedBuildingNumber));
 }
 
@@ -299,7 +296,7 @@ TEST_F(LocationTest, shouldGenerateFranceStreetAddress)
         StringHelper::join({generatedStreetAddressElements.begin() + 2, generatedStreetAddressElements.end()});
 
     ASSERT_GE(generatedStreetAddressElements.size(), 3);
-    ASSERT_TRUE(generatedBuildingNumber.size() >= 1 && generatedBuildingNumber.size() <= 4);
+    ASSERT_TRUE(!generatedBuildingNumber.empty() && generatedBuildingNumber.size() <= 4);
     ASSERT_TRUE(checkIfAllCharactersAreNumeric(generatedBuildingNumber));
     ASSERT_TRUE(std::ranges::any_of(franceStreetPrefixes, [generatedStreetPrefix](const std::string& streetPrefix)
                                     { return streetPrefix == generatedStreetPrefix; }));
@@ -312,7 +309,7 @@ TEST_F(LocationTest, shouldGenerateLatitude)
     const auto latitude = Location::latitude();
 
     auto offset = latitude.size();
-    const auto latitudeAsFloat = std::stof(latitude.data(), &offset);
+    const auto latitudeAsFloat = std::stof(latitude, &offset);
 
     const auto generatedLatitudeParts = StringHelper::split(latitude, ".");
 
@@ -327,7 +324,7 @@ TEST_F(LocationTest, shouldGenerateLatitudeWithSpecifiedPrecision)
     const auto latitude = Location::latitude(Precision::ThreeDp);
 
     auto offset = latitude.size();
-    const auto latitudeAsFloat = std::stof(latitude.data(), &offset);
+    const auto latitudeAsFloat = std::stof(latitude, &offset);
 
     const auto generatedLatitudeParts = StringHelper::split(latitude, ".");
 
@@ -342,7 +339,7 @@ TEST_F(LocationTest, shouldGenerateLongitude)
     const auto longitude = Location::longitude();
 
     auto offset = longitude.size();
-    const auto longitudeAsFloat = std::stof(longitude.data(), &offset);
+    const auto longitudeAsFloat = std::stof(longitude, &offset);
 
     const auto generatedLongitudeParts = StringHelper::split(longitude, ".");
 
@@ -357,7 +354,7 @@ TEST_F(LocationTest, shouldGenerateLongitudeWithSpecifiedPrecision)
     const auto longitude = Location::longitude(Precision::SixDp);
 
     auto offset = longitude.size();
-    const auto longitudeAsFloat = std::stof(longitude.data(), &offset);
+    const auto longitudeAsFloat = std::stof(longitude, &offset);
 
     const auto generatedLongitudeParts = StringHelper::split(longitude, ".");
 
diff --git a/src/modules/person/Person.cpp b/src/modules/person/Person.cpp
index 66a5548ac..0077baa91 100644
--- a/src/modules/person/Person.cpp
+++ b/src/modules/person/Person.cpp
@@ -1,126 +1,73 @@
 #include "faker-cxx/Person.h"
 
 #include <map>
+#include <set>
 
-#include "data/english/EnglishFirstNamesFemales.h"
-#include "data/english/EnglishFirstNamesMales.h"
-#include "data/english/EnglishLastNames.h"
-#include "data/finnish/FinnishFirstNamesFemales.h"
-#include "data/finnish/FinnishFirstNamesMales.h"
-#include "data/finnish/FinnishLastNames.h"
-#include "data/french/FrenchFirstNamesFemales.h"
-#include "data/french/FrenchFirstNamesMales.h"
-#include "data/french/FrenchLastNames.h"
+#include "../../common/StringHelper.h"
+#include "data/english/EnglishPeopleNames.h"
+#include "data/finnish/FinnishPeopleNames.h"
+#include "data/french/FrenchPeopleNames.h"
 #include "data/Gender.h"
-#include "data/german/GermanFirstNamesFemales.h"
-#include "data/german/GermanFirstNamesMales.h"
-#include "data/german/GermanLastNames.h"
+#include "data/german/GermanPeopleNames.h"
 #include "data/Hobbies.h"
-#include "data/indian/IndianFirstNames.h"
-#include "data/indian/IndianLastNames.h"
-#include "data/italian/ItalianFirstNamesFemales.h"
-#include "data/italian/ItalianFirstNamesMales.h"
-#include "data/italian/ItalianLastNames.h"
+#include "data/indian/IndianPeopleNames.h"
+#include "data/italian/ItalianPeopleNames.h"
 #include "data/JobTitles.h"
 #include "data/Nationalities.h"
-#include "data/nepalese/NepaleseFirstNamesFemales.h"
-#include "data/nepalese/NepaleseFirstNamesMales.h"
-#include "data/nepalese/NepaleseLastNames.h"
-#include "data/polish/PolishFirstNamesFemales.h"
-#include "data/polish/PolishFirstNamesMales.h"
-#include "data/polish/PolishLastNames.h"
-#include "data/romanian/RomanianFirstNamesFemales.h"
-#include "data/romanian/RomanianFirstNamesMales.h"
-#include "data/romanian/RomanianLastNames.h"
-#include "data/russian/RussianFirstNamesFemales.h"
-#include "data/russian/RussianFirstNamesMales.h"
-#include "data/russian/RussianLastNamesFemales.h"
-#include "data/russian/RussianLastNamesMales.h"
-#include "data/spanish/SpanishFirstNamesFemales.h"
-#include "data/spanish/SpanishFirstNamesMales.h"
-#include "data/spanish/SpanishLastNames.h"
+#include "data/nepalese/NepalesePeopleNames.h"
+#include "data/polish/PolishPeopleNames.h"
+#include "data/romanian/RomanianPeopleNames.h"
+#include "data/russian/RussianPeopleNames.h"
+#include "data/spanish/SpanishPeopleNames.h"
+#include "data/turkish/TurkishPeopleNames.h"
 #include "faker-cxx/Helper.h"
-#include "data/turkish/TurkishFirstNamesFemales.h"
-#include "data/turkish/TurkishFirstNamesMales.h"
-#include "data/turkish/TurkishLastNames.h"
 #include "fmt/format.h"
 
 namespace faker
 {
 namespace
 {
-
 const std::vector<std::string> sexes{"Male", "Female"};
 
-const std::map<Language, std::map<Sex, std::vector<std::string>>> languageToFirstNamesMapping{
-    {Language::English, {{Sex::Male, englishFirstNamesMales}, {Sex::Female, englishFirstNamesFemales}}},
-    {Language::French, {{Sex::Male, frenchFirstNamesMales}, {Sex::Female, frenchFirstNamesFemales}}},
-    {Language::German, {{Sex::Male, germanFirstNamesMales}, {Sex::Female, germanFirstNamesFemales}}},
-    {Language::Italian, {{Sex::Male, italianFirstNamesMales}, {Sex::Female, italianFirstNamesFemales}}},
-    {Language::Polish, {{Sex::Male, polishFirstNamesMales}, {Sex::Female, polishFirstNamesFemales}}},
-    {Language::Russian, {{Sex::Male, russianFirstNamesMales}, {Sex::Female, russianFirstNamesFemales}}},
-    {Language::Romanian, {{Sex::Male, romanianFirstNamesMales}, {Sex::Female, romanianFirstNamesFemales}}},
-    {Language::Hindi, {{Sex::Male, indianFirstNamesMales}, {Sex::Female, indianFirstNamesFemales}}},
-    {Language::Finnish, {{Sex::Male, finnishFirstNamesMales}, {Sex::Female, finnishFirstNamesFemales}}},
-    {Language::Nepali, {{Sex::Male, nepaleseFirstNamesMales}, {Sex::Female, nepaleseFirstNamesFemales}}},
-    {Language::Spanish, {{Sex::Male, spanishFirstNamesMales}, {Sex::Female, spanishFirstNamesFemales}}},
-    {Language::Turkish, {{Sex::Male, turkishFirstNamesMales}, {Sex::Female, turkishFirstNamesFemales}}},
-};
-
-const std::map<Language, std::map<Sex, std::vector<std::string>>> languageToLastNamesMapping{
-    {Language::English, {{Sex::Male, englishLastNames}, {Sex::Female, englishLastNames}}},
-    {Language::French, {{Sex::Male, frenchLastNames}, {Sex::Female, frenchLastNames}}},
-    {Language::German, {{Sex::Male, germanLastNames}, {Sex::Female, germanLastNames}}},
-    {Language::Italian, {{Sex::Male, italianLastNames}, {Sex::Female, italianLastNames}}},
-    {Language::Polish, {{Sex::Male, polishLastNames}, {Sex::Female, polishLastNames}}},
-    {Language::Russian, {{Sex::Male, russianLastNamesMales}, {Sex::Female, russianLastNamesFemales}}},
-    {Language::Romanian, {{Sex::Male, romanianLastNames}, {Sex::Female, romanianLastNames}}},
-    {Language::Hindi, {{Sex::Male, indianLastNames}, {Sex::Female, indianLastNames}}},
-    {Language::Finnish, {{Sex::Male, finnishLastNames}, {Sex::Female, finnishLastNames}}},
-    {Language::Nepali, {{Sex::Male, nepaleseLastNames}, {Sex::Female, nepaleseLastNames}}},
-    {Language::Spanish, {{Sex::Male, spanishLastNames}, {Sex::Female, spanishLastNames}}},
-    {Language::Turkish, {{Sex::Male, turkishLastNames}, {Sex::Female, turkishLastNames}}},
+const std::map<Language, PeopleNames> languageToPeopleNamesMapping{
+    {Language::English, englishPeopleNames},   {Language::French, frenchPeopleNames},
+    {Language::German, germanPeopleNames},     {Language::Italian, italianPeopleNames},
+    {Language::Polish, polishPeopleNames},     {Language::Russian, russianPeopleNames},
+    {Language::Romanian, romanianPeopleNames}, {Language::Hindi, indianPeopleNames},
+    {Language::Finnish, finnishPeopleNames},   {Language::Nepali, nepalesePeopleNames},
+    {Language::Spanish, spanishPeopleNames},   {Language::Turkish, turkishPeopleNames},
 };
 
-const std::map<Language, std::map<Sex, std::vector<std::string>>> languageToPrefixesMapping{
-    {Language::English, {{Sex::Male, englishLastNames}, {Sex::Female, englishLastNames}}},
-    {Language::French, {{Sex::Male, frenchLastNames}, {Sex::Female, frenchLastNames}}},
-    {Language::German, {{Sex::Male, germanLastNames}, {Sex::Female, germanLastNames}}},
-    {Language::Italian, {{Sex::Male, italianLastNames}, {Sex::Female, italianLastNames}}},
-    {Language::Polish, {{Sex::Male, polishLastNames}, {Sex::Female, polishLastNames}}},
-    {Language::Russian, {{Sex::Male, russianLastNamesMales}, {Sex::Female, russianLastNamesFemales}}},
-    {Language::Romanian, {{Sex::Male, romanianLastNames}, {Sex::Female, romanianLastNames}}},
-    {Language::Hindi, {{Sex::Male, indianLastNames}, {Sex::Female, indianLastNames}}},
-    {Language::Finnish, {{Sex::Male, finnishLastNames}, {Sex::Female, finnishLastNames}}},
-    {Language::Nepali, {{Sex::Male, nepaleseLastNames}, {Sex::Female, nepaleseLastNames}}},
-};
+std::string middleNameForLanguage(Language language, std::optional<Sex> sex);
+std::string prefixForLanguage(Language language, std::optional<Sex> sex);
+std::string suffixForLanguage(Language language, std::optional<Sex> sex);
 }
 
 std::string Person::firstName(Language language, std::optional<Sex> sex)
 {
-    const auto& firstNamesBySexMapping = languageToFirstNamesMapping.at(language);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
 
     std::vector<std::string> firstNames;
 
     if (sex == Sex::Male)
     {
-        const auto& firstNamesMales = firstNamesBySexMapping.at(Sex::Male);
+        const auto& malesFirstNames = peopleNames.malesNames.firstNames;
 
-        firstNames.insert(firstNames.end(), firstNamesMales.begin(), firstNamesMales.end());
+        firstNames.insert(firstNames.end(), malesFirstNames.begin(), malesFirstNames.end());
     }
     else if (sex == Sex::Female)
     {
-        const auto& firstNamesFemales = firstNamesBySexMapping.at(Sex::Female);
+        const auto& femalesFirstNames = peopleNames.femalesNames.firstNames;
 
-        firstNames.insert(firstNames.end(), firstNamesFemales.begin(), firstNamesFemales.end());
+        firstNames.insert(firstNames.end(), femalesFirstNames.begin(), femalesFirstNames.end());
     }
     else
     {
-        const auto& firstNamesMales = firstNamesBySexMapping.at(Sex::Male);
-        const auto& firstNamesFemales = firstNamesBySexMapping.at(Sex::Female);
+        const auto& malesFirstNames = peopleNames.malesNames.firstNames;
+        const auto& femalesFirstNames = peopleNames.femalesNames.firstNames;
 
-        firstNames.insert(firstNames.end(), firstNamesMales.begin(), firstNamesMales.end());
-        firstNames.insert(firstNames.end(), firstNamesFemales.begin(), firstNamesFemales.end());
+        firstNames.insert(firstNames.end(), malesFirstNames.begin(), malesFirstNames.end());
+        firstNames.insert(firstNames.end(), femalesFirstNames.begin(), femalesFirstNames.end());
     }
 
     return Helper::arrayElement<std::string>(firstNames);
@@ -128,80 +75,188 @@ std::string Person::firstName(Language language, std::optional<Sex> sex)
 
 std::string Person::lastName(Language language, std::optional<Sex> sex)
 {
-    const auto& lastNamesBySexMapping = languageToLastNamesMapping.at(language);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
 
     std::vector<std::string> lastNames;
 
     if (sex == Sex::Male)
     {
-        const auto& lastNamesMales = lastNamesBySexMapping.at(Sex::Male);
+        const auto& malesLastNames = peopleNames.malesNames.lastNames;
 
-        lastNames.insert(lastNames.end(), lastNamesMales.begin(), lastNamesMales.end());
+        lastNames.insert(lastNames.end(), malesLastNames.begin(), malesLastNames.end());
     }
     else if (sex == Sex::Female)
     {
-        const auto& lastNamesFemales = lastNamesBySexMapping.at(Sex::Female);
+        const auto& femalesLastNames = peopleNames.femalesNames.lastNames;
 
-        lastNames.insert(lastNames.end(), lastNamesFemales.begin(), lastNamesFemales.end());
+        lastNames.insert(lastNames.end(), femalesLastNames.begin(), femalesLastNames.end());
     }
     else
     {
-        const auto& lastNamesMales = lastNamesBySexMapping.at(Sex::Male);
-        const auto& lastNamesFemales = lastNamesBySexMapping.at(Sex::Female);
+        const auto& malesLastNames = peopleNames.malesNames.lastNames;
+        const auto& femalesLastNames = peopleNames.femalesNames.lastNames;
 
-        lastNames.insert(lastNames.end(), lastNamesMales.begin(), lastNamesMales.end());
-        lastNames.insert(lastNames.end(), lastNamesFemales.begin(), lastNamesFemales.end());
+        lastNames.insert(lastNames.end(), malesLastNames.begin(), malesLastNames.end());
+        lastNames.insert(lastNames.end(), femalesLastNames.begin(), femalesLastNames.end());
     }
 
     return Helper::arrayElement<std::string>(lastNames);
 }
 
-std::string Person::fullName(Language language, std::optional<Sex> sex)
+std::string Person::middleName(std::optional<Sex> sex)
 {
-    return fmt::format("{} {}", firstName(language, sex), lastName(language, sex));
-}
+    std::vector<std::string> allMiddleNames;
 
-std::string Person::prefix(std::optional<Sex> sex)
-{
-    const auto& lastNamesBySexMapping = languageToLastNamesMapping.at(language);
+    for (const auto& [_, peopleNames] : languageToPeopleNamesMapping)
+    {
+        std::vector<std::string> middleNames;
 
-    std::vector<std::string> lastNames;
+        if (sex == Sex::Male)
+        {
+            const auto& malesMiddleNames = peopleNames.malesNames.middleNames;
 
-    if (sex == Sex::Male)
-    {
-        const auto& lastNamesMales = lastNamesBySexMapping.at(Sex::Male);
+            middleNames.insert(middleNames.end(), malesMiddleNames.begin(), malesMiddleNames.end());
+        }
+        else if (sex == Sex::Female)
+        {
+            const auto& femalesMiddleNames = peopleNames.femalesNames.middleNames;
+
+            middleNames.insert(middleNames.end(), femalesMiddleNames.begin(), femalesMiddleNames.end());
+        }
+        else
+        {
+            const auto& malesMiddleNames = peopleNames.malesNames.middleNames;
+            const auto& femalesMiddleNames = peopleNames.femalesNames.middleNames;
+
+            middleNames.insert(middleNames.end(), malesMiddleNames.begin(), malesMiddleNames.end());
+            middleNames.insert(middleNames.end(), femalesMiddleNames.begin(), femalesMiddleNames.end());
+        }
+
+        std::set<std::string> uniqueMiddleNames(middleNames.begin(), middleNames.end());
 
-        lastNames.insert(lastNames.end(), lastNamesMales.begin(), lastNamesMales.end());
+        middleNames.assign(uniqueMiddleNames.begin(), uniqueMiddleNames.end());
+
+        allMiddleNames.insert(allMiddleNames.end(), middleNames.begin(), middleNames.end());
     }
-    else if (sex == Sex::Female)
-    {
-        const auto& lastNamesFemales = lastNamesBySexMapping.at(Sex::Female);
 
-        lastNames.insert(lastNames.end(), lastNamesFemales.begin(), lastNamesFemales.end());
+    if (allMiddleNames.empty())
+    {
+        throw std::runtime_error{fmt::format("No middle name fround, sex: {}.", sex ? toString(*sex) : "none")};
     }
-    else
+
+    return Helper::arrayElement<std::string>(allMiddleNames);
+}
+
+std::string Person::fullName(Language language, std::optional<Sex> sex)
+{
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
+
+    std::vector<Helper::WeightedElement<std::string>> weightedElements;
+
+    for (const auto& nameFormat : peopleNames.nameFormats)
     {
-        const auto& lastNamesMales = lastNamesBySexMapping.at(Sex::Male);
-        const auto& lastNamesFemales = lastNamesBySexMapping.at(Sex::Female);
+        weightedElements.push_back({nameFormat.weight, nameFormat.format});
+    }
+
+    const auto nameFormat = Helper::weightedArrayElement<std::string>(weightedElements);
 
-        lastNames.insert(lastNames.end(), lastNamesMales.begin(), lastNamesMales.end());
-        lastNames.insert(lastNames.end(), lastNamesFemales.begin(), lastNamesFemales.end());
+    const auto nameFormatElements = StringHelper::split(nameFormat, " ");
+
+    std::vector<std::string> nameElements;
+
+    for (const auto& nameFormatElement : nameFormatElements)
+    {
+        if (nameFormatElement == "{firstName}")
+        {
+            nameElements.push_back(Person::firstName(language, sex));
+        }
+        else if (nameFormatElement == "{middleName}")
+        {
+            nameElements.push_back(middleNameForLanguage(language, sex));
+        }
+        else if (nameFormatElement == "{lastName}")
+        {
+            nameElements.push_back(Person::lastName(language, sex));
+        }
+        else if (nameFormatElement == "{prefix}")
+        {
+            nameElements.push_back(prefixForLanguage(language, sex));
+        }
+        else if (nameFormatElement == "{suffix}")
+        {
+            nameElements.push_back(suffixForLanguage(language, sex));
+        }
     }
 
-    return Helper::arrayElement<std::string>(lastNames);
+    return StringHelper::join(nameElements, " ");
+}
 
-    if (sex == Sex::Male)
+std::string Person::prefix(std::optional<Sex> sex)
+{
+    std::vector<std::string> allPrefixes;
+
+    for (const auto& [_, peopleNames] : languageToPeopleNamesMapping)
     {
-        return malePrefix;
+        std::vector<std::string> prefixes;
+
+        if (sex == Sex::Male)
+        {
+            const auto& malesPrefixes = peopleNames.malesNames.prefixes;
+
+            prefixes.insert(prefixes.end(), malesPrefixes.begin(), malesPrefixes.end());
+        }
+        else if (sex == Sex::Female)
+        {
+            const auto& femalesPrefixes = peopleNames.femalesNames.prefixes;
+
+            prefixes.insert(prefixes.end(), femalesPrefixes.begin(), femalesPrefixes.end());
+        }
+        else
+        {
+            const auto& malesPrefixes = peopleNames.malesNames.prefixes;
+            const auto& femalesPrefixes = peopleNames.femalesNames.prefixes;
+
+            prefixes.insert(prefixes.end(), malesPrefixes.begin(), malesPrefixes.end());
+            prefixes.insert(prefixes.end(), femalesPrefixes.begin(), femalesPrefixes.end());
+        }
+
+        std::set<std::string> uniquePrefixes(prefixes.begin(), prefixes.end());
+
+        prefixes.assign(uniquePrefixes.begin(), uniquePrefixes.end());
+
+        allPrefixes.insert(allPrefixes.end(), prefixes.begin(), prefixes.end());
     }
-    else if (sex == Sex::Female)
+
+    if (allPrefixes.empty())
     {
-        return Helper::arrayElement<std::string>(femalePrefixes);
+        throw std::runtime_error{fmt::format("No prefixes fround, sex: {}.", sex ? toString(*sex) : "none")};
     }
-    else
+
+    return Helper::arrayElement<std::string>(allPrefixes);
+}
+
+std::string Person::suffix()
+{
+    std::vector<std::string> allSuffixes;
+
+    for (const auto& [_, peopleNames] : languageToPeopleNamesMapping)
     {
-        return Helper::arrayElement<std::string>(allPrefixes);
+        std::vector<std::string> suffixes;
+
+        const auto& malesSuffixes = peopleNames.malesNames.suffixes;
+        const auto& femalesSuffixes = peopleNames.femalesNames.suffixes;
+
+        suffixes.insert(suffixes.end(), malesSuffixes.begin(), malesSuffixes.end());
+        suffixes.insert(suffixes.end(), femalesSuffixes.begin(), femalesSuffixes.end());
+
+        std::set<std::string> uniqueSuffixes(suffixes.begin(), suffixes.end());
+
+        suffixes.assign(uniqueSuffixes.begin(), uniqueSuffixes.end());
+
+        allSuffixes.insert(allSuffixes.end(), suffixes.begin(), suffixes.end());
     }
+
+    return Helper::arrayElement<std::string>(allSuffixes);
 }
 
 std::string Person::sex()
@@ -248,4 +303,97 @@ std::string Person::nationality()
 {
     return Helper::arrayElement<std::string>(nationalities);
 }
+
+namespace
+{
+std::string middleNameForLanguage(Language language, std::optional<Sex> sex)
+{
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
+
+    std::vector<std::string> middleNames;
+
+    if (sex == Sex::Male)
+    {
+        const auto& malesMiddleNames = peopleNames.malesNames.middleNames;
+
+        middleNames.insert(middleNames.end(), malesMiddleNames.begin(), malesMiddleNames.end());
+    }
+    else if (sex == Sex::Female)
+    {
+        const auto& femalesMiddleNames = peopleNames.femalesNames.middleNames;
+
+        middleNames.insert(middleNames.end(), femalesMiddleNames.begin(), femalesMiddleNames.end());
+    }
+    else
+    {
+        const auto& malesMiddleNames = peopleNames.malesNames.middleNames;
+        const auto& femalesMiddleNames = peopleNames.femalesNames.middleNames;
+
+        middleNames.insert(middleNames.end(), malesMiddleNames.begin(), malesMiddleNames.end());
+        middleNames.insert(middleNames.end(), femalesMiddleNames.begin(), femalesMiddleNames.end());
+    }
+
+    return Helper::arrayElement<std::string>(middleNames);
+}
+
+std::string prefixForLanguage(Language language, std::optional<Sex> sex)
+{
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
+
+    std::vector<std::string> prefixes;
+
+    if (sex == Sex::Male)
+    {
+        const auto& malesPrefixes = peopleNames.malesNames.prefixes;
+
+        prefixes.insert(prefixes.end(), malesPrefixes.begin(), malesPrefixes.end());
+    }
+    else if (sex == Sex::Female)
+    {
+        const auto& femalesPrefixes = peopleNames.femalesNames.prefixes;
+
+        prefixes.insert(prefixes.end(), femalesPrefixes.begin(), femalesPrefixes.end());
+    }
+    else
+    {
+        const auto& malesPrefixes = peopleNames.malesNames.prefixes;
+        const auto& femalesPrefixes = peopleNames.femalesNames.prefixes;
+
+        prefixes.insert(prefixes.end(), malesPrefixes.begin(), malesPrefixes.end());
+        prefixes.insert(prefixes.end(), femalesPrefixes.begin(), femalesPrefixes.end());
+    }
+
+    return Helper::arrayElement<std::string>(prefixes);
+}
+
+std::string suffixForLanguage(Language language, std::optional<Sex> sex)
+{
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
+
+    std::vector<std::string> suffixes;
+
+    if (sex == Sex::Male)
+    {
+        const auto& malesSuffixes = peopleNames.malesNames.suffixes;
+
+        suffixes.insert(suffixes.end(), malesSuffixes.begin(), malesSuffixes.end());
+    }
+    else if (sex == Sex::Female)
+    {
+        const auto& femalesSuffixes = peopleNames.femalesNames.suffixes;
+
+        suffixes.insert(suffixes.end(), femalesSuffixes.begin(), femalesSuffixes.end());
+    }
+    else
+    {
+        const auto& malesSuffixes = peopleNames.malesNames.suffixes;
+        const auto& femalesSuffixes = peopleNames.femalesNames.suffixes;
+
+        suffixes.insert(suffixes.end(), malesSuffixes.begin(), malesSuffixes.end());
+        suffixes.insert(suffixes.end(), femalesSuffixes.begin(), femalesSuffixes.end());
+    }
+
+    return Helper::arrayElement<std::string>(suffixes);
+}
+}
 }
diff --git a/src/modules/person/PersonTest.cpp b/src/modules/person/PersonTest.cpp
index 9aa51ac93..dab9ee8e3 100644
--- a/src/modules/person/PersonTest.cpp
+++ b/src/modules/person/PersonTest.cpp
@@ -4,85 +4,39 @@
 
 #include "gtest/gtest.h"
 
-#include "data/english/EnglishFirstNamesFemales.h"
-#include "data/english/EnglishFirstNamesMales.h"
-#include "data/english/EnglishLastNames.h"
-#include "data/finnish/FinnishFirstNamesFemales.h"
-#include "data/finnish/FinnishFirstNamesMales.h"
-#include "data/finnish/FinnishLastNames.h"
-#include "data/french/FrenchFirstNamesFemales.h"
-#include "data/french/FrenchFirstNamesMales.h"
-#include "data/french/FrenchLastNames.h"
+#include "../../common/StringHelper.h"
+#include "data/english/EnglishPeopleNames.h"
+#include "data/finnish/FinnishPeopleNames.h"
+#include "data/french/FrenchPeopleNames.h"
 #include "data/Gender.h"
-#include "data/german/GermanFirstNamesFemales.h"
-#include "data/german/GermanFirstNamesMales.h"
-#include "data/german/GermanLastNames.h"
+#include "data/german/GermanPeopleNames.h"
 #include "data/Hobbies.h"
-#include "data/indian/IndianFirstNames.h"
-#include "data/indian/IndianLastNames.h"
-#include "data/italian/ItalianFirstNamesFemales.h"
-#include "data/italian/ItalianFirstNamesMales.h"
-#include "data/italian/ItalianLastNames.h"
+#include "data/indian/IndianPeopleNames.h"
+#include "data/italian/ItalianPeopleNames.h"
 #include "data/JobTitles.h"
 #include "data/Nationalities.h"
-#include "data/polish/PolishFirstNamesFemales.h"
-#include "data/polish/PolishFirstNamesMales.h"
-#include "data/polish/PolishLastNames.h"
-#include "data/romanian/RomanianFirstNamesFemales.h"
-#include "data/romanian/RomanianFirstNamesMales.h"
-#include "data/romanian/RomanianLastNames.h"
-#include "data/russian/RussianFirstNamesFemales.h"
-#include "data/russian/RussianFirstNamesMales.h"
-#include "data/russian/RussianLastNamesFemales.h"
-#include "data/russian/RussianLastNamesMales.h"
-#include "data/spanish/SpanishFirstNamesFemales.h"
-#include "data/spanish/SpanishFirstNamesMales.h"
-#include "data/spanish/SpanishLastNames.h"
-#include "src/common/StringHelper.h"
-#include "src/modules/person/data/nepalese/NepaleseFirstNamesFemales.h"
-#include "src/modules/person/data/nepalese/NepaleseFirstNamesMales.h"
-#include "src/modules/person/data/nepalese/NepaleseLastNames.h"
-#include "data/turkish/TurkishFirstNamesFemales.h"
-#include "data/turkish/TurkishFirstNamesMales.h"
-#include "data/turkish/TurkishLastNames.h"
+#include "data/nepalese/NepalesePeopleNames.h"
+#include "data/polish/PolishPeopleNames.h"
+#include "data/romanian/RomanianPeopleNames.h"
+#include "data/russian/RussianPeopleNames.h"
+#include "data/spanish/SpanishPeopleNames.h"
+#include "data/turkish/TurkishPeopleNames.h"
+#include "src/modules/person/data/PeopleNames.h"
 
 using namespace ::testing;
 using namespace faker;
 
 namespace
 {
-const auto malePrefix{"Mr."};
-const std::vector<std::string> femalePrefixes{"Ms.", "Miss"};
-const std::vector<std::string> allPrefixes{"Mr.", "Ms.", "Miss"};
-
-const std::map<Language, std::map<Sex, std::vector<std::string>>> languageToFirstNamesMapping{
-    {Language::English, {{Sex::Male, englishFirstNamesMales}, {Sex::Female, englishFirstNamesFemales}}},
-    {Language::French, {{Sex::Male, frenchFirstNamesMales}, {Sex::Female, frenchFirstNamesFemales}}},
-    {Language::German, {{Sex::Male, germanFirstNamesMales}, {Sex::Female, germanFirstNamesFemales}}},
-    {Language::Italian, {{Sex::Male, italianFirstNamesMales}, {Sex::Female, italianFirstNamesFemales}}},
-    {Language::Polish, {{Sex::Male, polishFirstNamesMales}, {Sex::Female, polishFirstNamesFemales}}},
-    {Language::Russian, {{Sex::Male, russianFirstNamesMales}, {Sex::Female, russianFirstNamesFemales}}},
-    {Language::Romanian, {{Sex::Male, romanianFirstNamesMales}, {Sex::Female, romanianFirstNamesFemales}}},
-    {Language::Hindi, {{Sex::Male, indianFirstNamesMales}, {Sex::Female, indianFirstNamesFemales}}},
-    {Language::Finnish, {{Sex::Male, finnishFirstNamesMales}, {Sex::Female, finnishFirstNamesFemales}}},
-    {Language::Nepali, {{Sex::Male, nepaleseFirstNamesMales}, {Sex::Female, nepaleseFirstNamesFemales}}},
-    {Language::Spanish, {{Sex::Male, spanishFirstNamesMales}, {Sex::Female, spanishFirstNamesFemales}}},
-    {Language::Turkish, {{Sex::Male, turkishFirstNamesMales}, {Sex::Female, turkishFirstNamesFemales}}},
-};
-
-const std::map<Language, std::map<Sex, std::vector<std::string>>> languageToLastNamesMapping{
-    {Language::English, {{Sex::Male, englishLastNames}, {Sex::Female, englishLastNames}}},
-    {Language::French, {{Sex::Male, frenchLastNames}, {Sex::Female, frenchLastNames}}},
-    {Language::German, {{Sex::Male, germanLastNames}, {Sex::Female, germanLastNames}}},
-    {Language::Italian, {{Sex::Male, italianLastNames}, {Sex::Female, italianLastNames}}},
-    {Language::Polish, {{Sex::Male, polishLastNames}, {Sex::Female, polishLastNames}}},
-    {Language::Russian, {{Sex::Male, russianLastNamesMales}, {Sex::Female, russianLastNamesFemales}}},
-    {Language::Romanian, {{Sex::Male, romanianLastNames}, {Sex::Female, romanianLastNames}}},
-    {Language::Hindi, {{Sex::Male, indianLastNames}, {Sex::Female, indianLastNames}}},
-    {Language::Finnish, {{Sex::Male, finnishLastNames}, {Sex::Female, finnishLastNames}}},
-    {Language::Nepali, {{Sex::Male, nepaleseLastNames}, {Sex::Female, nepaleseLastNames}}},
-    {Language::Spanish, {{Sex::Male, spanishLastNames}, {Sex::Female, spanishLastNames}}},
-    {Language::Turkish, {{Sex::Male, turkishLastNames}, {Sex::Female, turkishLastNames}}},
+const std::vector<std::string> sexes{"Male", "Female"};
+
+const std::map<Language, PeopleNames> languageToPeopleNamesMapping{
+    {Language::English, englishPeopleNames},   {Language::French, frenchPeopleNames},
+    {Language::German, germanPeopleNames},     {Language::Italian, italianPeopleNames},
+    {Language::Polish, polishPeopleNames},     {Language::Russian, russianPeopleNames},
+    {Language::Romanian, romanianPeopleNames}, {Language::Hindi, indianPeopleNames},
+    {Language::Finnish, finnishPeopleNames},   {Language::Nepali, nepalesePeopleNames},
+    {Language::Spanish, spanishPeopleNames},   {Language::Turkish, turkishPeopleNames},
 };
 
 const std::map<Language, std::string> generatedTestName{
@@ -91,23 +45,92 @@ const std::map<Language, std::string> generatedTestName{
     {Language::Polish, "shouldGeneratePolishName"},     {Language::Russian, "shouldGenerateRussianName"},
     {Language::Romanian, "shouldGenerateRomanianName"}, {Language::Hindi, "shouldGenerateIndianName"},
     {Language::Finnish, "shouldGenerateFinnishName"},   {Language::Nepali, "shouldGenerateNepaleseName"},
-    {Language::Spanish, "shouldGenerateSpanishName"}, {Language::Turkish, "shouldGenerateTurkishName"},
+    {Language::Spanish, "shouldGenerateSpanishName"},   {Language::Turkish, "shouldGenerateTurkishName"},
 };
 }
 
 class PersonTest : public TestWithParam<Language>
 {
 public:
+    PersonTest()
+    {
+        initializePrefixes();
+
+        initializeSuffixes();
+
+        initializeMiddleNames();
+    }
+
+    void initializePrefixes()
+    {
+        for (const auto& [_, peopleNames] : languageToPeopleNamesMapping)
+        {
+            malesPrefixes.insert(malesPrefixes.end(), peopleNames.malesNames.prefixes.begin(),
+                                 peopleNames.malesNames.prefixes.end());
+
+            femalesPrefixes.insert(femalesPrefixes.end(), peopleNames.femalesNames.prefixes.begin(),
+                                   peopleNames.femalesNames.prefixes.end());
+
+            allPrefixes.insert(allPrefixes.end(), peopleNames.malesNames.prefixes.begin(),
+                               peopleNames.malesNames.prefixes.end());
+            allPrefixes.insert(allPrefixes.end(), peopleNames.femalesNames.prefixes.begin(),
+                               peopleNames.femalesNames.prefixes.end());
+        }
+    }
+
+    void initializeSuffixes()
+    {
+        for (const auto& [_, peopleNames] : languageToPeopleNamesMapping)
+        {
+            malesSuffixes.insert(malesSuffixes.end(), peopleNames.malesNames.suffixes.begin(),
+                                 peopleNames.malesNames.suffixes.end());
+
+            femalesSuffixes.insert(femalesSuffixes.end(), peopleNames.femalesNames.suffixes.begin(),
+                                   peopleNames.femalesNames.suffixes.end());
+
+            allSuffixes.insert(allSuffixes.end(), peopleNames.malesNames.suffixes.begin(),
+                               peopleNames.malesNames.suffixes.end());
+            allSuffixes.insert(allSuffixes.end(), peopleNames.femalesNames.suffixes.begin(),
+                               peopleNames.femalesNames.suffixes.end());
+        }
+    }
+
+    void initializeMiddleNames()
+    {
+        for (const auto& [_, peopleNames] : languageToPeopleNamesMapping)
+        {
+            malesMiddleNames.insert(malesMiddleNames.end(), peopleNames.malesNames.middleNames.begin(),
+                                    peopleNames.malesNames.middleNames.end());
+
+            femalesMiddleNames.insert(femalesMiddleNames.end(), peopleNames.femalesNames.middleNames.begin(),
+                                      peopleNames.femalesNames.middleNames.end());
+
+            allMiddleNames.insert(allMiddleNames.end(), peopleNames.malesNames.middleNames.begin(),
+                                  peopleNames.malesNames.middleNames.end());
+            allMiddleNames.insert(allMiddleNames.end(), peopleNames.femalesNames.middleNames.begin(),
+                                  peopleNames.femalesNames.middleNames.end());
+        }
+    }
+
+    std::vector<std::string> allPrefixes;
+    std::vector<std::string> malesPrefixes;
+    std::vector<std::string> femalesPrefixes;
+    std::vector<std::string> allSuffixes;
+    std::vector<std::string> malesSuffixes;
+    std::vector<std::string> femalesSuffixes;
+    std::vector<std::string> allMiddleNames;
+    std::vector<std::string> malesMiddleNames;
+    std::vector<std::string> femalesMiddleNames;
 };
 
 TEST_P(PersonTest, shouldGenerateFirstName)
 {
     const auto language = GetParam();
 
-    const auto& firstNamesBySexMapping = languageToFirstNamesMapping.at(language);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
 
-    const auto& malesFirstNames = firstNamesBySexMapping.at(Sex::Male);
-    const auto& femalesFirstNames = firstNamesBySexMapping.at(Sex::Female);
+    const auto& malesFirstNames = peopleNames.malesNames.firstNames;
+    const auto& femalesFirstNames = peopleNames.femalesNames.firstNames;
 
     std::vector<std::string> firstNames{malesFirstNames};
 
@@ -123,9 +146,9 @@ TEST_P(PersonTest, shouldGenerateMaleFirstName)
 {
     const auto language = GetParam();
 
-    const auto& firstNamesBySexMapping = languageToFirstNamesMapping.at(language);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
 
-    const auto& malesFirstNames = firstNamesBySexMapping.at(Sex::Male);
+    const auto& malesFirstNames = peopleNames.malesNames.firstNames;
 
     const auto generatedFirstName = Person::firstName(language, Sex::Male);
 
@@ -137,9 +160,9 @@ TEST_P(PersonTest, shouldGenerateFemaleFirstName)
 {
     const auto language = GetParam();
 
-    const auto& firstNamesBySexMapping = languageToFirstNamesMapping.at(language);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
 
-    const auto& femalesFirstNames = firstNamesBySexMapping.at(Sex::Female);
+    const auto& femalesFirstNames = peopleNames.femalesNames.firstNames;
 
     const auto generatedFirstName = Person::firstName(language, Sex::Female);
 
@@ -151,7 +174,9 @@ TEST_P(PersonTest, shouldGenerateLastNameMale)
 {
     const auto language = GetParam();
 
-    const auto& malesLastNames = languageToLastNamesMapping.at(language).at(Sex::Male);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
+
+    const auto& malesLastNames = peopleNames.malesNames.lastNames;
 
     const auto generatedLastName = Person::lastName(language, Sex::Male);
 
@@ -163,7 +188,9 @@ TEST_P(PersonTest, shouldGenerateLastNameFemale)
 {
     const auto language = GetParam();
 
-    const auto& femalesLastNames = languageToLastNamesMapping.at(language).at(Sex::Female);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
+
+    const auto& femalesLastNames = peopleNames.femalesNames.lastNames;
 
     const auto generatedLastName = Person::lastName(language, Sex::Female);
 
@@ -175,15 +202,13 @@ TEST_P(PersonTest, shouldGenerateFullName)
 {
     const auto language = GetParam();
 
-    const auto& firstNamesBySexMapping = languageToFirstNamesMapping.at(language);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
 
-    const auto& malesFirstNames = firstNamesBySexMapping.at(Sex::Male);
-    const auto& femalesFirstNames = firstNamesBySexMapping.at(Sex::Female);
+    const auto& malesFirstNames = peopleNames.malesNames.firstNames;
+    const auto& femalesFirstNames = peopleNames.femalesNames.firstNames;
 
-    const auto& lastNamesBySexMapping = languageToLastNamesMapping.at(language);
-
-    const auto& malesLastNames = lastNamesBySexMapping.at(Sex::Male);
-    const auto& femalesLastNames = lastNamesBySexMapping.at(Sex::Female);
+    const auto& malesLastNames = peopleNames.malesNames.lastNames;
+    const auto& femalesLastNames = peopleNames.malesNames.lastNames;
 
     std::vector<std::string> firstNames{malesFirstNames};
     std::vector<std::string> lastNames{malesLastNames};
@@ -194,54 +219,92 @@ TEST_P(PersonTest, shouldGenerateFullName)
     const auto generatedFullName = Person::fullName(language);
 
     ASSERT_TRUE(std::ranges::any_of(firstNames, [generatedFullName](const std::string& firstName)
-                                    { return generatedFullName.starts_with(firstName); }));
+                                    { return generatedFullName.find(firstName) != std::string::npos; }));
     ASSERT_TRUE(std::ranges::any_of(lastNames, [generatedFullName](const std::string& lastName)
-                                    { return generatedFullName.ends_with(lastName); }));
+                                    { return generatedFullName.find(lastName) != std::string::npos; }));
 }
 
 TEST_P(PersonTest, shouldGenerateMaleFullName)
 {
     const auto language = GetParam();
 
-    const auto& firstNamesBySexMapping = languageToFirstNamesMapping.at(language);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
 
-    const auto& malesFirstNames = firstNamesBySexMapping.at(Sex::Male);
+    const auto& malesFirstNames = peopleNames.malesNames.firstNames;
 
-    const auto& malesLastNames = languageToLastNamesMapping.at(language).at(Sex::Male);
+    const auto& malesLastNames = peopleNames.malesNames.lastNames;
 
     const auto generatedFullName = Person::fullName(language, Sex::Male);
 
     ASSERT_TRUE(std::ranges::any_of(malesFirstNames, [generatedFullName](const std::string& firstName)
-                                    { return generatedFullName.starts_with(firstName); }));
+                                    { return generatedFullName.find(firstName) != std::string::npos; }));
     ASSERT_TRUE(std::ranges::any_of(malesLastNames, [generatedFullName](const std::string& lastName)
-                                    { return generatedFullName.ends_with(lastName); }));
+                                    { return generatedFullName.find(lastName) != std::string::npos; }));
 }
 
 TEST_P(PersonTest, shouldGenerateFemaleFullName)
 {
     const auto language = GetParam();
 
-    const auto& firstNamesBySexMapping = languageToFirstNamesMapping.at(language);
+    const auto& peopleNames = languageToPeopleNamesMapping.at(language);
 
-    const auto& femalesFirstNames = firstNamesBySexMapping.at(Sex::Female);
+    const auto& femalesFirstNames = peopleNames.femalesNames.firstNames;
 
-    const auto& femalesLastNames = languageToLastNamesMapping.at(language).at(Sex::Female);
+    const auto& femalesLastNames = peopleNames.malesNames.lastNames;
 
     const auto generatedFullName = Person::fullName(language, Sex::Female);
 
     ASSERT_TRUE(std::ranges::any_of(femalesFirstNames, [generatedFullName](const std::string& firstName)
-                                    { return generatedFullName.starts_with(firstName); }));
+                                    { return generatedFullName.find(firstName) != std::string::npos; }));
     ASSERT_TRUE(std::ranges::any_of(femalesLastNames, [generatedFullName](const std::string& lastName)
-                                    { return generatedFullName.ends_with(lastName); }));
+                                    { return generatedFullName.find(lastName) != std::string::npos; }));
 }
 
 INSTANTIATE_TEST_SUITE_P(TestPersonNamesByLanguages, PersonTest, ValuesIn(languages),
                          [](const TestParamInfo<Language>& info) { return generatedTestName.at(info.param); });
 
-TEST_F(PersonTest, shouldGenerateSex)
+TEST_F(PersonTest, shouldGenerateMiddleName)
 {
-    const std::vector<std::string> sexes{"Male", "Female"};
+    const auto generatedMiddleName = Person::middleName();
+
+    ASSERT_TRUE(std::ranges::any_of(allMiddleNames, [generatedMiddleName](const std::string& middleName)
+                                    { return middleName == generatedMiddleName; }));
+}
 
+TEST_F(PersonTest, shouldGeneratePrefix)
+{
+    const auto generatedPrefix = Person::prefix();
+
+    ASSERT_TRUE(std::ranges::any_of(allPrefixes, [generatedPrefix](const std::string& prefix)
+                                    { return prefix == generatedPrefix; }));
+}
+
+TEST_F(PersonTest, shouldGenerateMalePrefix)
+{
+    const auto generatedPrefix = Person::prefix(Sex::Male);
+
+    ASSERT_TRUE(std::ranges::any_of(malesPrefixes, [generatedPrefix](const std::string& prefix)
+                                    { return prefix == generatedPrefix; }));
+}
+
+TEST_F(PersonTest, shouldGenerateFemalePrefix)
+{
+    const auto generatedPrefix = Person::prefix(Sex::Female);
+
+    ASSERT_TRUE(std::ranges::any_of(femalesPrefixes, [generatedPrefix](const std::string& prefix)
+                                    { return prefix == generatedPrefix; }));
+}
+
+TEST_F(PersonTest, shouldGenerateSuffix)
+{
+    const auto generatedSuffix = Person::suffix();
+
+    ASSERT_TRUE(std::ranges::any_of(allSuffixes, [generatedSuffix](const std::string& suffix)
+                                    { return suffix == generatedSuffix; }));
+}
+
+TEST_F(PersonTest, shouldGenerateSex)
+{
     const auto generatedSex = Person::sex();
 
     ASSERT_TRUE(std::ranges::any_of(sexes, [generatedSex](const std::string& sex) { return sex == generatedSex; }));
@@ -297,29 +360,6 @@ TEST_F(PersonTest, shouldGenerateJobTitle)
                                     { return jobType == generatedJobType; }));
 }
 
-TEST_F(PersonTest, shouldGeneratePrefix)
-{
-    const auto generatedPrefix = Person::prefix();
-
-    ASSERT_TRUE(std::ranges::any_of(allPrefixes, [generatedPrefix](const std::string& prefix)
-                                    { return prefix == generatedPrefix; }));
-}
-
-TEST_F(PersonTest, shouldGenerateMalePrefix)
-{
-    const auto generatedPrefix = Person::prefix(Sex::Male);
-
-    ASSERT_EQ(generatedPrefix, malePrefix);
-}
-
-TEST_F(PersonTest, shouldGenerateFemalePrefix)
-{
-    const auto generatedPrefix = Person::prefix(Sex::Female);
-
-    ASSERT_TRUE(std::ranges::any_of(femalePrefixes, [generatedPrefix](const std::string& prefix)
-                                    { return prefix == generatedPrefix; }));
-}
-
 TEST_F(PersonTest, shouldGenerateHobby)
 {
     const auto generatedHobby = Person::hobby();
diff --git a/src/modules/person/data/NameFormats.h b/src/modules/person/data/NameFormats.h
new file mode 100644
index 000000000..46dc6e0f6
--- /dev/null
+++ b/src/modules/person/data/NameFormats.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+struct NameFormat
+{
+    std::string format;
+    unsigned weight;
+};
+
+using NameFormats = std::vector<NameFormat>;
+}
diff --git a/src/modules/person/data/PeopleNames.h b/src/modules/person/data/PeopleNames.h
index 5d56e5bc4..ea58fa5c2 100644
--- a/src/modules/person/data/PeopleNames.h
+++ b/src/modules/person/data/PeopleNames.h
@@ -8,6 +8,7 @@ struct PeopleNames
 {
     PersonNames malesNames;
     PersonNames femalesNames;
+    NameFormats nameFormats;
 };
 
 inline bool operator==(const PeopleNames& lhs, const PeopleNames& rhs)
diff --git a/src/modules/person/data/PersonNames.h b/src/modules/person/data/PersonNames.h
index 936a35ffa..eba3b3e98 100644
--- a/src/modules/person/data/PersonNames.h
+++ b/src/modules/person/data/PersonNames.h
@@ -7,15 +7,16 @@ namespace faker
 {
 struct PersonNames
 {
-    std::vector<std::string> prefixes;
     std::vector<std::string> firstNames;
+    std::vector<std::string> middleNames;
     std::vector<std::string> lastNames;
+    std::vector<std::string> prefixes;
     std::vector<std::string> suffixes;
 };
 
 inline bool operator==(const PersonNames& lhs, const PersonNames& rhs)
 {
-    return lhs.prefixes == rhs.prefixes && lhs.firstNames == rhs.firstNames && lhs.lastNames == rhs.lastNames &&
-           lhs.suffixes == rhs.suffixes;
+    return lhs.prefixes == rhs.prefixes && lhs.firstNames == rhs.firstNames && lhs.middleNames == rhs.middleNames &&
+           lhs.lastNames == rhs.lastNames && lhs.suffixes == rhs.suffixes;
 }
 }
diff --git a/src/modules/person/data/english/EnglishFirstNamesFemales.h b/src/modules/person/data/english/EnglishFirstNames.h
similarity index 50%
rename from src/modules/person/data/english/EnglishFirstNamesFemales.h
rename to src/modules/person/data/english/EnglishFirstNames.h
index a4396ce52..63c3a96e7 100644
--- a/src/modules/person/data/english/EnglishFirstNamesFemales.h
+++ b/src/modules/person/data/english/EnglishFirstNames.h
@@ -5,7 +5,73 @@
 
 namespace faker
 {
-const std::vector<std::string> englishFirstNamesFemales = {
+const std::vector<std::string> englishMalesFirstNames = {
+    "James",     "John",      "Robert",      "Michael",   "William",   "David",      "Richard",  "Charles",
+    "Joseph",    "Thomas",    "Christopher", "Daniel",    "Paul",      "Mark",       "Donald",   "George",
+    "Kenneth",   "Steven",    "Edward",      "Brian",     "Ronald",    "Anthony",    "Kevin",    "Jason",
+    "Matthew",   "Gary",      "Timothy",     "Jose",      "Larry",     "Jeffrey",    "Frank",    "Scott",
+    "Eric",      "Stephen",   "Andrew",      "Raymond",   "Gregory",   "Joshua",     "Jerry",    "Dennis",
+    "Walter",    "Patrick",   "Peter",       "Harold",    "Douglas",   "Henry",      "Carl",     "Arthur",
+    "Ryan",      "Roger",     "Joe",         "Juan",      "Jack",      "Albert",     "Jonathan", "Justin",
+    "Terry",     "Gerald",    "Keith",       "Samuel",    "Willie",    "Ralph",      "Lawrence", "Nicholas",
+    "Roy",       "Benjamin",  "Bruce",       "Brandon",   "Adam",      "Harry",      "Fred",     "Wayne",
+    "Billy",     "Steve",     "Louis",       "Jeremy",    "Aaron",     "Randy",      "Howard",   "Eugene",
+    "Carlos",    "Russell",   "Bobby",       "Victor",    "Martin",    "Ernest",     "Phillip",  "Todd",
+    "Jesse",     "Craig",     "Alan",        "Shawn",     "Clarence",  "Sean",       "Philip",   "Chris",
+    "Johnny",    "Earl",      "Jimmy",       "Antonio",   "Danny",     "Bryan",      "Tony",     "Luis",
+    "Mike",      "Stanley",   "Leonard",     "Nathan",    "Dale",      "Manuel",     "Rodney",   "Curtis",
+    "Norman",    "Allen",     "Marvin",      "Vincent",   "Glenn",     "Jeffery",    "Travis",   "Jeff",
+    "Chad",      "Jacob",     "Lee",         "Melvin",    "Alfred",    "Kyle",       "Francis",  "Bradley",
+    "Jesus",     "Herbert",   "Frederick",   "Ray",       "Joel",      "Edwin",      "Don",      "Eddie",
+    "Ricky",     "Troy",      "Randall",     "Barry",     "Alexander", "Bernard",    "Mario",    "Leroy",
+    "Francisco", "Marcus",    "Micheal",     "Theodore",  "Clifford",  "Miguel",     "Oscar",    "Jay",
+    "Jim",       "Tom",       "Calvin",      "Alex",      "Jon",       "Ronnie",     "Bill",     "Lloyd",
+    "Tommy",     "Leon",      "Derek",       "Warren",    "Darrell",   "Jerome",     "Floyd",    "Leo",
+    "Alvin",     "Tim",       "Wesley",      "Gordon",    "Dean",      "Greg",       "Jorge",    "Dustin",
+    "Pedro",     "Derrick",   "Dan",         "Lewis",     "Zachary",   "Corey",      "Herman",   "Maurice",
+    "Vernon",    "Roberto",   "Clyde",       "Glen",      "Hector",    "Shane",      "Ricardo",  "Sam",
+    "Rick",      "Lester",    "Brent",       "Ramon",     "Charlie",   "Tyler",      "Gilbert",  "Gene",
+    "Marc",      "Reginald",  "Ruben",       "Brett",     "Angel",     "Nathaniel",  "Rafael",   "Leslie",
+    "Edgar",     "Milton",    "Raul",        "Ben",       "Chester",   "Cecil",      "Duane",    "Franklin",
+    "Andre",     "Elmer",     "Brad",        "Gabriel",   "Ron",       "Mitchell",   "Roland",   "Arnold",
+    "Harvey",    "Jared",     "Adrian",      "Karl",      "Cory",      "Claude",     "Erik",     "Darryl",
+    "Jamie",     "Neil",      "Jessie",      "Christian", "Javier",    "Fernando",   "Clinton",  "Ted",
+    "Mathew",    "Tyrone",    "Darren",      "Lonnie",    "Lance",     "Cody",       "Julio",    "Kelly",
+    "Kurt",      "Allan",     "Nelson",      "Guy",       "Clayton",   "Hugh",       "Max",      "Dwayne",
+    "Dwight",    "Armando",   "Felix",       "Jimmie",    "Everett",   "Jordan",     "Ian",      "Wallace",
+    "Ken",       "Bob",       "Jaime",       "Casey",     "Alfredo",   "Alberto",    "Dave",     "Ivan",
+    "Johnnie",   "Sidney",    "Byron",       "Julian",    "Isaac",     "Morris",     "Clifton",  "Willard",
+    "Daryl",     "Ross",      "Virgil",      "Andy",      "Marshall",  "Salvador",   "Perry",    "Kirk",
+    "Sergio",    "Marion",    "Tracy",       "Seth",      "Kent",      "Terrance",   "Rene",     "Eduardo",
+    "Terrence",  "Enrique",   "Freddie",     "Wade",      "Austin",    "Stuart",     "Fredrick", "Arturo",
+    "Alejandro", "Jackie",    "Joey",        "Nick",      "Luther",    "Wendell",    "Jeremiah", "Evan",
+    "Julius",    "Dana",      "Donnie",      "Otis",      "Shannon",   "Trevor",     "Oliver",   "Luke",
+    "Homer",     "Gerard",    "Doug",        "Kenny",     "Hubert",    "Angelo",     "Shaun",    "Lyle",
+    "Matt",      "Lynn",      "Alfonso",     "Orlando",   "Rex",       "Carlton",    "Ernesto",  "Cameron",
+    "Neal",      "Pablo",     "Lorenzo",     "Omar",      "Wilbur",    "Blake",      "Grant",    "Horace",
+    "Roderick",  "Kerry",     "Abraham",     "Willis",    "Rickey",    "Jean",       "Ira",      "Andres",
+    "Cesar",     "Johnathan", "Malcolm",     "Rudolph",   "Damon",     "Kelvin",     "Rudy",     "Preston",
+    "Alton",     "Archie",    "Marco",       "Wm",        "Pete",      "Randolph",   "Garry",    "Geoffrey",
+    "Jonathon",  "Felipe",    "Bennie",      "Gerardo",   "Ed",        "Dominic",    "Robin",    "Loren",
+    "Delbert",   "Colin",     "Guillermo",   "Earnest",   "Lucas",     "Benny",      "Noel",     "Spencer",
+    "Rodolfo",   "Myron",     "Edmund",      "Garrett",   "Salvatore", "Cedric",     "Lowell",   "Gregg",
+    "Sherman",   "Wilson",    "Devin",       "Sylvester", "Kim",       "Roosevelt",  "Israel",   "Jermaine",
+    "Forrest",   "Wilbert",   "Leland",      "Simon",     "Guadalupe", "Clark",      "Irving",   "Carroll",
+    "Bryant",    "Owen",      "Rufus",       "Woodrow",   "Sammy",     "Kristopher", "Mack",     "Levi",
+    "Marcos",    "Gustavo",   "Jake",        "Lionel",    "Marty",     "Taylor",     "Ellis",    "Dallas",
+    "Gilberto",  "Clint",     "Nicolas",     "Laurence",  "Ismael",    "Orville",    "Drew",     "Jody",
+    "Ervin",     "Dewey",     "Al",          "Wilfred",   "Josh",      "Hugo",       "Ignacio",  "Caleb",
+    "Tomas",     "Sheldon",   "Erick",       "Frankie",   "Stewart",   "Doyle",      "Darrel",   "Rogelio",
+    "Terence",   "Santiago",  "Alonzo",      "Elias",     "Bert",      "Elbert",     "Ramiro",   "Conrad",
+    "Pat",       "Noah",      "Grady",       "Phil",      "Cornelius", "Lamar",      "Rolando",  "Clay",
+    "Percy",     "Dexter",    "Bradford",    "Merle",     "Darin",     "Amos",       "Terrell",  "Moses",
+    "Irvin",     "Saul",      "Roman",       "Darnell",   "Randal",    "Tommie",     "Timmy",    "Darrin",
+    "Winston",   "Brendan",   "Toby",        "Van",       "Abel",      "Dominick",   "Boyd",     "Courtney",
+    "Jan",       "Emilio",    "Elijah",      "Cary",      "Domingo",   "Santos",     "Aubrey",   "Emmett",
+    "Marlon",    "Emanuel",   "Jerald",      "Edmond",
+};
+
+const std::vector<std::string> englishFemalesFirstNames = {
     "Mary",       "Patricia",   "Linda",     "Barbara",   "Elizabeth", "Jennifer",   "Maria",     "Susan",
     "Margaret",   "Dorothy",    "Lisa",      "Nancy",     "Karen",     "Betty",      "Helen",     "Sandra",
     "Donna",      "Carol",      "Ruth",      "Sharon",    "Michelle",  "Laura",      "Sarah",     "Kimberly",
diff --git a/src/modules/person/data/english/EnglishFirstNamesMales.h b/src/modules/person/data/english/EnglishFirstNamesMales.h
deleted file mode 100644
index 63ed2277d..000000000
--- a/src/modules/person/data/english/EnglishFirstNamesMales.h
+++ /dev/null
@@ -1,73 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> englishFirstNamesMales = {
-    "James",     "John",      "Robert",      "Michael",   "William",   "David",      "Richard",  "Charles",
-    "Joseph",    "Thomas",    "Christopher", "Daniel",    "Paul",      "Mark",       "Donald",   "George",
-    "Kenneth",   "Steven",    "Edward",      "Brian",     "Ronald",    "Anthony",    "Kevin",    "Jason",
-    "Matthew",   "Gary",      "Timothy",     "Jose",      "Larry",     "Jeffrey",    "Frank",    "Scott",
-    "Eric",      "Stephen",   "Andrew",      "Raymond",   "Gregory",   "Joshua",     "Jerry",    "Dennis",
-    "Walter",    "Patrick",   "Peter",       "Harold",    "Douglas",   "Henry",      "Carl",     "Arthur",
-    "Ryan",      "Roger",     "Joe",         "Juan",      "Jack",      "Albert",     "Jonathan", "Justin",
-    "Terry",     "Gerald",    "Keith",       "Samuel",    "Willie",    "Ralph",      "Lawrence", "Nicholas",
-    "Roy",       "Benjamin",  "Bruce",       "Brandon",   "Adam",      "Harry",      "Fred",     "Wayne",
-    "Billy",     "Steve",     "Louis",       "Jeremy",    "Aaron",     "Randy",      "Howard",   "Eugene",
-    "Carlos",    "Russell",   "Bobby",       "Victor",    "Martin",    "Ernest",     "Phillip",  "Todd",
-    "Jesse",     "Craig",     "Alan",        "Shawn",     "Clarence",  "Sean",       "Philip",   "Chris",
-    "Johnny",    "Earl",      "Jimmy",       "Antonio",   "Danny",     "Bryan",      "Tony",     "Luis",
-    "Mike",      "Stanley",   "Leonard",     "Nathan",    "Dale",      "Manuel",     "Rodney",   "Curtis",
-    "Norman",    "Allen",     "Marvin",      "Vincent",   "Glenn",     "Jeffery",    "Travis",   "Jeff",
-    "Chad",      "Jacob",     "Lee",         "Melvin",    "Alfred",    "Kyle",       "Francis",  "Bradley",
-    "Jesus",     "Herbert",   "Frederick",   "Ray",       "Joel",      "Edwin",      "Don",      "Eddie",
-    "Ricky",     "Troy",      "Randall",     "Barry",     "Alexander", "Bernard",    "Mario",    "Leroy",
-    "Francisco", "Marcus",    "Micheal",     "Theodore",  "Clifford",  "Miguel",     "Oscar",    "Jay",
-    "Jim",       "Tom",       "Calvin",      "Alex",      "Jon",       "Ronnie",     "Bill",     "Lloyd",
-    "Tommy",     "Leon",      "Derek",       "Warren",    "Darrell",   "Jerome",     "Floyd",    "Leo",
-    "Alvin",     "Tim",       "Wesley",      "Gordon",    "Dean",      "Greg",       "Jorge",    "Dustin",
-    "Pedro",     "Derrick",   "Dan",         "Lewis",     "Zachary",   "Corey",      "Herman",   "Maurice",
-    "Vernon",    "Roberto",   "Clyde",       "Glen",      "Hector",    "Shane",      "Ricardo",  "Sam",
-    "Rick",      "Lester",    "Brent",       "Ramon",     "Charlie",   "Tyler",      "Gilbert",  "Gene",
-    "Marc",      "Reginald",  "Ruben",       "Brett",     "Angel",     "Nathaniel",  "Rafael",   "Leslie",
-    "Edgar",     "Milton",    "Raul",        "Ben",       "Chester",   "Cecil",      "Duane",    "Franklin",
-    "Andre",     "Elmer",     "Brad",        "Gabriel",   "Ron",       "Mitchell",   "Roland",   "Arnold",
-    "Harvey",    "Jared",     "Adrian",      "Karl",      "Cory",      "Claude",     "Erik",     "Darryl",
-    "Jamie",     "Neil",      "Jessie",      "Christian", "Javier",    "Fernando",   "Clinton",  "Ted",
-    "Mathew",    "Tyrone",    "Darren",      "Lonnie",    "Lance",     "Cody",       "Julio",    "Kelly",
-    "Kurt",      "Allan",     "Nelson",      "Guy",       "Clayton",   "Hugh",       "Max",      "Dwayne",
-    "Dwight",    "Armando",   "Felix",       "Jimmie",    "Everett",   "Jordan",     "Ian",      "Wallace",
-    "Ken",       "Bob",       "Jaime",       "Casey",     "Alfredo",   "Alberto",    "Dave",     "Ivan",
-    "Johnnie",   "Sidney",    "Byron",       "Julian",    "Isaac",     "Morris",     "Clifton",  "Willard",
-    "Daryl",     "Ross",      "Virgil",      "Andy",      "Marshall",  "Salvador",   "Perry",    "Kirk",
-    "Sergio",    "Marion",    "Tracy",       "Seth",      "Kent",      "Terrance",   "Rene",     "Eduardo",
-    "Terrence",  "Enrique",   "Freddie",     "Wade",      "Austin",    "Stuart",     "Fredrick", "Arturo",
-    "Alejandro", "Jackie",    "Joey",        "Nick",      "Luther",    "Wendell",    "Jeremiah", "Evan",
-    "Julius",    "Dana",      "Donnie",      "Otis",      "Shannon",   "Trevor",     "Oliver",   "Luke",
-    "Homer",     "Gerard",    "Doug",        "Kenny",     "Hubert",    "Angelo",     "Shaun",    "Lyle",
-    "Matt",      "Lynn",      "Alfonso",     "Orlando",   "Rex",       "Carlton",    "Ernesto",  "Cameron",
-    "Neal",      "Pablo",     "Lorenzo",     "Omar",      "Wilbur",    "Blake",      "Grant",    "Horace",
-    "Roderick",  "Kerry",     "Abraham",     "Willis",    "Rickey",    "Jean",       "Ira",      "Andres",
-    "Cesar",     "Johnathan", "Malcolm",     "Rudolph",   "Damon",     "Kelvin",     "Rudy",     "Preston",
-    "Alton",     "Archie",    "Marco",       "Wm",        "Pete",      "Randolph",   "Garry",    "Geoffrey",
-    "Jonathon",  "Felipe",    "Bennie",      "Gerardo",   "Ed",        "Dominic",    "Robin",    "Loren",
-    "Delbert",   "Colin",     "Guillermo",   "Earnest",   "Lucas",     "Benny",      "Noel",     "Spencer",
-    "Rodolfo",   "Myron",     "Edmund",      "Garrett",   "Salvatore", "Cedric",     "Lowell",   "Gregg",
-    "Sherman",   "Wilson",    "Devin",       "Sylvester", "Kim",       "Roosevelt",  "Israel",   "Jermaine",
-    "Forrest",   "Wilbert",   "Leland",      "Simon",     "Guadalupe", "Clark",      "Irving",   "Carroll",
-    "Bryant",    "Owen",      "Rufus",       "Woodrow",   "Sammy",     "Kristopher", "Mack",     "Levi",
-    "Marcos",    "Gustavo",   "Jake",        "Lionel",    "Marty",     "Taylor",     "Ellis",    "Dallas",
-    "Gilberto",  "Clint",     "Nicolas",     "Laurence",  "Ismael",    "Orville",    "Drew",     "Jody",
-    "Ervin",     "Dewey",     "Al",          "Wilfred",   "Josh",      "Hugo",       "Ignacio",  "Caleb",
-    "Tomas",     "Sheldon",   "Erick",       "Frankie",   "Stewart",   "Doyle",      "Darrel",   "Rogelio",
-    "Terence",   "Santiago",  "Alonzo",      "Elias",     "Bert",      "Elbert",     "Ramiro",   "Conrad",
-    "Pat",       "Noah",      "Grady",       "Phil",      "Cornelius", "Lamar",      "Rolando",  "Clay",
-    "Percy",     "Dexter",    "Bradford",    "Merle",     "Darin",     "Amos",       "Terrell",  "Moses",
-    "Irvin",     "Saul",      "Roman",       "Darnell",   "Randal",    "Tommie",     "Timmy",    "Darrin",
-    "Winston",   "Brendan",   "Toby",        "Van",       "Abel",      "Dominick",   "Boyd",     "Courtney",
-    "Jan",       "Emilio",    "Elijah",      "Cary",      "Domingo",   "Santos",     "Aubrey",   "Emmett",
-    "Marlon",    "Emanuel",   "Jerald",      "Edmond",
-};
-}
diff --git a/src/modules/person/data/english/EnglishPeopleNames.h b/src/modules/person/data/english/EnglishPeopleNames.h
new file mode 100644
index 000000000..d6b85d230
--- /dev/null
+++ b/src/modules/person/data/english/EnglishPeopleNames.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "EnglishFirstNames.h"
+#include "EnglishLastNames.h"
+#include "EnglishPrefixes.h"
+#include "EnglishSuffixes.h"
+
+namespace faker
+{
+const NameFormats englishPersonNameFormats{{{"{firstName} {lastName}", 49},
+                                            {"{prefix} {firstName} {lastName}", 7},
+                                            {"{firstName} {lastName} {suffix}", 7},
+                                            {"{prefix} {firstName} {lastName} {suffix}", 1}}};
+
+const PeopleNames englishPeopleNames{
+    {englishMalesFirstNames, {}, englishLastNames, englishMalesPrefixes, englishSuffixes},
+    {englishFemalesFirstNames, {}, englishLastNames, englishFemalesPrefixes, englishSuffixes},
+    englishPersonNameFormats};
+}
diff --git a/src/modules/person/data/english/EnglishPrefixes.h b/src/modules/person/data/english/EnglishPrefixes.h
index b048c6e2f..59be877ef 100644
--- a/src/modules/person/data/english/EnglishPrefixes.h
+++ b/src/modules/person/data/english/EnglishPrefixes.h
@@ -5,7 +5,7 @@
 
 namespace faker
 {
-const std::string englishMalePrefixes{"Mr."};
+const std::vector<std::string> englishMalesPrefixes{"Mr.", "Dr."};
 
-const std::vector<std::string> englishFemalePrefixes{"Ms.", "Miss"};
+const std::vector<std::string> englishFemalesPrefixes{"Mrs.", "Ms.", "Miss", "Dr."};
 }
diff --git a/src/modules/person/data/english/EnglishSuffixes.h b/src/modules/person/data/english/EnglishSuffixes.h
new file mode 100644
index 000000000..3621c95bb
--- /dev/null
+++ b/src/modules/person/data/english/EnglishSuffixes.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> englishSuffixes{"Jr.", "Sr.", "I", "II", "III", "IV", "V", "MD", "DDS", "PhD", "DVM"};
+}
diff --git a/src/modules/person/data/finnish/FinnishFirstNames.h b/src/modules/person/data/finnish/FinnishFirstNames.h
new file mode 100644
index 000000000..b98a0d953
--- /dev/null
+++ b/src/modules/person/data/finnish/FinnishFirstNames.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> finnishMalesFirstNames = {
+    "Leo",   "Elias", "Eino",   "Väinö",   "Onni",  "Leevi",  "Niilo",   "Oliver", "Eetu",
+    "Noel",  "Eeli",  "Veeti",  "Mikael",  "Joel",  "Daniel", "Andreas", "Edvin",  "Elia",
+    "Eliel", "Felix", "Niila",  "Nikolas", "Oskar", "Oula",   "Petja",   "Petrus", "Rene",
+    "Teo",   "Venni", "Viktor", "Aarre",   "Aarni", "Ahti",   "Aarne",   "Kuura",  "Kuutti",
+    "Oras",  "Otso",  "Pyry",   "Tammi",   "Terho", "Touko",  "Ukko",    "Vesa",   "Visa",
+};
+
+const std::vector<std::string> finnishFemalesFirstNames = {
+    "Aino",  "Eevi",   "Emma",   "Sofia",  "Aada",     "Ella",   "Lilja",  "Helmi",   "Elli",    "Enni",
+    "Venla", "Olivia", "Pihla",  "Isla",   "Adele",    "Aida",   "Bertta", "Cecilia", "Daniela", "Elle",
+    "Erin",  "Fiona",  "Iita",   "Inna",   "Jasmiina", "Lila",   "Luna",   "Malla",   "Meea",    "Minka",
+    "Minni", "Neela",  "Selina", "Unna",   "Aamu",     "Aava",   "Aura",   "Heini",   "Hilla",   "Hilja",
+    "Ilma",  "Ilta",   "Iiris",  "Jasmin", "Kaisla",   "Kaneli",
+};
+}
diff --git a/src/modules/person/data/finnish/FinnishFirstNamesFemales.h b/src/modules/person/data/finnish/FinnishFirstNamesFemales.h
deleted file mode 100644
index b2ce26cd4..000000000
--- a/src/modules/person/data/finnish/FinnishFirstNamesFemales.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> finnishFirstNamesFemales = {
-    "Aino",  "Eevi",   "Emma",   "Sofia",  "Aada",     "Ella",   "Lilja",  "Helmi",   "Elli",    "Enni",
-    "Venla", "Olivia", "Pihla",  "Isla",   "Adele",    "Aida",   "Bertta", "Cecilia", "Daniela", "Elle",
-    "Erin",  "Fiona",  "Iita",   "Inna",   "Jasmiina", "Lila",   "Luna",   "Malla",   "Meea",    "Minka",
-    "Minni", "Neela",  "Selina", "Unna",   "Aamu",     "Aava",   "Aura",   "Heini",   "Hilla",   "Hilja",
-    "Ilma",  "Ilta",   "Iiris",  "Jasmin", "Kaisla",   "Kaneli",
-};
-}
\ No newline at end of file
diff --git a/src/modules/person/data/finnish/FinnishFirstNamesMales.h b/src/modules/person/data/finnish/FinnishFirstNamesMales.h
deleted file mode 100644
index f9fd4942d..000000000
--- a/src/modules/person/data/finnish/FinnishFirstNamesMales.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> finnishFirstNamesMales = {
-    "Leo",   "Elias", "Eino",   "Väinö",   "Onni",  "Leevi",  "Niilo",   "Oliver", "Eetu",
-    "Noel",  "Eeli",  "Veeti",  "Mikael",  "Joel",  "Daniel", "Andreas", "Edvin",  "Elia",
-    "Eliel", "Felix", "Niila",  "Nikolas", "Oskar", "Oula",   "Petja",   "Petrus", "Rene",
-    "Teo",   "Venni", "Viktor", "Aarre",   "Aarni", "Ahti",   "Aarne",   "Kuura",  "Kuutti",
-    "Oras",  "Otso",  "Pyry",   "Tammi",   "Terho", "Touko",  "Ukko",    "Vesa",   "Visa",
-};
-}
\ No newline at end of file
diff --git a/src/modules/person/data/finnish/FinnishLastNames.h b/src/modules/person/data/finnish/FinnishLastNames.h
index bbe91cd38..550dc4207 100644
--- a/src/modules/person/data/finnish/FinnishLastNames.h
+++ b/src/modules/person/data/finnish/FinnishLastNames.h
@@ -13,4 +13,4 @@ const std::vector<std::string> finnishLastNames = {
     "Miettinen", "Savolainen", "Nurmi",      "Niemelä",     "Hakkarainen", "Laakso",   "Kinnunen",   "Mattila",
     "Salmi",     "Pekkanen",   "Leinonen",   "Ojala",       "Kankaanpää",  "Heikkilä",
 };
-}
\ No newline at end of file
+}
diff --git a/src/modules/person/data/finnish/FinnishPeopleNames.h b/src/modules/person/data/finnish/FinnishPeopleNames.h
new file mode 100644
index 000000000..b3a502ab8
--- /dev/null
+++ b/src/modules/person/data/finnish/FinnishPeopleNames.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "FinnishFirstNames.h"
+#include "FinnishLastNames.h"
+
+namespace faker
+{
+const NameFormats finnishPersonNameFormats{{"{firstName} {lastName}", 1}};
+
+const PeopleNames finnishPeopleNames{{finnishMalesFirstNames, {}, finnishLastNames, {}, {}},
+                                     {finnishFemalesFirstNames, {}, finnishLastNames, {}, {}},
+                                     finnishPersonNameFormats};
+}
diff --git a/src/modules/person/data/finnish/FinnishPrefixes.h b/src/modules/person/data/finnish/FinnishPrefixes.h
deleted file mode 100644
index b048c6e2f..000000000
--- a/src/modules/person/data/finnish/FinnishPrefixes.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::string englishMalePrefixes{"Mr."};
-
-const std::vector<std::string> englishFemalePrefixes{"Ms.", "Miss"};
-}
diff --git a/src/modules/person/data/french/FrenchFirstNamesMales.h b/src/modules/person/data/french/FrenchFirstNames.h
similarity index 51%
rename from src/modules/person/data/french/FrenchFirstNamesMales.h
rename to src/modules/person/data/french/FrenchFirstNames.h
index 444397028..63df0888c 100644
--- a/src/modules/person/data/french/FrenchFirstNamesMales.h
+++ b/src/modules/person/data/french/FrenchFirstNames.h
@@ -5,7 +5,7 @@
 
 namespace faker
 {
-const std::vector<std::string> frenchFirstNamesMales = {
+const std::vector<std::string> frenchMalesFirstNames = {
     "Aaron",       "Abdon",      "Abel",        "Abélard",    "Abelin",    "Abondance",    "Abraham",    "Absalon",
     "Acace",       "Achaire",    "Achille",     "Adalard",    "Adalbald",  "Adalbéron",    "Adalbert",   "Adalric",
     "Adam",        "Adegrin",    "Adel",        "Adelin",     "Adelphe",   "Adenet",       "Adéodat",    "Adhémar",
@@ -68,4 +68,63 @@ const std::vector<std::string> frenchFirstNamesMales = {
     "Ulysse",      "Urbain",     "Valentin",    "Valère",     "Valéry",    "Venance",      "Venceslas",  "Vianney",
     "Victor",      "Victorien",  "Victorin",    "Vigile",     "Vincent",   "Vital",        "Vivien",     "Waleran",
     "Wandrille",   "Xavier",     "Xénophon",    "Yves",       "Yoann",     "Zacharie",     "Zaché",      "Zéphirin"};
+
+const std::vector<std::string> frenchFemalesFirstNames = {
+    "Abdonie",    "Abeline",    "Abigaelle",  "Abigaïl",     "Acacie",     "Acanthe",      "Adalbaude",    "Adalsinde",
+    "Adegrine",   "Adélaïde",   "Adèle",      "Adélie",      "Adeline",    "Adeltrude",    "Adolphie",     "Adonise",
+    "Adrastée",   "Adrehilde",  "Adrienne",   "Agathe",      "Agilberte",  "Aglaé",        "Agnane",       "Agneflète",
+    "Agnès",      "Agrippine",  "Aimée",      "Alaine",      "Alaïs",      "Albane",       "Albérade",     "Alberte",
+    "Alcidie",    "Alcine",     "Alcyone",    "Aldegonde",   "Aleth",      "Alexandrine",  "Alexanne",     "Alexine",
+    "Alice",      "Aliénor",    "Aliette",    "Aline",       "Alix",       "Alizé",        "Aloïse",       "Aloyse",
+    "Alphonsine", "Althée",     "Amaliane",   "Amalthée",    "Amande",     "Amandine",     "Amante",       "Amarande",
+    "Amaranthe",  "Amaryllis",  "Ambre",      "Ambroisie",   "Améliane",   "Amélie",       "Ameline",      "Améthyste",
+    "Aminte",     "Anaëlle",    "Anaïs",      "Anastasie",   "Anatolie",   "Anceline",     "Andrée",       "Anémone",
+    "Angadrême",  "Angèle",     "Angeline",   "Angélina",    "Angélique",  "Angilberte",   "Anicée",       "Anicette",
+    "Annabelle",  "Anne",       "Annette",    "Annonciade",  "Ansberte",   "Anstrudie",    "Anthelmette",  "Antigone",
+    "Antoinette", "Antonine",   "Aphélie",    "Apolline",    "Aquiline",   "Arabelle",     "Arcadie",      "Archange",
+    "Argine",     "Ariane",     "Aricie",     "Ariel",       "Arielle",    "Arlette",      "Armance",      "Armande",
+    "Armandine",  "Armeline",   "Armide",     "Armelle",     "Armine",     "Arnaude",      "Arsènie",      "Arsinoé",
+    "Artémis",    "Arthurine",  "Asceline",   "Ascension",   "Assomption", "Astarté",      "Astérie",      "Astrée",
+    "Astride",    "Athalie",    "Athanasie",  "Athénaïs",    "Athina",     "Aube",         "Aubertine",    "Aude",
+    "Audeline",   "Audrey",     "Augustine",  "Aure",        "Aurélie",    "Aurélienne",   "Aurelle",      "Auriane",
+    "Aurore",     "Auxane",     "Aveline",    "Avigaëlle",   "Avoye",      "Axeline",      "Axelle",       "Aymardine",
+    "Aymonde",    "Azalée",     "Azélie",     "Azeline",     "Barbe",      "Basilisse",    "Bathilde",     "Béatrice",
+    "Bénédicte",  "Bérangère",  "Bernadette", "Berthe",      "Bertille",   "Betty",        "Beuve",        "Blanche",
+    "Blandine",   "Brigitte",   "Brunehaut",  "Brunehilde",  "Camille",    "Capucine",     "Carine",       "Caroline",
+    "Cassandre",  "Catherine",  "Cécile",     "Céleste",     "Célestine",  "Céline",       "Chantal",      "Charlaine",
+    "Charline",   "Charlotte",  "Chloé",      "Christelle",  "Christiane", "Christine",    "Claire",       "Clara",
+    "Claude",     "Claudine",   "Clarisse",   "Clélie",      "Clémence",   "Clémentine",   "Clio",         "Clotilde",
+    "Coline",     "Conception", "Constance",  "Coralie",     "Coraline",   "Corentine",    "Corinne",      "Cyrielle",
+    "Danielle",   "Daphné",     "Débora",     "Delphine",    "Denise",     "Diane",        "Dieudonnée",   "Dominique",
+    "Doriane",    "Dorine",     "Dorothée",   "Douce",       "Édith",      "Edmée",        "Éléonore",     "Éliane",
+    "Élia",       "Élisabeth",  "Élise",      "Ella",        "Élodie",     "Éloïse",       "Elsa",         "Émeline",
+    "Émérance",   "Émérencie",  "Émilie",     "Emma",        "Emmanuelle", "Emmelie",      "Ernestine",    "Esther",
+    "Estelle",    "Eudoxie",    "Eugénie",    "Eulalie",     "Euphrasie",  "Eusébie",      "Évangéline",   "Eva",
+    "Ève",        "Évelyne",    "Fanny",      "Fantine",     "Faustine",   "Félicie",      "Frédérique",   "Flavie",
+    "Fleur",      "Flore",      "Florence",   "Florie",      "Fortunée",   "France",       "Francette",    "Francia",
+    "Françoise",  "Francine",   "Gabrielle",  "Gaëlle",      "Garance",    "Geneviève",    "Georgette",    "Gerberge",
+    "Germaine",   "Gertrude",   "Gisèle",     "Guenièvre",   "Guilhemine", "Guillemette",  "Gustavine",    "Gwenaëlle",
+    "Hélène",     "Héloïse",    "Henriette",  "Hermine",     "Hippolyte",  "Honorine",     "Hortense",     "Huguette",
+    "Inès",       "Irène",      "Irina",      "Iris",        "Isabeau",    "Isabelle",     "Iseult",       "Ismérie",
+    "Jacinthe",   "Jacqueline", "Jade",       "Janine",      "Jeanne",     "Jeanne d’Arc", "Jehanne",      "Jocelyne",
+    "Joëlle",     "Joséphine",  "Judith",     "Julia",       "Julie",      "Juliette",     "Justine",      "Laura",
+    "Laurane",    "Laure",      "Laureline",  "Laurence",    "Laurène",    "Lauriane",     "Laurine",      "Léa",
+    "Léna",       "Léopoldine", "Léonie",     "Léonne",      "Lorraine",   "Lucie",        "Lucienne",     "Lucille",
+    "Ludivine",   "Lydie",      "Mégane",     "Madeleine",   "Magali",     "Maguelone",    "Mahaut",       "Mallaury",
+    "Manon",      "Marceline",  "Margot",     "Marguerite",  "Marianne",   "Marie",        "Marine",       "Marion",
+    "Marlène",    "Marthe",     "Martine",    "Mathilde",    "Maud",       "Maureen",      "Mauricette",   "Maxellende",
+    "Maxime",     "Mélanie",    "Mélissa",    "Mélissandre", "Mélisande",  "Mélodie",      "Michèle",      "Mireille",
+    "Miriam",     "Moïsette",   "Monique",    "Morgane",     "Muriel",     "Mylène",       "Nadège",       "Nadine",
+    "Nathalie",   "Nicole",     "Nine",       "Noëlle",      "Noémie",     "Océane",       "Odette",       "Odile",
+    "Olive",      "Olympe",     "Ombline",    "Ophélie",     "Oriande",    "Oriane",       "Orlane",       "Ozanne",
+    "Pascale",    "Paule",      "Paulette",   "Pauline",     "Priscille",  "Pécine",       "Pélagie",      "Pénélope",
+    "Perrine",    "Pétronille", "Philippine", "Philomène",   "Philothée",  "Primerose",    "Prudence",     "Pulchérie",
+    "Quentine",   "Quiéta",     "Quintia",    "Rachel",      "Raphaëlle",  "Raymonde",     "Rebecca",      "Régine",
+    "Reine",      "Réjeanne",   "Renée",      "Rita",        "Rolande",    "Romane",       "Rosalie",      "Rose",
+    "Roseline",   "Sabine",     "Salomé",     "Sandra",      "Sandrine",   "Sarah",        "Scholastique", "Ségolène",
+    "Séverine",   "Sibylle",    "Simone",     "Sixtine",     "Solange",    "Soline",       "Sophie",       "Stéphanie",
+    "Suzanne",    "Suzon",      "Sylviane",   "Sylvie",      "Swassane",   "Tatiana",      "Thaïs",        "Théodora",
+    "Thérèse",    "Tiphaine",   "Ursule",     "Valentine",   "Valérie",    "Véronique",    "Victoire",     "Vinciane",
+    "Violette",   "Virginie",   "Viviane",    "Xavière",     "Yolande",    "Ysaline",      "Yseult",       "Yvette",
+    "Yvonne",     "Zoé",        "Zoéva"};
 }
diff --git a/src/modules/person/data/french/FrenchFirstNamesFemales.h b/src/modules/person/data/french/FrenchFirstNamesFemales.h
deleted file mode 100644
index f7feda0d2..000000000
--- a/src/modules/person/data/french/FrenchFirstNamesFemales.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> frenchFirstNamesFemales = {
-    "Abdonie",    "Abeline",    "Abigaelle",  "Abigaïl",     "Acacie",     "Acanthe",      "Adalbaude",    "Adalsinde",
-    "Adegrine",   "Adélaïde",   "Adèle",      "Adélie",      "Adeline",    "Adeltrude",    "Adolphie",     "Adonise",
-    "Adrastée",   "Adrehilde",  "Adrienne",   "Agathe",      "Agilberte",  "Aglaé",        "Agnane",       "Agneflète",
-    "Agnès",      "Agrippine",  "Aimée",      "Alaine",      "Alaïs",      "Albane",       "Albérade",     "Alberte",
-    "Alcidie",    "Alcine",     "Alcyone",    "Aldegonde",   "Aleth",      "Alexandrine",  "Alexanne",     "Alexine",
-    "Alice",      "Aliénor",    "Aliette",    "Aline",       "Alix",       "Alizé",        "Aloïse",       "Aloyse",
-    "Alphonsine", "Althée",     "Amaliane",   "Amalthée",    "Amande",     "Amandine",     "Amante",       "Amarande",
-    "Amaranthe",  "Amaryllis",  "Ambre",      "Ambroisie",   "Améliane",   "Amélie",       "Ameline",      "Améthyste",
-    "Aminte",     "Anaëlle",    "Anaïs",      "Anastasie",   "Anatolie",   "Anceline",     "Andrée",       "Anémone",
-    "Angadrême",  "Angèle",     "Angeline",   "Angélina",    "Angélique",  "Angilberte",   "Anicée",       "Anicette",
-    "Annabelle",  "Anne",       "Annette",    "Annonciade",  "Ansberte",   "Anstrudie",    "Anthelmette",  "Antigone",
-    "Antoinette", "Antonine",   "Aphélie",    "Apolline",    "Aquiline",   "Arabelle",     "Arcadie",      "Archange",
-    "Argine",     "Ariane",     "Aricie",     "Ariel",       "Arielle",    "Arlette",      "Armance",      "Armande",
-    "Armandine",  "Armeline",   "Armide",     "Armelle",     "Armine",     "Arnaude",      "Arsènie",      "Arsinoé",
-    "Artémis",    "Arthurine",  "Asceline",   "Ascension",   "Assomption", "Astarté",      "Astérie",      "Astrée",
-    "Astride",    "Athalie",    "Athanasie",  "Athénaïs",    "Athina",     "Aube",         "Aubertine",    "Aude",
-    "Audeline",   "Audrey",     "Augustine",  "Aure",        "Aurélie",    "Aurélienne",   "Aurelle",      "Auriane",
-    "Aurore",     "Auxane",     "Aveline",    "Avigaëlle",   "Avoye",      "Axeline",      "Axelle",       "Aymardine",
-    "Aymonde",    "Azalée",     "Azélie",     "Azeline",     "Barbe",      "Basilisse",    "Bathilde",     "Béatrice",
-    "Bénédicte",  "Bérangère",  "Bernadette", "Berthe",      "Bertille",   "Betty",        "Beuve",        "Blanche",
-    "Blandine",   "Brigitte",   "Brunehaut",  "Brunehilde",  "Camille",    "Capucine",     "Carine",       "Caroline",
-    "Cassandre",  "Catherine",  "Cécile",     "Céleste",     "Célestine",  "Céline",       "Chantal",      "Charlaine",
-    "Charline",   "Charlotte",  "Chloé",      "Christelle",  "Christiane", "Christine",    "Claire",       "Clara",
-    "Claude",     "Claudine",   "Clarisse",   "Clélie",      "Clémence",   "Clémentine",   "Clio",         "Clotilde",
-    "Coline",     "Conception", "Constance",  "Coralie",     "Coraline",   "Corentine",    "Corinne",      "Cyrielle",
-    "Danielle",   "Daphné",     "Débora",     "Delphine",    "Denise",     "Diane",        "Dieudonnée",   "Dominique",
-    "Doriane",    "Dorine",     "Dorothée",   "Douce",       "Édith",      "Edmée",        "Éléonore",     "Éliane",
-    "Élia",       "Élisabeth",  "Élise",      "Ella",        "Élodie",     "Éloïse",       "Elsa",         "Émeline",
-    "Émérance",   "Émérencie",  "Émilie",     "Emma",        "Emmanuelle", "Emmelie",      "Ernestine",    "Esther",
-    "Estelle",    "Eudoxie",    "Eugénie",    "Eulalie",     "Euphrasie",  "Eusébie",      "Évangéline",   "Eva",
-    "Ève",        "Évelyne",    "Fanny",      "Fantine",     "Faustine",   "Félicie",      "Frédérique",   "Flavie",
-    "Fleur",      "Flore",      "Florence",   "Florie",      "Fortunée",   "France",       "Francette",    "Francia",
-    "Françoise",  "Francine",   "Gabrielle",  "Gaëlle",      "Garance",    "Geneviève",    "Georgette",    "Gerberge",
-    "Germaine",   "Gertrude",   "Gisèle",     "Guenièvre",   "Guilhemine", "Guillemette",  "Gustavine",    "Gwenaëlle",
-    "Hélène",     "Héloïse",    "Henriette",  "Hermine",     "Hippolyte",  "Honorine",     "Hortense",     "Huguette",
-    "Inès",       "Irène",      "Irina",      "Iris",        "Isabeau",    "Isabelle",     "Iseult",       "Ismérie",
-    "Jacinthe",   "Jacqueline", "Jade",       "Janine",      "Jeanne",     "Jeanne d’Arc", "Jehanne",      "Jocelyne",
-    "Joëlle",     "Joséphine",  "Judith",     "Julia",       "Julie",      "Juliette",     "Justine",      "Laura",
-    "Laurane",    "Laure",      "Laureline",  "Laurence",    "Laurène",    "Lauriane",     "Laurine",      "Léa",
-    "Léna",       "Léopoldine", "Léonie",     "Léonne",      "Lorraine",   "Lucie",        "Lucienne",     "Lucille",
-    "Ludivine",   "Lydie",      "Mégane",     "Madeleine",   "Magali",     "Maguelone",    "Mahaut",       "Mallaury",
-    "Manon",      "Marceline",  "Margot",     "Marguerite",  "Marianne",   "Marie",        "Marine",       "Marion",
-    "Marlène",    "Marthe",     "Martine",    "Mathilde",    "Maud",       "Maureen",      "Mauricette",   "Maxellende",
-    "Maxime",     "Mélanie",    "Mélissa",    "Mélissandre", "Mélisande",  "Mélodie",      "Michèle",      "Mireille",
-    "Miriam",     "Moïsette",   "Monique",    "Morgane",     "Muriel",     "Mylène",       "Nadège",       "Nadine",
-    "Nathalie",   "Nicole",     "Nine",       "Noëlle",      "Noémie",     "Océane",       "Odette",       "Odile",
-    "Olive",      "Olympe",     "Ombline",    "Ophélie",     "Oriande",    "Oriane",       "Orlane",       "Ozanne",
-    "Pascale",    "Paule",      "Paulette",   "Pauline",     "Priscille",  "Pécine",       "Pélagie",      "Pénélope",
-    "Perrine",    "Pétronille", "Philippine", "Philomène",   "Philothée",  "Primerose",    "Prudence",     "Pulchérie",
-    "Quentine",   "Quiéta",     "Quintia",    "Rachel",      "Raphaëlle",  "Raymonde",     "Rebecca",      "Régine",
-    "Reine",      "Réjeanne",   "Renée",      "Rita",        "Rolande",    "Romane",       "Rosalie",      "Rose",
-    "Roseline",   "Sabine",     "Salomé",     "Sandra",      "Sandrine",   "Sarah",        "Scholastique", "Ségolène",
-    "Séverine",   "Sibylle",    "Simone",     "Sixtine",     "Solange",    "Soline",       "Sophie",       "Stéphanie",
-    "Suzanne",    "Suzon",      "Sylviane",   "Sylvie",      "Swassane",   "Tatiana",      "Thaïs",        "Théodora",
-    "Thérèse",    "Tiphaine",   "Ursule",     "Valentine",   "Valérie",    "Véronique",    "Victoire",     "Vinciane",
-    "Violette",   "Virginie",   "Viviane",    "Xavière",     "Yolande",    "Ysaline",      "Yseult",       "Yvette",
-    "Yvonne",     "Zoé",        "Zoéva"};
-}
diff --git a/src/modules/person/data/french/FrenchPeopleNames.h b/src/modules/person/data/french/FrenchPeopleNames.h
new file mode 100644
index 000000000..ba9985bae
--- /dev/null
+++ b/src/modules/person/data/french/FrenchPeopleNames.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "FrenchFirstNames.h"
+#include "FrenchLastNames.h"
+#include "FrenchPrefixes.h"
+
+namespace faker
+{
+const NameFormats frenchPersonNameFormats{{{"{prefix} {firstName} {lastName}", 2}, {"{firstName} {lastName}", 8}}};
+
+const PeopleNames frenchPeopleNames{{frenchMalesFirstNames, {}, frenchLastNames, frenchMalesPrefixes, {}},
+                                    {frenchFemalesFirstNames, {}, frenchLastNames, frenchFemalesPrefixes, {}},
+                                    frenchPersonNameFormats};
+}
diff --git a/src/modules/person/data/french/FrenchPrefixes.h b/src/modules/person/data/french/FrenchPrefixes.h
new file mode 100644
index 000000000..7ea9feddf
--- /dev/null
+++ b/src/modules/person/data/french/FrenchPrefixes.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> frenchMalesPrefixes{"M", "Dr", "Prof"};
+
+const std::vector<std::string> frenchFemalesPrefixes{"Mme", "Mlle", "Dr", "Prof"};
+}
diff --git a/src/modules/person/data/german/GermanFirstNames.h b/src/modules/person/data/german/GermanFirstNames.h
new file mode 100644
index 000000000..c9d687c27
--- /dev/null
+++ b/src/modules/person/data/german/GermanFirstNames.h
@@ -0,0 +1,156 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> germanMalesFirstNames = {
+    "Aaron",      "Abdul",    "Abdullah",  "Adam",       "Adrian",     "Adriano",     "Ahmad",     "Ahmed",
+    "Ahmet",      "Alan",     "Albert",    "Alessandro", "Alessio",    "Alex",        "Alexander", "Alfred",
+    "Ali",        "Amar",     "Amir",      "Amon",       "Andre",      "Andreas",     "Andrew",    "Angelo",
+    "Ansgar",     "Anthony",  "Anton",     "Antonio",    "Arda",       "Arian",       "Armin",     "Arne",
+    "Arno",       "Arthur",   "Artur",     "Arved",      "Arvid",      "Ayman",       "Baran",     "Baris",
+    "Bastian",    "Batuhan",  "Bela",      "Ben",        "Benedikt",   "Benjamin",    "Bennet",    "Bennett",
+    "Benno",      "Bent",     "Berat",     "Berkay",     "Bernd",      "Bilal",       "Bjarne",    "Björn",
+    "Bo",         "Boris",    "Brandon",   "Brian",      "Bruno",      "Bryan",       "Burak",     "Calvin",
+    "Can",        "Carl",     "Carlo",     "Carlos",     "Caspar",     "Cedric",      "Cedrik",    "Cem",
+    "Charlie",    "Chris",    "Christian", "Christiano", "Christoph",  "Christopher", "Claas",     "Clemens",
+    "Colin",      "Collin",   "Conner",    "Connor",     "Constantin", "Corvin",      "Curt",      "Damian",
+    "Damien",     "Daniel",   "Danilo",    "Danny",      "Darian",     "Dario",       "Darius",    "Darren",
+    "David",      "Davide",   "Davin",     "Dean",       "Deniz",      "Dennis",      "Denny",     "Devin",
+    "Diego",      "Dion",     "Domenic",   "Domenik",    "Dominic",    "Dominik",     "Dorian",    "Dustin",
+    "Dylan",      "Ecrin",    "Eddi",      "Eddy",       "Edgar",      "Edwin",       "Efe",       "Ege",
+    "Elia",       "Eliah",    "Elias",     "Elijah",     "Emanuel",    "Emil",        "Emilian",   "Emilio",
+    "Emir",       "Emirhan",  "Emre",      "Enes",       "Enno",       "Enrico",      "Eren",      "Eric",
+    "Erik",       "Etienne",  "Fabian",    "Fabien",     "Fabio",      "Fabrice",     "Falk",      "Felix",
+    "Ferdinand",  "Fiete",    "Filip",     "Finlay",     "Finley",     "Finn",        "Finnley",   "Florian",
+    "Francesco",  "Franz",    "Frederic",  "Frederick",  "Frederik",   "Friedrich",   "Fritz",     "Furkan",
+    "Fynn",       "Gabriel",  "Georg",     "Gerrit",     "Gian",       "Gianluca",    "Gino",      "Giuliano",
+    "Giuseppe",   "Gregor",   "Gustav",    "Hagen",      "Hamza",      "Hannes",      "Hanno",     "Hans",
+    "Hasan",      "Hassan",   "Hauke",     "Hendrik",    "Hennes",     "Henning",     "Henri",     "Henrick",
+    "Henrik",     "Henry",    "Hugo",      "Hussein",    "Ian",        "Ibrahim",     "Ilias",     "Ilja",
+    "Ilyas",      "Immanuel", "Ismael",    "Ismail",     "Ivan",       "Iven",        "Jack",      "Jacob",
+    "Jaden",      "Jakob",    "Jamal",     "James",      "Jamie",      "Jan",         "Janek",     "Janis",
+    "Janne",      "Jannek",   "Jannes",    "Jannik",     "Jannis",     "Jano",        "Janosch",   "Jared",
+    "Jari",       "Jarne",    "Jarno",     "Jaron",      "Jason",      "Jasper",      "Jay",       "Jayden",
+    "Jayson",     "Jean",     "Jens",      "Jeremias",   "Jeremie",    "Jeremy",      "Jermaine",  "Jerome",
+    "Jesper",     "Jesse",    "Jim",       "Jimmy",      "Joe",        "Joel",        "Joey",      "Johann",
+    "Johannes",   "John",     "Johnny",    "Jon",        "Jona",       "Jonah",       "Jonas",     "Jonathan",
+    "Jonte",      "Joost",    "Jordan",    "Joris",      "Joscha",     "Joschua",     "Josef",     "Joseph",
+    "Josh",       "Joshua",   "Josua",     "Juan",       "Julian",     "Julien",      "Julius",    "Juri",
+    "Justin",     "Justus",   "Kaan",      "Kai",        "Kalle",      "Karim",       "Karl",      "Karlo",
+    "Kay",        "Keanu",    "Kenan",     "Kenny",      "Keno",       "Kerem",       "Kerim",     "Kevin",
+    "Kian",       "Kilian",   "Kim",       "Kimi",       "Kjell",      "Klaas",       "Klemens",   "Konrad",
+    "Konstantin", "Koray",    "Korbinian", "Kurt",       "Lars",       "Lasse",       "Laurence",  "Laurens",
+    "Laurenz",    "Laurin",   "Lean",      "Leander",    "Leandro",    "Leif",        "Len",       "Lenn",
+    "Lennard",    "Lennart",  "Lennert",   "Lennie",     "Lennox",     "Lenny",       "Leo",       "Leon",
+    "Leonard",    "Leonardo", "Leonhard",  "Leonidas",   "Leopold",    "Leroy",       "Levent",    "Levi",
+    "Levin",      "Lewin",    "Lewis",     "Liam",       "Lian",       "Lias",        "Lino",      "Linus",
+    "Lio",        "Lion",     "Lionel",    "Logan",      "Lorenz",     "Lorenzo",     "Loris",     "Louis",
+    "Luan",       "Luc",      "Luca",      "Lucas",      "Lucian",     "Lucien",      "Ludwig",    "Luis",
+    "Luiz",       "Luk",      "Luka",      "Lukas",      "Luke",       "Lutz",        "Maddox",    "Mads",
+    "Magnus",     "Maik",     "Maksim",    "Malik",      "Malte",      "Manuel",      "Marc",      "Marcel",
+    "Marco",      "Marcus",   "Marek",     "Marian",     "Mario",      "Marius",      "Mark",      "Marko",
+    "Markus",     "Marlo",    "Marlon",    "Marten",     "Martin",     "Marvin",      "Marwin",    "Mateo",
+    "Mathis",     "Matis",    "Mats",      "Matteo",     "Mattes",     "Matthias",    "Matthis",   "Matti",
+    "Mattis",     "Maurice",  "Max",       "Maxim",      "Maximilian", "Mehmet",      "Meik",      "Melvin",
+    "Merlin",     "Mert",     "Michael",   "Michel",     "Mick",       "Miguel",      "Mika",      "Mikail",
+    "Mike",       "Milan",    "Milo",      "Mio",        "Mirac",      "Mirco",       "Mirko",     "Mohamed",
+    "Mohammad",   "Mohammed", "Moritz",    "Morten",     "Muhammed",   "Murat",       "Mustafa",   "Nathan",
+    "Nathanael",  "Nelson",   "Neo",       "Nevio",      "Nick",       "Niclas",      "Nico",      "Nicolai",
+    "Nicolas",    "Niels",    "Nikita",    "Niklas",     "Niko",       "Nikolai",     "Nikolas",   "Nils",
+    "Nino",       "Noah",     "Noel",      "Norman",     "Odin",       "Oke",         "Ole",       "Oliver",
+    "Omar",       "Onur",     "Oscar",     "Oskar",      "Pascal",     "Patrice",     "Patrick",   "Paul",
+    "Peer",       "Pepe",     "Peter",     "Phil",       "Philip",     "Philipp",     "Pierre",    "Piet",
+    "Pit",        "Pius",     "Quentin",   "Quirin",     "Rafael",     "Raik",        "Ramon",     "Raphael",
+    "Rasmus",     "Raul",     "Rayan",     "René",       "Ricardo",    "Riccardo",    "Richard",   "Rick",
+    "Rico",       "Robert",   "Robin",     "Rocco",      "Roman",      "Romeo",       "Ron",       "Ruben",
+    "Ryan",       "Said",     "Salih",     "Sam",        "Sami",       "Sammy",       "Samuel",    "Sandro",
+    "Santino",    "Sascha",   "Sean",      "Sebastian",  "Selim",      "Semih",       "Shawn",     "Silas",
+    "Simeon",     "Simon",    "Sinan",     "Sky",        "Stefan",     "Steffen",     "Stephan",   "Steve",
+    "Steven",     "Sven",     "Sönke",     "Sören",      "Taha",       "Tamino",      "Tammo",     "Tarik",
+    "Tayler",     "Taylor",   "Teo",       "Theo",       "Theodor",    "Thies",       "Thilo",     "Thomas",
+    "Thorben",    "Thore",    "Thorge",    "Tiago",      "Til",        "Till",        "Tillmann",  "Tim",
+    "Timm",       "Timo",     "Timon",     "Timothy",    "Tino",       "Titus",       "Tizian",    "Tjark",
+    "Tobias",     "Tom",      "Tommy",     "Toni",       "Tony",       "Torben",      "Tore",      "Tristan",
+    "Tyler",      "Tyron",    "Umut",      "Valentin",   "Valentino",  "Veit",        "Victor",    "Viktor",
+    "Vin",        "Vincent",  "Vito",      "Vitus",      "Wilhelm",    "Willi",       "William",   "Willy",
+    "Xaver",      "Yannic",   "Yannick",   "Yannik",     "Yannis",     "Yasin",       "Youssef",   "Yunus",
+    "Yusuf",      "Yven",     "Yves",      "Ömer"};
+
+const std::vector<std::string> germanFemalesFirstNames = {
+    "Aaliyah",   "Abby",      "Abigail",   "Ada",       "Adelina",    "Adriana",   "Aileen",    "Aimee",
+    "Alana",     "Alea",      "Alena",     "Alessa",    "Alessia",    "Alexa",     "Alexandra", "Alexia",
+    "Alexis",    "Aleyna",    "Alia",      "Alica",     "Alice",      "Alicia",    "Alina",     "Alisa",
+    "Alisha",    "Alissa",    "Aliya",     "Aliyah",    "Allegra",    "Alma",      "Alyssa",    "Amalia",
+    "Amanda",    "Amelia",    "Amelie",    "Amina",     "Amira",      "Amy",       "Ana",       "Anabel",
+    "Anastasia", "Andrea",    "Angela",    "Angelina",  "Angelique",  "Anja",      "Ann",       "Anna",
+    "Annabel",   "Annabell",  "Annabelle", "Annalena",  "Anne",       "Anneke",    "Annelie",   "Annemarie",
+    "Anni",      "Annie",     "Annika",    "Anny",      "Anouk",      "Antonia",   "Arda",      "Ariana",
+    "Ariane",    "Arwen",     "Ashley",    "Asya",      "Aurelia",    "Aurora",    "Ava",       "Ayleen",
+    "Aylin",     "Ayse",      "Azra",      "Betty",     "Bianca",     "Bianka",    "Caitlin",   "Cara",
+    "Carina",    "Carla",     "Carlotta",  "Carmen",    "Carolin",    "Carolina",  "Caroline",  "Cassandra",
+    "Catharina", "Catrin",    "Cecile",    "Cecilia",   "Celia",      "Celina",    "Celine",    "Ceyda",
+    "Ceylin",    "Chantal",   "Charleen",  "Charlotta", "Charlotte",  "Chayenne",  "Cheyenne",  "Chiara",
+    "Christin",  "Christina", "Cindy",     "Claire",    "Clara",      "Clarissa",  "Colleen",   "Collien",
+    "Cora",      "Corinna",   "Cosima",    "Dana",      "Daniela",    "Daria",     "Darleen",   "Defne",
+    "Delia",     "Denise",    "Diana",     "Dilara",    "Dina",       "Dorothea",  "Ecrin",     "Eda",
+    "Eileen",    "Ela",       "Elaine",    "Elanur",    "Elea",       "Elena",     "Eleni",     "Eleonora",
+    "Eliana",    "Elif",      "Elina",     "Elisa",     "Elisabeth",  "Ella",      "Ellen",     "Elli",
+    "Elly",      "Elsa",      "Emelie",    "Emely",     "Emilia",     "Emilie",    "Emily",     "Emma",
+    "Emmely",    "Emmi",      "Emmy",      "Enie",      "Enna",       "Enya",      "Esma",      "Estelle",
+    "Esther",    "Eva",       "Evelin",    "Evelina",   "Eveline",    "Evelyn",    "Fabienne",  "Fatima",
+    "Fatma",     "Felicia",   "Felicitas", "Felina",    "Femke",      "Fenja",     "Fine",      "Finia",
+    "Finja",     "Finnja",    "Fiona",     "Flora",     "Florentine", "Francesca", "Franka",    "Franziska",
+    "Frederike", "Freya",     "Frida",     "Frieda",    "Friederike", "Giada",     "Gina",      "Giulia",
+    "Giuliana",  "Greta",     "Hailey",    "Hana",      "Hanna",      "Hannah",    "Heidi",     "Helen",
+    "Helena",    "Helene",    "Helin",     "Henriette", "Henrike",    "Hermine",   "Ida",       "Ilayda",
+    "Imke",      "Ina",       "Ines",      "Inga",      "Inka",       "Irem",      "Isa",       "Isabel",
+    "Isabell",   "Isabella",  "Isabelle",  "Ivonne",    "Jacqueline", "Jamie",     "Jamila",    "Jana",
+    "Jane",      "Janin",     "Janina",    "Janine",    "Janna",      "Janne",     "Jara",      "Jasmin",
+    "Jasmina",   "Jasmine",   "Jella",     "Jenna",     "Jennifer",   "Jenny",     "Jessica",   "Jessy",
+    "Jette",     "Jil",       "Jill",      "Joana",     "Joanna",     "Joelina",   "Joeline",   "Joelle",
+    "Johanna",   "Joleen",    "Jolie",     "Jolien",    "Jolin",      "Jolina",    "Joline",    "Jona",
+    "Jonah",     "Jonna",     "Josefin",   "Josefine",  "Josephin",   "Josephine", "Josie",     "Josy",
+    "Joy",       "Joyce",     "Judith",    "Judy",      "Jule",       "Julia",     "Juliana",   "Juliane",
+    "Julie",     "Julienne",  "Julika",    "Julina",    "Juna",       "Justine",   "Kaja",      "Karina",
+    "Karla",     "Karlotta",  "Karolina",  "Karoline",  "Kassandra",  "Katarina",  "Katharina", "Kathrin",
+    "Katja",     "Katrin",    "Kaya",      "Kayra",     "Kiana",      "Kiara",     "Kim",       "Kimberley",
+    "Kimberly",  "Kira",      "Klara",     "Korinna",   "Kristin",    "Kyra",      "Laila",     "Lana",
+    "Lara",      "Larissa",   "Laura",     "Laureen",   "Lavinia",    "Lea",       "Leah",      "Leana",
+    "Leandra",   "Leann",     "Lee",       "Leila",     "Lena",       "Lene",      "Leni",      "Lenia",
+    "Lenja",     "Lenya",     "Leona",     "Leoni",     "Leonie",     "Leonora",   "Leticia",   "Letizia",
+    "Levke",     "Leyla",     "Lia",       "Liah",      "Liana",      "Lili",      "Lilia",     "Lilian",
+    "Liliana",   "Lilith",    "Lilli",     "Lillian",   "Lilly",      "Lily",      "Lina",      "Linda",
+    "Lindsay",   "Line",      "Linn",      "Linnea",    "Lisa",       "Lisann",    "Lisanne",   "Liv",
+    "Livia",     "Liz",       "Lola",      "Loreen",    "Lorena",     "Lotta",     "Lotte",     "Louisa",
+    "Louise",    "Luana",     "Luca",      "Lucia",     "Lucie",      "Lucienne",  "Lucy",      "Luisa",
+    "Luise",     "Luka",      "Luna",      "Luzie",     "Lya",        "Lydia",     "Lyn",       "Lynn",
+    "Madeleine", "Madita",    "Madleen",   "Madlen",    "Magdalena",  "Maike",     "Mailin",    "Maira",
+    "Maja",      "Malena",    "Malia",     "Malin",     "Malina",     "Mandy",     "Mara",      "Marah",
+    "Mareike",   "Maren",     "Maria",     "Mariam",    "Marie",      "Marieke",   "Mariella",  "Marika",
+    "Marina",    "Marisa",    "Marissa",   "Marit",     "Marla",      "Marleen",   "Marlen",    "Marlena",
+    "Marlene",   "Marta",     "Martha",    "Mary",      "Maryam",     "Mathilda",  "Mathilde",  "Matilda",
+    "Maxi",      "Maxima",    "Maxine",    "Maya",      "Mayra",      "Medina",    "Medine",    "Meike",
+    "Melanie",   "Melek",     "Melike",    "Melina",    "Melinda",    "Melis",     "Melisa",    "Melissa",
+    "Merle",     "Merve",     "Meryem",    "Mette",     "Mia",        "Michaela",  "Michelle",  "Mieke",
+    "Mila",      "Milana",    "Milena",    "Milla",     "Mina",       "Mira",      "Miray",     "Miriam",
+    "Mirja",     "Mona",      "Monique",   "Nadine",    "Nadja",      "Naemi",     "Nancy",     "Naomi",
+    "Natalia",   "Natalie",   "Nathalie",  "Neele",     "Nela",       "Nele",      "Nelli",     "Nelly",
+    "Nia",       "Nicole",    "Nika",      "Nike",      "Nikita",     "Nila",      "Nina",      "Nisa",
+    "Noemi",     "Nora",      "Olivia",    "Patricia",  "Patrizia",   "Paula",     "Paulina",   "Pauline",
+    "Penelope",  "Philine",   "Phoebe",    "Pia",       "Rahel",      "Rania",     "Rebecca",   "Rebekka",
+    "Riana",     "Rieke",     "Rike",      "Romina",    "Romy",       "Ronja",     "Rosa",      "Rosalie",
+    "Ruby",      "Sabrina",   "Sahra",     "Sally",     "Salome",     "Samantha",  "Samia",     "Samira",
+    "Sandra",    "Sandy",     "Sanja",     "Saphira",   "Sara",       "Sarah",     "Saskia",    "Selin",
+    "Selina",    "Selma",     "Sena",      "Sidney",    "Sienna",     "Silja",     "Sina",      "Sinja",
+    "Smilla",    "Sofia",     "Sofie",     "Sonja",     "Sophia",     "Sophie",    "Soraya",    "Stefanie",
+    "Stella",    "Stephanie", "Stina",     "Sude",      "Summer",     "Susanne",   "Svea",      "Svenja",
+    "Sydney",    "Tabea",     "Talea",     "Talia",     "Tamara",     "Tamia",     "Tamina",    "Tanja",
+    "Tara",      "Tarja",     "Teresa",    "Tessa",     "Thalea",     "Thalia",    "Thea",      "Theresa",
+    "Tia",       "Tina",      "Tomke",     "Tuana",     "Valentina",  "Valeria",   "Valerie",   "Vanessa",
+    "Vera",      "Veronika",  "Victoria",  "Viktoria",  "Viola",      "Vivian",    "Vivien",    "Vivienne",
+    "Wibke",     "Wiebke",    "Xenia",     "Yara",      "Yaren",      "Yasmin",    "Ylvi",      "Ylvie",
+    "Yvonne",    "Zara",      "Zehra",     "Zeynep",    "Zoe",        "Zoey",      "Zoé"};
+}
diff --git a/src/modules/person/data/german/GermanFirstNamesFemales.h b/src/modules/person/data/german/GermanFirstNamesFemales.h
deleted file mode 100644
index 5425eceb4..000000000
--- a/src/modules/person/data/german/GermanFirstNamesFemales.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> germanFirstNamesFemales = {
-    "Aaliyah",   "Abby",      "Abigail",   "Ada",       "Adelina",    "Adriana",   "Aileen",    "Aimee",
-    "Alana",     "Alea",      "Alena",     "Alessa",    "Alessia",    "Alexa",     "Alexandra", "Alexia",
-    "Alexis",    "Aleyna",    "Alia",      "Alica",     "Alice",      "Alicia",    "Alina",     "Alisa",
-    "Alisha",    "Alissa",    "Aliya",     "Aliyah",    "Allegra",    "Alma",      "Alyssa",    "Amalia",
-    "Amanda",    "Amelia",    "Amelie",    "Amina",     "Amira",      "Amy",       "Ana",       "Anabel",
-    "Anastasia", "Andrea",    "Angela",    "Angelina",  "Angelique",  "Anja",      "Ann",       "Anna",
-    "Annabel",   "Annabell",  "Annabelle", "Annalena",  "Anne",       "Anneke",    "Annelie",   "Annemarie",
-    "Anni",      "Annie",     "Annika",    "Anny",      "Anouk",      "Antonia",   "Arda",      "Ariana",
-    "Ariane",    "Arwen",     "Ashley",    "Asya",      "Aurelia",    "Aurora",    "Ava",       "Ayleen",
-    "Aylin",     "Ayse",      "Azra",      "Betty",     "Bianca",     "Bianka",    "Caitlin",   "Cara",
-    "Carina",    "Carla",     "Carlotta",  "Carmen",    "Carolin",    "Carolina",  "Caroline",  "Cassandra",
-    "Catharina", "Catrin",    "Cecile",    "Cecilia",   "Celia",      "Celina",    "Celine",    "Ceyda",
-    "Ceylin",    "Chantal",   "Charleen",  "Charlotta", "Charlotte",  "Chayenne",  "Cheyenne",  "Chiara",
-    "Christin",  "Christina", "Cindy",     "Claire",    "Clara",      "Clarissa",  "Colleen",   "Collien",
-    "Cora",      "Corinna",   "Cosima",    "Dana",      "Daniela",    "Daria",     "Darleen",   "Defne",
-    "Delia",     "Denise",    "Diana",     "Dilara",    "Dina",       "Dorothea",  "Ecrin",     "Eda",
-    "Eileen",    "Ela",       "Elaine",    "Elanur",    "Elea",       "Elena",     "Eleni",     "Eleonora",
-    "Eliana",    "Elif",      "Elina",     "Elisa",     "Elisabeth",  "Ella",      "Ellen",     "Elli",
-    "Elly",      "Elsa",      "Emelie",    "Emely",     "Emilia",     "Emilie",    "Emily",     "Emma",
-    "Emmely",    "Emmi",      "Emmy",      "Enie",      "Enna",       "Enya",      "Esma",      "Estelle",
-    "Esther",    "Eva",       "Evelin",    "Evelina",   "Eveline",    "Evelyn",    "Fabienne",  "Fatima",
-    "Fatma",     "Felicia",   "Felicitas", "Felina",    "Femke",      "Fenja",     "Fine",      "Finia",
-    "Finja",     "Finnja",    "Fiona",     "Flora",     "Florentine", "Francesca", "Franka",    "Franziska",
-    "Frederike", "Freya",     "Frida",     "Frieda",    "Friederike", "Giada",     "Gina",      "Giulia",
-    "Giuliana",  "Greta",     "Hailey",    "Hana",      "Hanna",      "Hannah",    "Heidi",     "Helen",
-    "Helena",    "Helene",    "Helin",     "Henriette", "Henrike",    "Hermine",   "Ida",       "Ilayda",
-    "Imke",      "Ina",       "Ines",      "Inga",      "Inka",       "Irem",      "Isa",       "Isabel",
-    "Isabell",   "Isabella",  "Isabelle",  "Ivonne",    "Jacqueline", "Jamie",     "Jamila",    "Jana",
-    "Jane",      "Janin",     "Janina",    "Janine",    "Janna",      "Janne",     "Jara",      "Jasmin",
-    "Jasmina",   "Jasmine",   "Jella",     "Jenna",     "Jennifer",   "Jenny",     "Jessica",   "Jessy",
-    "Jette",     "Jil",       "Jill",      "Joana",     "Joanna",     "Joelina",   "Joeline",   "Joelle",
-    "Johanna",   "Joleen",    "Jolie",     "Jolien",    "Jolin",      "Jolina",    "Joline",    "Jona",
-    "Jonah",     "Jonna",     "Josefin",   "Josefine",  "Josephin",   "Josephine", "Josie",     "Josy",
-    "Joy",       "Joyce",     "Judith",    "Judy",      "Jule",       "Julia",     "Juliana",   "Juliane",
-    "Julie",     "Julienne",  "Julika",    "Julina",    "Juna",       "Justine",   "Kaja",      "Karina",
-    "Karla",     "Karlotta",  "Karolina",  "Karoline",  "Kassandra",  "Katarina",  "Katharina", "Kathrin",
-    "Katja",     "Katrin",    "Kaya",      "Kayra",     "Kiana",      "Kiara",     "Kim",       "Kimberley",
-    "Kimberly",  "Kira",      "Klara",     "Korinna",   "Kristin",    "Kyra",      "Laila",     "Lana",
-    "Lara",      "Larissa",   "Laura",     "Laureen",   "Lavinia",    "Lea",       "Leah",      "Leana",
-    "Leandra",   "Leann",     "Lee",       "Leila",     "Lena",       "Lene",      "Leni",      "Lenia",
-    "Lenja",     "Lenya",     "Leona",     "Leoni",     "Leonie",     "Leonora",   "Leticia",   "Letizia",
-    "Levke",     "Leyla",     "Lia",       "Liah",      "Liana",      "Lili",      "Lilia",     "Lilian",
-    "Liliana",   "Lilith",    "Lilli",     "Lillian",   "Lilly",      "Lily",      "Lina",      "Linda",
-    "Lindsay",   "Line",      "Linn",      "Linnea",    "Lisa",       "Lisann",    "Lisanne",   "Liv",
-    "Livia",     "Liz",       "Lola",      "Loreen",    "Lorena",     "Lotta",     "Lotte",     "Louisa",
-    "Louise",    "Luana",     "Luca",      "Lucia",     "Lucie",      "Lucienne",  "Lucy",      "Luisa",
-    "Luise",     "Luka",      "Luna",      "Luzie",     "Lya",        "Lydia",     "Lyn",       "Lynn",
-    "Madeleine", "Madita",    "Madleen",   "Madlen",    "Magdalena",  "Maike",     "Mailin",    "Maira",
-    "Maja",      "Malena",    "Malia",     "Malin",     "Malina",     "Mandy",     "Mara",      "Marah",
-    "Mareike",   "Maren",     "Maria",     "Mariam",    "Marie",      "Marieke",   "Mariella",  "Marika",
-    "Marina",    "Marisa",    "Marissa",   "Marit",     "Marla",      "Marleen",   "Marlen",    "Marlena",
-    "Marlene",   "Marta",     "Martha",    "Mary",      "Maryam",     "Mathilda",  "Mathilde",  "Matilda",
-    "Maxi",      "Maxima",    "Maxine",    "Maya",      "Mayra",      "Medina",    "Medine",    "Meike",
-    "Melanie",   "Melek",     "Melike",    "Melina",    "Melinda",    "Melis",     "Melisa",    "Melissa",
-    "Merle",     "Merve",     "Meryem",    "Mette",     "Mia",        "Michaela",  "Michelle",  "Mieke",
-    "Mila",      "Milana",    "Milena",    "Milla",     "Mina",       "Mira",      "Miray",     "Miriam",
-    "Mirja",     "Mona",      "Monique",   "Nadine",    "Nadja",      "Naemi",     "Nancy",     "Naomi",
-    "Natalia",   "Natalie",   "Nathalie",  "Neele",     "Nela",       "Nele",      "Nelli",     "Nelly",
-    "Nia",       "Nicole",    "Nika",      "Nike",      "Nikita",     "Nila",      "Nina",      "Nisa",
-    "Noemi",     "Nora",      "Olivia",    "Patricia",  "Patrizia",   "Paula",     "Paulina",   "Pauline",
-    "Penelope",  "Philine",   "Phoebe",    "Pia",       "Rahel",      "Rania",     "Rebecca",   "Rebekka",
-    "Riana",     "Rieke",     "Rike",      "Romina",    "Romy",       "Ronja",     "Rosa",      "Rosalie",
-    "Ruby",      "Sabrina",   "Sahra",     "Sally",     "Salome",     "Samantha",  "Samia",     "Samira",
-    "Sandra",    "Sandy",     "Sanja",     "Saphira",   "Sara",       "Sarah",     "Saskia",    "Selin",
-    "Selina",    "Selma",     "Sena",      "Sidney",    "Sienna",     "Silja",     "Sina",      "Sinja",
-    "Smilla",    "Sofia",     "Sofie",     "Sonja",     "Sophia",     "Sophie",    "Soraya",    "Stefanie",
-    "Stella",    "Stephanie", "Stina",     "Sude",      "Summer",     "Susanne",   "Svea",      "Svenja",
-    "Sydney",    "Tabea",     "Talea",     "Talia",     "Tamara",     "Tamia",     "Tamina",    "Tanja",
-    "Tara",      "Tarja",     "Teresa",    "Tessa",     "Thalea",     "Thalia",    "Thea",      "Theresa",
-    "Tia",       "Tina",      "Tomke",     "Tuana",     "Valentina",  "Valeria",   "Valerie",   "Vanessa",
-    "Vera",      "Veronika",  "Victoria",  "Viktoria",  "Viola",      "Vivian",    "Vivien",    "Vivienne",
-    "Wibke",     "Wiebke",    "Xenia",     "Yara",      "Yaren",      "Yasmin",    "Ylvi",      "Ylvie",
-    "Yvonne",    "Zara",      "Zehra",     "Zeynep",    "Zoe",        "Zoey",      "Zoé"};
-}
diff --git a/src/modules/person/data/german/GermanFirstNamesMales.h b/src/modules/person/data/german/GermanFirstNamesMales.h
deleted file mode 100644
index 8b11b2abf..000000000
--- a/src/modules/person/data/german/GermanFirstNamesMales.h
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> germanFirstNamesMales = {
-    "Aaron",      "Abdul",    "Abdullah",  "Adam",       "Adrian",     "Adriano",     "Ahmad",     "Ahmed",
-    "Ahmet",      "Alan",     "Albert",    "Alessandro", "Alessio",    "Alex",        "Alexander", "Alfred",
-    "Ali",        "Amar",     "Amir",      "Amon",       "Andre",      "Andreas",     "Andrew",    "Angelo",
-    "Ansgar",     "Anthony",  "Anton",     "Antonio",    "Arda",       "Arian",       "Armin",     "Arne",
-    "Arno",       "Arthur",   "Artur",     "Arved",      "Arvid",      "Ayman",       "Baran",     "Baris",
-    "Bastian",    "Batuhan",  "Bela",      "Ben",        "Benedikt",   "Benjamin",    "Bennet",    "Bennett",
-    "Benno",      "Bent",     "Berat",     "Berkay",     "Bernd",      "Bilal",       "Bjarne",    "Björn",
-    "Bo",         "Boris",    "Brandon",   "Brian",      "Bruno",      "Bryan",       "Burak",     "Calvin",
-    "Can",        "Carl",     "Carlo",     "Carlos",     "Caspar",     "Cedric",      "Cedrik",    "Cem",
-    "Charlie",    "Chris",    "Christian", "Christiano", "Christoph",  "Christopher", "Claas",     "Clemens",
-    "Colin",      "Collin",   "Conner",    "Connor",     "Constantin", "Corvin",      "Curt",      "Damian",
-    "Damien",     "Daniel",   "Danilo",    "Danny",      "Darian",     "Dario",       "Darius",    "Darren",
-    "David",      "Davide",   "Davin",     "Dean",       "Deniz",      "Dennis",      "Denny",     "Devin",
-    "Diego",      "Dion",     "Domenic",   "Domenik",    "Dominic",    "Dominik",     "Dorian",    "Dustin",
-    "Dylan",      "Ecrin",    "Eddi",      "Eddy",       "Edgar",      "Edwin",       "Efe",       "Ege",
-    "Elia",       "Eliah",    "Elias",     "Elijah",     "Emanuel",    "Emil",        "Emilian",   "Emilio",
-    "Emir",       "Emirhan",  "Emre",      "Enes",       "Enno",       "Enrico",      "Eren",      "Eric",
-    "Erik",       "Etienne",  "Fabian",    "Fabien",     "Fabio",      "Fabrice",     "Falk",      "Felix",
-    "Ferdinand",  "Fiete",    "Filip",     "Finlay",     "Finley",     "Finn",        "Finnley",   "Florian",
-    "Francesco",  "Franz",    "Frederic",  "Frederick",  "Frederik",   "Friedrich",   "Fritz",     "Furkan",
-    "Fynn",       "Gabriel",  "Georg",     "Gerrit",     "Gian",       "Gianluca",    "Gino",      "Giuliano",
-    "Giuseppe",   "Gregor",   "Gustav",    "Hagen",      "Hamza",      "Hannes",      "Hanno",     "Hans",
-    "Hasan",      "Hassan",   "Hauke",     "Hendrik",    "Hennes",     "Henning",     "Henri",     "Henrick",
-    "Henrik",     "Henry",    "Hugo",      "Hussein",    "Ian",        "Ibrahim",     "Ilias",     "Ilja",
-    "Ilyas",      "Immanuel", "Ismael",    "Ismail",     "Ivan",       "Iven",        "Jack",      "Jacob",
-    "Jaden",      "Jakob",    "Jamal",     "James",      "Jamie",      "Jan",         "Janek",     "Janis",
-    "Janne",      "Jannek",   "Jannes",    "Jannik",     "Jannis",     "Jano",        "Janosch",   "Jared",
-    "Jari",       "Jarne",    "Jarno",     "Jaron",      "Jason",      "Jasper",      "Jay",       "Jayden",
-    "Jayson",     "Jean",     "Jens",      "Jeremias",   "Jeremie",    "Jeremy",      "Jermaine",  "Jerome",
-    "Jesper",     "Jesse",    "Jim",       "Jimmy",      "Joe",        "Joel",        "Joey",      "Johann",
-    "Johannes",   "John",     "Johnny",    "Jon",        "Jona",       "Jonah",       "Jonas",     "Jonathan",
-    "Jonte",      "Joost",    "Jordan",    "Joris",      "Joscha",     "Joschua",     "Josef",     "Joseph",
-    "Josh",       "Joshua",   "Josua",     "Juan",       "Julian",     "Julien",      "Julius",    "Juri",
-    "Justin",     "Justus",   "Kaan",      "Kai",        "Kalle",      "Karim",       "Karl",      "Karlo",
-    "Kay",        "Keanu",    "Kenan",     "Kenny",      "Keno",       "Kerem",       "Kerim",     "Kevin",
-    "Kian",       "Kilian",   "Kim",       "Kimi",       "Kjell",      "Klaas",       "Klemens",   "Konrad",
-    "Konstantin", "Koray",    "Korbinian", "Kurt",       "Lars",       "Lasse",       "Laurence",  "Laurens",
-    "Laurenz",    "Laurin",   "Lean",      "Leander",    "Leandro",    "Leif",        "Len",       "Lenn",
-    "Lennard",    "Lennart",  "Lennert",   "Lennie",     "Lennox",     "Lenny",       "Leo",       "Leon",
-    "Leonard",    "Leonardo", "Leonhard",  "Leonidas",   "Leopold",    "Leroy",       "Levent",    "Levi",
-    "Levin",      "Lewin",    "Lewis",     "Liam",       "Lian",       "Lias",        "Lino",      "Linus",
-    "Lio",        "Lion",     "Lionel",    "Logan",      "Lorenz",     "Lorenzo",     "Loris",     "Louis",
-    "Luan",       "Luc",      "Luca",      "Lucas",      "Lucian",     "Lucien",      "Ludwig",    "Luis",
-    "Luiz",       "Luk",      "Luka",      "Lukas",      "Luke",       "Lutz",        "Maddox",    "Mads",
-    "Magnus",     "Maik",     "Maksim",    "Malik",      "Malte",      "Manuel",      "Marc",      "Marcel",
-    "Marco",      "Marcus",   "Marek",     "Marian",     "Mario",      "Marius",      "Mark",      "Marko",
-    "Markus",     "Marlo",    "Marlon",    "Marten",     "Martin",     "Marvin",      "Marwin",    "Mateo",
-    "Mathis",     "Matis",    "Mats",      "Matteo",     "Mattes",     "Matthias",    "Matthis",   "Matti",
-    "Mattis",     "Maurice",  "Max",       "Maxim",      "Maximilian", "Mehmet",      "Meik",      "Melvin",
-    "Merlin",     "Mert",     "Michael",   "Michel",     "Mick",       "Miguel",      "Mika",      "Mikail",
-    "Mike",       "Milan",    "Milo",      "Mio",        "Mirac",      "Mirco",       "Mirko",     "Mohamed",
-    "Mohammad",   "Mohammed", "Moritz",    "Morten",     "Muhammed",   "Murat",       "Mustafa",   "Nathan",
-    "Nathanael",  "Nelson",   "Neo",       "Nevio",      "Nick",       "Niclas",      "Nico",      "Nicolai",
-    "Nicolas",    "Niels",    "Nikita",    "Niklas",     "Niko",       "Nikolai",     "Nikolas",   "Nils",
-    "Nino",       "Noah",     "Noel",      "Norman",     "Odin",       "Oke",         "Ole",       "Oliver",
-    "Omar",       "Onur",     "Oscar",     "Oskar",      "Pascal",     "Patrice",     "Patrick",   "Paul",
-    "Peer",       "Pepe",     "Peter",     "Phil",       "Philip",     "Philipp",     "Pierre",    "Piet",
-    "Pit",        "Pius",     "Quentin",   "Quirin",     "Rafael",     "Raik",        "Ramon",     "Raphael",
-    "Rasmus",     "Raul",     "Rayan",     "René",       "Ricardo",    "Riccardo",    "Richard",   "Rick",
-    "Rico",       "Robert",   "Robin",     "Rocco",      "Roman",      "Romeo",       "Ron",       "Ruben",
-    "Ryan",       "Said",     "Salih",     "Sam",        "Sami",       "Sammy",       "Samuel",    "Sandro",
-    "Santino",    "Sascha",   "Sean",      "Sebastian",  "Selim",      "Semih",       "Shawn",     "Silas",
-    "Simeon",     "Simon",    "Sinan",     "Sky",        "Stefan",     "Steffen",     "Stephan",   "Steve",
-    "Steven",     "Sven",     "Sönke",     "Sören",      "Taha",       "Tamino",      "Tammo",     "Tarik",
-    "Tayler",     "Taylor",   "Teo",       "Theo",       "Theodor",    "Thies",       "Thilo",     "Thomas",
-    "Thorben",    "Thore",    "Thorge",    "Tiago",      "Til",        "Till",        "Tillmann",  "Tim",
-    "Timm",       "Timo",     "Timon",     "Timothy",    "Tino",       "Titus",       "Tizian",    "Tjark",
-    "Tobias",     "Tom",      "Tommy",     "Toni",       "Tony",       "Torben",      "Tore",      "Tristan",
-    "Tyler",      "Tyron",    "Umut",      "Valentin",   "Valentino",  "Veit",        "Victor",    "Viktor",
-    "Vin",        "Vincent",  "Vito",      "Vitus",      "Wilhelm",    "Willi",       "William",   "Willy",
-    "Xaver",      "Yannic",   "Yannick",   "Yannik",     "Yannis",     "Yasin",       "Youssef",   "Yunus",
-    "Yusuf",      "Yven",     "Yves",      "Ömer"};
-}
diff --git a/src/modules/person/data/german/GermanPeopleNames.h b/src/modules/person/data/german/GermanPeopleNames.h
new file mode 100644
index 000000000..0db0d2b01
--- /dev/null
+++ b/src/modules/person/data/german/GermanPeopleNames.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "GermanFirstNames.h"
+#include "GermanLastNames.h"
+#include "GermanPrefixes.h"
+
+namespace faker
+{
+const NameFormats germanPersonNameFormats{{{"{prefix} {firstName} {lastName}", 1}, {"{firstName} {lastName}", 8}}};
+
+const PeopleNames germanPeopleNames{{germanMalesFirstNames, {}, germanLastNames, germanMalesPrefixes, {}},
+                                    {germanFemalesFirstNames, {}, germanLastNames, germanFemalesPrefixes, {}},
+                                    germanPersonNameFormats};
+
+}
diff --git a/src/modules/person/data/german/GermanPrefixes.h b/src/modules/person/data/german/GermanPrefixes.h
new file mode 100644
index 000000000..8d0fb8af6
--- /dev/null
+++ b/src/modules/person/data/german/GermanPrefixes.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> germanMalesPrefixes{"Herr", "Dr.", "Prof. Dr."};
+
+const std::vector<std::string> germanFemalesPrefixes{"Frau", "Dr.", "Prof. Dr."};
+}
diff --git a/src/modules/person/data/indian/IndianFirstNames.h b/src/modules/person/data/indian/IndianFirstNames.h
index 9994cc6de..325ddeddc 100644
--- a/src/modules/person/data/indian/IndianFirstNames.h
+++ b/src/modules/person/data/indian/IndianFirstNames.h
@@ -5,7 +5,7 @@
 
 namespace faker
 {
-const std::vector<std::string> indianFirstNamesMales = {
+const std::vector<std::string> indianMalesFirstNames = {
     "Aadi",      "Aadil",      "Aahan",     "Aarav",       "Aarit",     "Aarush",   "Aaryan",    "Aaryav",
     "Aayush",    "Abeer",      "Abhay",     "Abhinav",     "Abhishek",  "Abhiyay",  "Adarsh",    "Adhvait",
     "Aditya",    "Advait",     "Advay",     "Ahaan",       "Akash",     "Akhil",    "Akhilesh",  "Akshant",
@@ -52,7 +52,7 @@ const std::vector<std::string> indianFirstNamesMales = {
     "Yuvansh",   "Yuvraj",     "Yuvraja",   "Zaheer",      "Zahir",     "Zain",     "Zayyan",
 };
 
-const std::vector<std::string> indianFirstNamesFemales = {
+const std::vector<std::string> indianFemalesFirstNames = {
     "Aadrika",  "Aadya",      "Aakriti",  "Aanya",     "Aanyaya",   "Aaradhya",  "Aarohi",     "Aashi",     "Aashika",
     "Adhithi",  "Aditi",      "Aisha",    "Akshara",   "Alia",      "Amaira",    "Amara",      "Ananya",    "Anika",
     "Anisha",   "Anushka",    "Anvi",     "Anwaya",    "Aria",      "Arunima",   "Avani",      "Avishi",    "Avni",
@@ -79,4 +79,4 @@ const std::vector<std::string> indianFirstNamesFemales = {
     "Vanya",    "Vasundhara", "Vidhi",    "Vidulika",  "Vinita",    "Wansika",   "Wisha",      "Wynona",    "Xandra",
     "Xara",     "Yashi",      "Yashika",  "Yashvi",    "Yukta",     "Yukthi",    "Zaina",      "Zaira",     "Zara",
     "Zarika",   "Zarna",      "Zoya"};
-}
\ No newline at end of file
+}
diff --git a/src/modules/person/data/indian/IndianPeopleNames.h b/src/modules/person/data/indian/IndianPeopleNames.h
new file mode 100644
index 000000000..1c39c5c30
--- /dev/null
+++ b/src/modules/person/data/indian/IndianPeopleNames.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "IndianFirstNames.h"
+#include "IndianLastNames.h"
+
+namespace faker
+{
+const NameFormats indianPersonNameFormats{{"{firstName} {lastName}", 1}};
+
+const PeopleNames indianPeopleNames{{indianMalesFirstNames, {}, indianLastNames, {}, {}},
+                                    {indianFemalesFirstNames, {}, indianLastNames, {}, {}},
+                                    indianPersonNameFormats};
+
+}
diff --git a/src/modules/person/data/italian/ItalianFirstNamesMales.h b/src/modules/person/data/italian/ItalianFirstNames.h
similarity index 64%
rename from src/modules/person/data/italian/ItalianFirstNamesMales.h
rename to src/modules/person/data/italian/ItalianFirstNames.h
index 8798c9cce..daef5a737 100644
--- a/src/modules/person/data/italian/ItalianFirstNamesMales.h
+++ b/src/modules/person/data/italian/ItalianFirstNames.h
@@ -5,7 +5,7 @@
 
 namespace faker
 {
-const std::vector<std::string> italianFirstNamesMales = {
+const std::vector<std::string> italianMalesFirstNames = {
     "Abaco",      "Abbondanzio",  "Abbondio",     "Abdone",     "Abelardo",     "Abele",       "Abenzio",
     "Abibo",      "Abramio",      "Abramo",       "Acacio",     "Acario",       "Accursio",    "Achille",
     "Acilio",     "Aciscolo",     "Acrisio",      "Adalardo",   "Adalberto",    "Adalfredo",   "Adalgiso",
@@ -161,4 +161,84 @@ const std::vector<std::string> italianFirstNamesMales = {
     "Vodingo",    "Volfango",     "Vulmaro",      "Vulpiano",   "Walter",       "Zabedeo",     "Zaccaria",
     "Zaccheo",    "Zanobi",       "Zefiro",       "Zena",       "Zenaide",      "Zenebio",     "Zeno",
     "Zenobio",    "Zenone",       "Zetico",       "Zoilo",      "Zosimo"};
+
+const std::vector<std::string> italianFemalesFirstNames = {
+    "Abbondanza", "Acilia",      "Ada",         "Adalberta",  "Adalgisa",   "Addolorata", "Adelaide",  "Adelasia",
+    "Adele",      "Adelina",     "Adina",       "Adria",      "Adriana",    "Agape",      "Agata",     "Agnese",
+    "Agostina",   "Aida",        "Alba",        "Alberta",    "Albina",     "Alcina",     "Alda",      "Alessandra",
+    "Alessia",    "Alfonsa",     "Alfreda",     "Alice",      "Alida",      "Alina",      "Allegra",   "Alma",
+    "Altea",      "Amalia",      "Amanda",      "Amata",      "Ambra",      "Amelia",     "Amina",     "Anastasia",
+    "Anatolia",   "Ancilla",     "Andromeda",   "Angela",     "Angelica",   "Anita",      "Anna",      "Annabella",
+    "Annagrazia", "Annamaria",   "Annunziata",  "Antea",      "Antigone",   "Antonella",  "Antonia",   "Apollina",
+    "Apollonia",  "Appia",       "Arabella",    "Argelia",    "Arianna",    "Armida",     "Artemisa",  "Asella",
+    "Asia",       "Assunta",     "Astrid",      "Atanasia",   "Aurelia",    "Aurora",     "Ausilia",   "Ausiliatrice",
+    "Ave",        "Aza",         "Azelia",      "Azzurra",    "Babila",     "Bambina",    "Barbara",   "Bartolomea",
+    "Basilia",    "Bassilla",    "Batilda",     "Beata",      "Beatrice",   "Belina",     "Benedetta", "Beniamina",
+    "Benigna",    "Benvenuta",   "Berenice",    "Bernadetta", "Betta",      "Bianca",     "Bibiana",   "Bice",
+    "Brigida",    "Brigitta",    "Bruna",       "Brunilde",   "Calogera",   "Calpurnia",  "Camelia",   "Camilla",
+    "Candida",    "Capitolina",  "Carina",      "Carla",      "Carlotta",   "Carmela",    "Carmen",    "Carola",
+    "Carolina",   "Casilda",     "Casimira",    "Cassandra",  "Cassiopea",  "Catena",     "Caterina",  "Cecilia",
+    "Celeste",    "Celinia",     "Chiara",      "Cinzia",     "Cirilla",    "Clara",      "Claudia",   "Clelia",
+    "Clemenzia",  "Cleo",        "Cleofe",      "Cleopatra",  "Cloe",       "Clorinda",   "Cointa",    "Colomba",
+    "Concetta",   "Consolata",   "Cora",        "Cordelia",   "Corinna",    "Cornelia",   "Cosima",    "Costanza",
+    "Crescenzia", "Cristiana",   "Cristina",    "Crocefissa", "Cronida",    "Cunegonda",  "Cuzia",     "Dafne",
+    "Dalida",     "Dalila",      "Damiana",     "Daniela",    "Daria",      "Deanna",     "Debora",    "Degna",
+    "Delfina",    "Delia",       "Delinda",     "Delizia",    "Demetria",   "Deodata",    "Desdemona", "Desiderata",
+    "Devota",     "Diamante",    "Diana",       "Dianora",    "Diletta",    "Dina",       "Diodata",   "Dionisia",
+    "Doda",       "Dolores",     "Domenica",    "Donata",     "Donatella",  "Donna",      "Dora",      "Dorotea",
+    "Druina",     "Dulina",      "Ebe",         "Edda",       "Edelberga",  "Editta",     "Edvige",    "Egizia",
+    "Egle",       "Elaide",      "Elda",        "Elena",      "Eleonora",   "Elettra",    "Eliana",    "Elide",
+    "Elimena",    "Elisa",       "Elisabetta",  "Elisea",     "Ella",       "Eloisa",     "Elsa",      "Elvia",
+    "Elvira",     "Emanuela",    "Emilia",      "Emiliana",   "Emma",       "Enimia",     "Enrica",    "Eracla",
+    "Ermelinda",  "Ermenegarda", "Ermenegilda", "Erminia",    "Ernesta",    "Ersilia",    "Esmeralda", "Estella",
+    "Ester",      "Esterina",    "Eufemia",     "Eufrasia",   "Eugenia",    "Eulalia",    "Euridice",  "Eusebia",
+    "Eutalia",    "Eva",         "Evangelina",  "Evelina",    "Fabiana",    "Fabiola",    "Fatima",    "Fausta",
+    "Federica",   "Fedora",      "Felicia",     "Felicita",   "Fernanda",   "Fiammetta",  "Filippa",   "Filomena",
+    "Fiordaliso", "Fiore",       "Fiorella",    "Fiorenza",   "Flaminia",   "Flavia",     "Flaviana",  "Flora",
+    "Floriana",   "Floridia",    "Florina",     "Foca",       "Fortunata",  "Fosca",      "Franca",    "Francesca",
+    "Fulvia",     "Gabriella",   "Gaia",        "Galatea",    "Gaudenzia",  "Gelsomina",  "Geltrude",  "Gemma",
+    "Generosa",   "Genesia",     "Genoveffa",   "Germana",    "Gertrude",   "Ghita",      "Giacinta",  "Giada",
+    "Gigliola",   "Gilda",       "Giliola",     "Ginevra",    "Gioacchina", "Gioconda",   "Gioia",     "Giorgia",
+    "Giovanna",   "Gisella",     "Giuditta",    "Giulia",     "Giuliana",   "Giulitta",   "Giuseppa",  "Giuseppina",
+    "Giusta",     "Glenda",      "Gloria",      "Godeberta",  "Godiva",     "Grazia",     "Graziana",  "Graziella",
+    "Greta",      "Griselda",    "Guenda",      "Guendalina", "Gundelinda", "Ianira",     "Ida",       "Idea",
+    "Iginia",     "Ilaria",      "Ilda",        "Ildegarda",  "Ildegonda",  "Ileana",     "Ilenia",    "Ilia",
+    "Ilva",       "Imelda",      "Immacolata",  "Incoronata", "Ines",       "Innocenza",  "Iolanda",   "Iole",
+    "Iona",       "Ione",        "Ionne",       "Irene",      "Iride",      "Iris",       "Irma",      "Irmina",
+    "Isa",        "Isabella",    "Iside",       "Isidora",    "Isotta",     "Italia",     "Ivetta",    "Lara",
+    "Laura",      "Lavinia",     "Lea",         "Leda",       "Lelia",      "Lena",       "Leonia",    "Leonilda",
+    "Leontina",   "Letizia",     "Lia",         "Liana",      "Liberata",   "Liboria",    "Licia",     "Lidania",
+    "Lidia",      "Liliana",     "Linda",       "Lisa",       "Livia",      "Liviana",    "Lodovica",  "Loredana",
+    "Lorella",    "Lorena",      "Lorenza",     "Loretta",    "Loriana",    "Luana",      "Luce",      "Lucia",
+    "Luciana",    "Lucilla",     "Lucrezia",    "Ludovica",   "Luigia",     "Luisa",      "Luminosa",  "Luna",
+    "Macaria",    "Maddalena",   "Mafalda",     "Magda",      "Maida",      "Manuela",    "Mara",      "Marana",
+    "Marcella",   "Mareta",      "Margherita",  "Maria",      "Marianna",   "Marica",     "Mariella",  "Marilena",
+    "Marina",     "Marinella",   "Marinetta",   "Marisa",     "Marita",     "Marta",      "Martina",   "Maruta",
+    "Marzia",     "Massima",     "Matilde",     "Maura",      "Melania",    "Melissa",    "Melitina",  "Menodora",
+    "Mercede",    "Messalina",   "Mia",         "Michela",    "Milena",     "Mimma",      "Mina",      "Minerva",
+    "Minervina",  "Miranda",     "Mirella",     "Miriam",     "Mirta",      "Moira",      "Monica",    "Morena",
+    "Morgana",    "Nadia",       "Natalia",     "Natalina",   "Neiva",      "Nerea",      "Nicla",     "Nicoletta",
+    "Nilde",      "Nina",        "Ninfa",       "Nives",      "Noemi",      "Norina",     "Norma",     "Novella",
+    "Nuccia",     "Nunziata",    "Odetta",      "Odilia",     "Ofelia",     "Olga",       "Olimpia",   "Olinda",
+    "Olivia",     "Oliviera",    "Ombretta",    "Ondina",     "Onesta",     "Onorata",    "Onorina",   "Orchidea",
+    "Oriana",     "Orietta",     "Ornella",     "Orsola",     "Orsolina",   "Ortensia",   "Osanna",    "Otilia",
+    "Ottilia",    "Palladia",    "Palmazio",    "Palmira",    "Pamela",     "Paola",      "Patrizia",  "Pelagia",
+    "Penelope",   "Perla",       "Petronilla",  "Pia",        "Piera",      "Placida",    "Polissena", "Porzia",
+    "Prisca",     "Priscilla",   "Proserpina",  "Prospera",   "Prudenzia",  "Quartilla",  "Quieta",    "Quiteria",
+    "Rachele",    "Raffaella",   "Rainelda",    "Rebecca",    "Regina",     "Renata",     "Riccarda",  "Rina",
+    "Rita",       "Roberta",     "Romana",      "Romilda",    "Romina",     "Romola",     "Rosa",      "Rosalia",
+    "Rosalinda",  "Rosamunda",   "Rosanna",     "Rosita",     "Rosmunda",   "Rossana",    "Rossella",  "Rufina",
+    "Saba",       "Sabina",      "Sabrina",     "Samanta",    "Samona",     "Sandra",     "Santina",   "Sara",
+    "Savina",     "Scolastica",  "Sebastiana",  "Seconda",    "Secondina",  "Sefora",     "Selene",    "Selvaggia",
+    "Semiramide", "Serafina",    "Serena",      "Severa",     "Sibilla",    "Sidonia",    "Silvana",   "Silvia",
+    "Simona",     "Simonetta",   "Siria",       "Smeralda",   "Soave",      "Sofia",      "Sofronia",  "Solange",
+    "Sonia",      "Speranza",    "Stefania",    "Stella",     "Susanna",    "Sveva",      "Tabita",    "Tamara",
+    "Tarquinia",  "Tarsilla",    "Taziana",     "Tea",        "Tecla",      "Telica",     "Teodata",   "Teodolinda",
+    "Teodora",    "Teresa",      "Teudosia",    "Tina",       "Tiziana",    "Tosca",      "Trasea",    "Tullia",
+    "Ugolina",    "Ulfa",        "Uliva",       "Unna",       "Vala",       "Valentina",  "Valeria",   "Valeriana",
+    "Vanda",      "Vanessa",     "Vanna",       "Venera",     "Veneranda",  "Venere",     "Venusta",   "Vera",
+    "Verdiana",   "Verena",      "Veriana",     "Veridiana",  "Veronica",   "Viliana",    "Vilma",     "Vincenza",
+    "Viola",      "Violante",    "Virginia",    "Vissia",     "Vittoria",   "Viviana",    "Wanda",     "Zabina",
+    "Zaira",      "Zama",        "Zanita",      "Zarina",     "Zelinda",    "Zenobia",    "Zita",      "Zoe",
+    "Zosima"};
 }
diff --git a/src/modules/person/data/italian/ItalianFirstNamesFemales.h b/src/modules/person/data/italian/ItalianFirstNamesFemales.h
deleted file mode 100644
index 8947a17e8..000000000
--- a/src/modules/person/data/italian/ItalianFirstNamesFemales.h
+++ /dev/null
@@ -1,87 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> italianFirstNamesFemales = {
-    "Abbondanza", "Acilia",      "Ada",         "Adalberta",  "Adalgisa",   "Addolorata", "Adelaide",  "Adelasia",
-    "Adele",      "Adelina",     "Adina",       "Adria",      "Adriana",    "Agape",      "Agata",     "Agnese",
-    "Agostina",   "Aida",        "Alba",        "Alberta",    "Albina",     "Alcina",     "Alda",      "Alessandra",
-    "Alessia",    "Alfonsa",     "Alfreda",     "Alice",      "Alida",      "Alina",      "Allegra",   "Alma",
-    "Altea",      "Amalia",      "Amanda",      "Amata",      "Ambra",      "Amelia",     "Amina",     "Anastasia",
-    "Anatolia",   "Ancilla",     "Andromeda",   "Angela",     "Angelica",   "Anita",      "Anna",      "Annabella",
-    "Annagrazia", "Annamaria",   "Annunziata",  "Antea",      "Antigone",   "Antonella",  "Antonia",   "Apollina",
-    "Apollonia",  "Appia",       "Arabella",    "Argelia",    "Arianna",    "Armida",     "Artemisa",  "Asella",
-    "Asia",       "Assunta",     "Astrid",      "Atanasia",   "Aurelia",    "Aurora",     "Ausilia",   "Ausiliatrice",
-    "Ave",        "Aza",         "Azelia",      "Azzurra",    "Babila",     "Bambina",    "Barbara",   "Bartolomea",
-    "Basilia",    "Bassilla",    "Batilda",     "Beata",      "Beatrice",   "Belina",     "Benedetta", "Beniamina",
-    "Benigna",    "Benvenuta",   "Berenice",    "Bernadetta", "Betta",      "Bianca",     "Bibiana",   "Bice",
-    "Brigida",    "Brigitta",    "Bruna",       "Brunilde",   "Calogera",   "Calpurnia",  "Camelia",   "Camilla",
-    "Candida",    "Capitolina",  "Carina",      "Carla",      "Carlotta",   "Carmela",    "Carmen",    "Carola",
-    "Carolina",   "Casilda",     "Casimira",    "Cassandra",  "Cassiopea",  "Catena",     "Caterina",  "Cecilia",
-    "Celeste",    "Celinia",     "Chiara",      "Cinzia",     "Cirilla",    "Clara",      "Claudia",   "Clelia",
-    "Clemenzia",  "Cleo",        "Cleofe",      "Cleopatra",  "Cloe",       "Clorinda",   "Cointa",    "Colomba",
-    "Concetta",   "Consolata",   "Cora",        "Cordelia",   "Corinna",    "Cornelia",   "Cosima",    "Costanza",
-    "Crescenzia", "Cristiana",   "Cristina",    "Crocefissa", "Cronida",    "Cunegonda",  "Cuzia",     "Dafne",
-    "Dalida",     "Dalila",      "Damiana",     "Daniela",    "Daria",      "Deanna",     "Debora",    "Degna",
-    "Delfina",    "Delia",       "Delinda",     "Delizia",    "Demetria",   "Deodata",    "Desdemona", "Desiderata",
-    "Devota",     "Diamante",    "Diana",       "Dianora",    "Diletta",    "Dina",       "Diodata",   "Dionisia",
-    "Doda",       "Dolores",     "Domenica",    "Donata",     "Donatella",  "Donna",      "Dora",      "Dorotea",
-    "Druina",     "Dulina",      "Ebe",         "Edda",       "Edelberga",  "Editta",     "Edvige",    "Egizia",
-    "Egle",       "Elaide",      "Elda",        "Elena",      "Eleonora",   "Elettra",    "Eliana",    "Elide",
-    "Elimena",    "Elisa",       "Elisabetta",  "Elisea",     "Ella",       "Eloisa",     "Elsa",      "Elvia",
-    "Elvira",     "Emanuela",    "Emilia",      "Emiliana",   "Emma",       "Enimia",     "Enrica",    "Eracla",
-    "Ermelinda",  "Ermenegarda", "Ermenegilda", "Erminia",    "Ernesta",    "Ersilia",    "Esmeralda", "Estella",
-    "Ester",      "Esterina",    "Eufemia",     "Eufrasia",   "Eugenia",    "Eulalia",    "Euridice",  "Eusebia",
-    "Eutalia",    "Eva",         "Evangelina",  "Evelina",    "Fabiana",    "Fabiola",    "Fatima",    "Fausta",
-    "Federica",   "Fedora",      "Felicia",     "Felicita",   "Fernanda",   "Fiammetta",  "Filippa",   "Filomena",
-    "Fiordaliso", "Fiore",       "Fiorella",    "Fiorenza",   "Flaminia",   "Flavia",     "Flaviana",  "Flora",
-    "Floriana",   "Floridia",    "Florina",     "Foca",       "Fortunata",  "Fosca",      "Franca",    "Francesca",
-    "Fulvia",     "Gabriella",   "Gaia",        "Galatea",    "Gaudenzia",  "Gelsomina",  "Geltrude",  "Gemma",
-    "Generosa",   "Genesia",     "Genoveffa",   "Germana",    "Gertrude",   "Ghita",      "Giacinta",  "Giada",
-    "Gigliola",   "Gilda",       "Giliola",     "Ginevra",    "Gioacchina", "Gioconda",   "Gioia",     "Giorgia",
-    "Giovanna",   "Gisella",     "Giuditta",    "Giulia",     "Giuliana",   "Giulitta",   "Giuseppa",  "Giuseppina",
-    "Giusta",     "Glenda",      "Gloria",      "Godeberta",  "Godiva",     "Grazia",     "Graziana",  "Graziella",
-    "Greta",      "Griselda",    "Guenda",      "Guendalina", "Gundelinda", "Ianira",     "Ida",       "Idea",
-    "Iginia",     "Ilaria",      "Ilda",        "Ildegarda",  "Ildegonda",  "Ileana",     "Ilenia",    "Ilia",
-    "Ilva",       "Imelda",      "Immacolata",  "Incoronata", "Ines",       "Innocenza",  "Iolanda",   "Iole",
-    "Iona",       "Ione",        "Ionne",       "Irene",      "Iride",      "Iris",       "Irma",      "Irmina",
-    "Isa",        "Isabella",    "Iside",       "Isidora",    "Isotta",     "Italia",     "Ivetta",    "Lara",
-    "Laura",      "Lavinia",     "Lea",         "Leda",       "Lelia",      "Lena",       "Leonia",    "Leonilda",
-    "Leontina",   "Letizia",     "Lia",         "Liana",      "Liberata",   "Liboria",    "Licia",     "Lidania",
-    "Lidia",      "Liliana",     "Linda",       "Lisa",       "Livia",      "Liviana",    "Lodovica",  "Loredana",
-    "Lorella",    "Lorena",      "Lorenza",     "Loretta",    "Loriana",    "Luana",      "Luce",      "Lucia",
-    "Luciana",    "Lucilla",     "Lucrezia",    "Ludovica",   "Luigia",     "Luisa",      "Luminosa",  "Luna",
-    "Macaria",    "Maddalena",   "Mafalda",     "Magda",      "Maida",      "Manuela",    "Mara",      "Marana",
-    "Marcella",   "Mareta",      "Margherita",  "Maria",      "Marianna",   "Marica",     "Mariella",  "Marilena",
-    "Marina",     "Marinella",   "Marinetta",   "Marisa",     "Marita",     "Marta",      "Martina",   "Maruta",
-    "Marzia",     "Massima",     "Matilde",     "Maura",      "Melania",    "Melissa",    "Melitina",  "Menodora",
-    "Mercede",    "Messalina",   "Mia",         "Michela",    "Milena",     "Mimma",      "Mina",      "Minerva",
-    "Minervina",  "Miranda",     "Mirella",     "Miriam",     "Mirta",      "Moira",      "Monica",    "Morena",
-    "Morgana",    "Nadia",       "Natalia",     "Natalina",   "Neiva",      "Nerea",      "Nicla",     "Nicoletta",
-    "Nilde",      "Nina",        "Ninfa",       "Nives",      "Noemi",      "Norina",     "Norma",     "Novella",
-    "Nuccia",     "Nunziata",    "Odetta",      "Odilia",     "Ofelia",     "Olga",       "Olimpia",   "Olinda",
-    "Olivia",     "Oliviera",    "Ombretta",    "Ondina",     "Onesta",     "Onorata",    "Onorina",   "Orchidea",
-    "Oriana",     "Orietta",     "Ornella",     "Orsola",     "Orsolina",   "Ortensia",   "Osanna",    "Otilia",
-    "Ottilia",    "Palladia",    "Palmazio",    "Palmira",    "Pamela",     "Paola",      "Patrizia",  "Pelagia",
-    "Penelope",   "Perla",       "Petronilla",  "Pia",        "Piera",      "Placida",    "Polissena", "Porzia",
-    "Prisca",     "Priscilla",   "Proserpina",  "Prospera",   "Prudenzia",  "Quartilla",  "Quieta",    "Quiteria",
-    "Rachele",    "Raffaella",   "Rainelda",    "Rebecca",    "Regina",     "Renata",     "Riccarda",  "Rina",
-    "Rita",       "Roberta",     "Romana",      "Romilda",    "Romina",     "Romola",     "Rosa",      "Rosalia",
-    "Rosalinda",  "Rosamunda",   "Rosanna",     "Rosita",     "Rosmunda",   "Rossana",    "Rossella",  "Rufina",
-    "Saba",       "Sabina",      "Sabrina",     "Samanta",    "Samona",     "Sandra",     "Santina",   "Sara",
-    "Savina",     "Scolastica",  "Sebastiana",  "Seconda",    "Secondina",  "Sefora",     "Selene",    "Selvaggia",
-    "Semiramide", "Serafina",    "Serena",      "Severa",     "Sibilla",    "Sidonia",    "Silvana",   "Silvia",
-    "Simona",     "Simonetta",   "Siria",       "Smeralda",   "Soave",      "Sofia",      "Sofronia",  "Solange",
-    "Sonia",      "Speranza",    "Stefania",    "Stella",     "Susanna",    "Sveva",      "Tabita",    "Tamara",
-    "Tarquinia",  "Tarsilla",    "Taziana",     "Tea",        "Tecla",      "Telica",     "Teodata",   "Teodolinda",
-    "Teodora",    "Teresa",      "Teudosia",    "Tina",       "Tiziana",    "Tosca",      "Trasea",    "Tullia",
-    "Ugolina",    "Ulfa",        "Uliva",       "Unna",       "Vala",       "Valentina",  "Valeria",   "Valeriana",
-    "Vanda",      "Vanessa",     "Vanna",       "Venera",     "Veneranda",  "Venere",     "Venusta",   "Vera",
-    "Verdiana",   "Verena",      "Veriana",     "Veridiana",  "Veronica",   "Viliana",    "Vilma",     "Vincenza",
-    "Viola",      "Violante",    "Virginia",    "Vissia",     "Vittoria",   "Viviana",    "Wanda",     "Zabina",
-    "Zaira",      "Zama",        "Zanita",      "Zarina",     "Zelinda",    "Zenobia",    "Zita",      "Zoe",
-    "Zosima"};
-}
diff --git a/src/modules/person/data/italian/ItalianPeopleNames.h b/src/modules/person/data/italian/ItalianPeopleNames.h
new file mode 100644
index 000000000..c5da67466
--- /dev/null
+++ b/src/modules/person/data/italian/ItalianPeopleNames.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "ItalianFirstNames.h"
+#include "ItalianLastNames.h"
+#include "ItalianPrefixes.h"
+
+namespace faker
+{
+const NameFormats italianPersonNameFormats{{{"{prefix} {firstName} {lastName}", 1}, {"{firstName} {lastName}", 9}}};
+
+const PeopleNames italianPeopleNames{{italianMalesFirstNames, {}, italianLastNames, italianPrefixes, {}},
+                                     {italianFemalesFirstNames, {}, italianLastNames, italianPrefixes, {}},
+                                     italianPersonNameFormats};
+
+}
diff --git a/src/modules/person/data/italian/ItalianPrefixes.h b/src/modules/person/data/italian/ItalianPrefixes.h
new file mode 100644
index 000000000..40da282ad
--- /dev/null
+++ b/src/modules/person/data/italian/ItalianPrefixes.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> italianPrefixes{"Sig.", "Dott.", "Dr.", "Ing."};
+}
diff --git a/src/modules/person/data/nepalese/NepaleseFirstNames.h b/src/modules/person/data/nepalese/NepaleseFirstNames.h
new file mode 100644
index 000000000..6938fd4ce
--- /dev/null
+++ b/src/modules/person/data/nepalese/NepaleseFirstNames.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> nepaleseMalesFirstNames = {
+
+    "Sijan",    "Prabesh", "Niwang",  "Nabin",    "Sanjok",   "Bibek",  "Sujal",    "Sagar",  "Mukunda", "Arun",
+    "Nirdesh",  "Rabin",   "Ramesh",  "Manoj",    "Bimal",    "Anil",   "Bipin",    "Gopal",  "Sunil",   "Bikash",
+    "Sujan",    "Sudeep",  "Nikhil",  "Nishant",  "Kiran",    "Pramod", "Saroj",    "Rajesh", "Dilip",   "Sandesh",
+    "Krishna",  "Hari",    "Suresh",  "Arjun",    "Bibash",   "Rajiv",  "Rajendra", "Bijay",  "Aashish", "Raju",
+    "Sabin",    "Keshav",  "Rabi",    "Sanjeev",  "Puspa",    "Saroj",  "Khem",     "Shiva",  "Mohan",   "Dinesh",
+    "Rajendra", "Suman",   "Ujjwal",  "Bhuwan",   "Birendra", "Birat",  "Lalit",    "Bhola",  "Pradip",  "Nabin",
+    "Suman",    "Shankar", "Laxman",  "Sushant",  "Roshan",   "Buddha", "Kapil",    "Rajbir", "Suraj",   "Manish",
+    "Ajay",     "Dipak",   "Anish",   "Sabin",    "Prem",     "Bijay",  "Narayan",  "Rajat",  "Rishi",   "Yogesh",
+    "Rajendra", "Pawan",   "Bhawesh", "Pramod",   "Pramod",   "Saurav", "Hemant",   "Subash", "Sparsha", "Sabin",
+    "Manohar",  "Anuj",    "Aryan",   "Yogendra", "Nischal",  "Samir",  "Sanjay",   "Bijay",  "Rohit",   "Rajat",
+    "Biraj",    "Kiran",   "Pravin",  "Pramod"
+
+};
+
+const std::vector<std::string> nepaleseFemalesFirstNames = {
+
+    "Sita",     "Gita",      "Shristi",  "Anita",   "Priya",     "Sabina",   "Nisha",    "Saraswati",
+    "Asha",     "Binita",    "Deepa",    "Kamala",  "Laxmi",     "Rina",     "Bishnu",   "Meera",
+    "Sushma",   "Pooja",     "Rajani",   "Sunita",  "Nirmala",   "Rita",     "Sumitra",  "Usha",
+    "Manisha",  "Rekha",     "Sarita",   "Kusum",   "Puja",      "Sanjana",  "Smriti",   "Pratima",
+    "Sabita",   "Kanchan",   "Nandita",  "Anjali",  "Harsha",    "Sangita",  "Sushmita", "Suman",
+    "Sweta",    "Sadhana",   "Anju",     "Nabina",  "Bhawana",   "Srijana",  "Nikita",   "Aarati",
+    "Anita",    "Nitu",      "Sima",     "Sita",    "Goma",      "Sarala",   "Sarika",   "Sabita",
+    "Madhavi",  "Indira",    "Ankita",   "Bhumika", "Neha",      "Ashmita",  "Subiksha", "Supriya",
+    "Urmila",   "Shova",     "Shruti",   "Ruby",    "Samjhana",  "Prakriti", "Ashika",   "Reecha",
+    "Yamuna",   "Sunaina",   "Sujata",   "Muna",    "Sulochana", "Jamuna",   "Anshu",    "Sarala",
+    "Sarika",   "Puspa",     "Manju",    "Sadhana", "Pabitra",   "Usha",     "Manita",   "Rekha",
+    "Swastika", "Priyanka",  "Sharmila", "Manju",   "Sudha",     "Laxmi",    "Sunita",   "Tulsi",
+    "Usha",     "Saraswati", "Rachana"
+
+};
+}
diff --git a/src/modules/person/data/nepalese/NepaleseFirstNamesFemales.h b/src/modules/person/data/nepalese/NepaleseFirstNamesFemales.h
deleted file mode 100644
index 76c28bf3e..000000000
--- a/src/modules/person/data/nepalese/NepaleseFirstNamesFemales.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> nepaleseFirstNamesFemales = {
-
-    "Sita",     "Gita",      "Shristi",  "Anita",   "Priya",     "Sabina",   "Nisha",    "Saraswati",
-    "Asha",     "Binita",    "Deepa",    "Kamala",  "Laxmi",     "Rina",     "Bishnu",   "Meera",
-    "Sushma",   "Pooja",     "Rajani",   "Sunita",  "Nirmala",   "Rita",     "Sumitra",  "Usha",
-    "Manisha",  "Rekha",     "Sarita",   "Kusum",   "Puja",      "Sanjana",  "Smriti",   "Pratima",
-    "Sabita",   "Kanchan",   "Nandita",  "Anjali",  "Harsha",    "Sangita",  "Sushmita", "Suman",
-    "Sweta",    "Sadhana",   "Anju",     "Nabina",  "Bhawana",   "Srijana",  "Nikita",   "Aarati",
-    "Anita",    "Nitu",      "Sima",     "Sita",    "Goma",      "Sarala",   "Sarika",   "Sabita",
-    "Madhavi",  "Indira",    "Ankita",   "Bhumika", "Neha",      "Ashmita",  "Subiksha", "Supriya",
-    "Urmila",   "Shova",     "Shruti",   "Ruby",    "Samjhana",  "Prakriti", "Ashika",   "Reecha",
-    "Yamuna",   "Sunaina",   "Sujata",   "Muna",    "Sulochana", "Jamuna",   "Anshu",    "Sarala",
-    "Sarika",   "Puspa",     "Manju",    "Sadhana", "Pabitra",   "Usha",     "Manita",   "Rekha",
-    "Swastika", "Priyanka",  "Sharmila", "Manju",   "Sudha",     "Laxmi",    "Sunita",   "Tulsi",
-    "Usha",     "Saraswati", "Rachana"
-
-};
-}
diff --git a/src/modules/person/data/nepalese/NepaleseFirstNamesMales.h b/src/modules/person/data/nepalese/NepaleseFirstNamesMales.h
deleted file mode 100644
index 4e7413f1e..000000000
--- a/src/modules/person/data/nepalese/NepaleseFirstNamesMales.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-
-const std::vector<std::string> nepaleseFirstNamesMales = {
-
-    "Sijan",    "Prabesh", "Niwang",  "Nabin",    "Sanjok",   "Bibek",  "Sujal",    "Sagar",  "Mukunda", "Arun",
-    "Nirdesh",  "Rabin",   "Ramesh",  "Manoj",    "Bimal",    "Anil",   "Bipin",    "Gopal",  "Sunil",   "Bikash",
-    "Sujan",    "Sudeep",  "Nikhil",  "Nishant",  "Kiran",    "Pramod", "Saroj",    "Rajesh", "Dilip",   "Sandesh",
-    "Krishna",  "Hari",    "Suresh",  "Arjun",    "Bibash",   "Rajiv",  "Rajendra", "Bijay",  "Aashish", "Raju",
-    "Sabin",    "Keshav",  "Rabi",    "Sanjeev",  "Puspa",    "Saroj",  "Khem",     "Shiva",  "Mohan",   "Dinesh",
-    "Rajendra", "Suman",   "Ujjwal",  "Bhuwan",   "Birendra", "Birat",  "Lalit",    "Bhola",  "Pradip",  "Nabin",
-    "Suman",    "Shankar", "Laxman",  "Sushant",  "Roshan",   "Buddha", "Kapil",    "Rajbir", "Suraj",   "Manish",
-    "Ajay",     "Dipak",   "Anish",   "Sabin",    "Prem",     "Bijay",  "Narayan",  "Rajat",  "Rishi",   "Yogesh",
-    "Rajendra", "Pawan",   "Bhawesh", "Pramod",   "Pramod",   "Saurav", "Hemant",   "Subash", "Sparsha", "Sabin",
-    "Manohar",  "Anuj",    "Aryan",   "Yogendra", "Nischal",  "Samir",  "Sanjay",   "Bijay",  "Rohit",   "Rajat",
-    "Biraj",    "Kiran",   "Pravin",  "Pramod"
-
-};
-
-}
diff --git a/src/modules/person/data/nepalese/NepalesePeopleNames.h b/src/modules/person/data/nepalese/NepalesePeopleNames.h
new file mode 100644
index 000000000..130f26759
--- /dev/null
+++ b/src/modules/person/data/nepalese/NepalesePeopleNames.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "NepaleseFirstNames.h"
+#include "NepaleseLastNames.h"
+
+namespace faker
+{
+const NameFormats nepalesePersonNameFormats{{"{firstName} {lastName}", 1}};
+
+const PeopleNames nepalesePeopleNames{{nepaleseMalesFirstNames, {}, nepaleseLastNames, {}, {}},
+                                      {nepaleseFemalesFirstNames, {}, nepaleseLastNames, {}, {}},
+                                      nepalesePersonNameFormats};
+}
diff --git a/src/modules/person/data/polish/PolishFirstNamesMales.h b/src/modules/person/data/polish/PolishFirstNames.h
similarity index 59%
rename from src/modules/person/data/polish/PolishFirstNamesMales.h
rename to src/modules/person/data/polish/PolishFirstNames.h
index 1c982ecfa..54c2cb5eb 100644
--- a/src/modules/person/data/polish/PolishFirstNamesMales.h
+++ b/src/modules/person/data/polish/PolishFirstNames.h
@@ -5,7 +5,7 @@
 
 namespace faker
 {
-const std::vector<std::string> polishFirstNamesMales = {
+const std::vector<std::string> polishMalesFirstNames = {
     "Aaron",      "Abraham",     "Adam",        "Adrian",     "Atanazy",    "Agaton",      "Alan",       "Albert",
     "Aleksander", "Aleksy",      "Alfred",      "Alwar",      "Ambroży",    "Anatol",      "Andrzej",    "Antoni",
     "Apollinary", "Apollo",      "Arkady",      "Arkadiusz",  "Archibald",  "Arystarch",   "Arnold",     "Arseniusz",
@@ -35,4 +35,27 @@ const std::vector<std::string> polishFirstNamesMales = {
     "Tomasz",     "Tymoteusz",   "Tobiasz",     "Walenty",    "Walentyn",   "Walerian",    "Walery",     "Wiktor",
     "Wincenty",   "Witalis",     "Włodzimierz", "Władysław",  "Błażej",     "Walter",      "Walgierz",   "Wacław",
     "Wilfryd",    "Wilhelm",     "Ksawery",     "Ksenofont",  "Zachariasz", "Zachary"};
+
+const std::vector<std::string> polishFemalesFirstNames = {
+    "Ada",        "Adelajda",   "Agata",     "Agnieszka", "Agrypina",   "Aida",      "Aleksandra", "Alicja",
+    "Alina",      "Amanda",     "Anastazja", "Angela",    "Andżelika",  "Angelina",  "Anna",       "Hanna",
+    "Antonina",   "Ariadna",    "Aurora",    "Barbara",   "Beatrycze",  "Berta",     "Brygida",    "Kamila",
+    "Karolina",   "Kornelia",   "Katarzyna", "Cecylia",   "Chloe",      "Krystyna",  "Klara",      "Klaudia",
+    "Klementyna", "Konstancja", "Koralia",   "Daria",     "Diana",      "Dina",      "Dorota",     "Edyta",
+    "Eleonora",   "Eliza",      "Elżbieta",  "Izabela",   "Elwira",     "Emilia",    "Estera",     "Eudoksja",
+    "Eudokia",    "Eugenia",    "Ewa",       "Ewelina",   "Ferdynanda", "Florencja", "Franciszka", "Gabriela",
+    "Gertruda",   "Gloria",     "Gracja",    "Jadwiga",   "Helena",     "Henryka",   "Nadzieja",   "Ida",
+    "Ilona",      "Irena",      "Irma",      "Izolda",    "Jakubina",   "Joanna",    "Janina",     "Żaneta",
+    "Ginewra",    "Józefina",   "Judyta",    "Julia",     "Julita",     "Justyna",   "Kira",       "Cyra",
+    "Kleopatra",  "Larysa",     "Laura",     "Laurencja", "Laurentyna", "Lea",       "Leila",      "Liliana",
+    "Lilianna",   "Lilia",      "Lilla",     "Liza",      "Ludwika",    "Luiza",     "Łucja",      "Lucja",
+    "Lidia",      "Amabela",    "Magdalena", "Malwina",   "Małgorzata", "Greta",     "Marianna",   "Maryna",
+    "Marta",      "Martyna",    "Maria",     "Matylda",   "Maja",       "Melania",   "Michalina",  "Monika",
+    "Noemi",      "Natalia",    "Nikola",    "Nina",      "Olga",       "Olimpia",   "Oliwia",     "Ofelia",
+    "Patrycja",   "Paula",      "Pelagia",   "Penelopa",  "Filipa",     "Paulina",   "Rachela",    "Rebeka",
+    "Regina",     "Renata",     "Rozalia",   "Róża",      "Roksana",    "Rufina",    "Ruta",       "Sabina",
+    "Sara",       "Serafina",   "Sybilla",   "Sylwia",    "Zofia",      "Stella",    "Stefania",   "Zuzanna",
+    "Tamara",     "Tacjana",    "Tekla",     "Teodora",   "Teresa",     "Walentyna", "Waleria",    "Wanesa",
+    "Wiara",      "Weronika",   "Wiktoria",  "Wirginia",  "Bibiana",    "Bibianna",  "Wanda",      "Wilhelmina",
+    "Ksawera",    "Ksenia",     "Zoe"};
 }
diff --git a/src/modules/person/data/polish/PolishFirstNamesFemales.h b/src/modules/person/data/polish/PolishFirstNamesFemales.h
deleted file mode 100644
index 8d75c957e..000000000
--- a/src/modules/person/data/polish/PolishFirstNamesFemales.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> polishFirstNamesFemales = {
-    "Ada",        "Adelajda",   "Agata",     "Agnieszka", "Agrypina",   "Aida",      "Aleksandra", "Alicja",
-    "Alina",      "Amanda",     "Anastazja", "Angela",    "Andżelika",  "Angelina",  "Anna",       "Hanna",
-    "Antonina",   "Ariadna",    "Aurora",    "Barbara",   "Beatrycze",  "Berta",     "Brygida",    "Kamila",
-    "Karolina",   "Kornelia",   "Katarzyna", "Cecylia",   "Chloe",      "Krystyna",  "Klara",      "Klaudia",
-    "Klementyna", "Konstancja", "Koralia",   "Daria",     "Diana",      "Dina",      "Dorota",     "Edyta",
-    "Eleonora",   "Eliza",      "Elżbieta",  "Izabela",   "Elwira",     "Emilia",    "Estera",     "Eudoksja",
-    "Eudokia",    "Eugenia",    "Ewa",       "Ewelina",   "Ferdynanda", "Florencja", "Franciszka", "Gabriela",
-    "Gertruda",   "Gloria",     "Gracja",    "Jadwiga",   "Helena",     "Henryka",   "Nadzieja",   "Ida",
-    "Ilona",      "Irena",      "Irma",      "Izolda",    "Jakubina",   "Joanna",    "Janina",     "Żaneta",
-    "Ginewra",    "Józefina",   "Judyta",    "Julia",     "Julita",     "Justyna",   "Kira",       "Cyra",
-    "Kleopatra",  "Larysa",     "Laura",     "Laurencja", "Laurentyna", "Lea",       "Leila",      "Liliana",
-    "Lilianna",   "Lilia",      "Lilla",     "Liza",      "Ludwika",    "Luiza",     "Łucja",      "Lucja",
-    "Lidia",      "Amabela",    "Magdalena", "Malwina",   "Małgorzata", "Greta",     "Marianna",   "Maryna",
-    "Marta",      "Martyna",    "Maria",     "Matylda",   "Maja",       "Melania",   "Michalina",  "Monika",
-    "Noemi",      "Natalia",    "Nikola",    "Nina",      "Olga",       "Olimpia",   "Oliwia",     "Ofelia",
-    "Patrycja",   "Paula",      "Pelagia",   "Penelopa",  "Filipa",     "Paulina",   "Rachela",    "Rebeka",
-    "Regina",     "Renata",     "Rozalia",   "Róża",      "Roksana",    "Rufina",    "Ruta",       "Sabina",
-    "Sara",       "Serafina",   "Sybilla",   "Sylwia",    "Zofia",      "Stella",    "Stefania",   "Zuzanna",
-    "Tamara",     "Tacjana",    "Tekla",     "Teodora",   "Teresa",     "Walentyna", "Waleria",    "Wanesa",
-    "Wiara",      "Weronika",   "Wiktoria",  "Wirginia",  "Bibiana",    "Bibianna",  "Wanda",      "Wilhelmina",
-    "Ksawera",    "Ksenia",     "Zoe"};
-}
diff --git a/src/modules/person/data/polish/PolishPeopleNames.h b/src/modules/person/data/polish/PolishPeopleNames.h
new file mode 100644
index 000000000..23b08748b
--- /dev/null
+++ b/src/modules/person/data/polish/PolishPeopleNames.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "PolishFirstNames.h"
+#include "PolishLastNames.h"
+#include "PolishPrefixes.h"
+
+namespace faker
+{
+const NameFormats polishPersonNameFormats{{{"{prefix} {firstName} {lastName}", 1}, {"{firstName} {lastName}", 9}}};
+
+const PeopleNames polishPeopleNames{{polishMalesFirstNames, {}, polishLastNames, polishMalesPrefixes, {}},
+                                    {polishFemalesFirstNames, {}, polishLastNames, polishFemalesPrefixes, {}},
+                                    polishPersonNameFormats};
+
+}
diff --git a/src/modules/person/data/polish/PolishPrefixes.h b/src/modules/person/data/polish/PolishPrefixes.h
new file mode 100644
index 000000000..116a045a0
--- /dev/null
+++ b/src/modules/person/data/polish/PolishPrefixes.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> polishMalesPrefixes{"Pan"};
+
+const std::vector<std::string> polishFemalesPrefixes{"Pani"};
+}
diff --git a/src/modules/person/data/romanian/RomanianFirstNamesMales.h b/src/modules/person/data/romanian/RomanianFirstNames.h
similarity index 50%
rename from src/modules/person/data/romanian/RomanianFirstNamesMales.h
rename to src/modules/person/data/romanian/RomanianFirstNames.h
index e1507afab..8f8f600ed 100644
--- a/src/modules/person/data/romanian/RomanianFirstNamesMales.h
+++ b/src/modules/person/data/romanian/RomanianFirstNames.h
@@ -5,7 +5,7 @@
 
 namespace faker
 {
-const std::vector<std::string> romanianFirstNamesMales = {
+const std::vector<std::string> romanianMalesFirstNames = {
     "Ion",      "Mihai",     "Andrei",   "Alexandru",  "George",    "Cristian",  "Florin",     "Răzvan",   "Lucian",
     "Adrian",   "Vlad",      "Gheorghe", "Constantin", "Daniel",    "Bogdan",    "Eduard",     "Valentin", "Gabriel",
     "Dumitru",  "Radu",      "Ștefan",   "Marin",      "Marian",    "Victor",    "Raul",       "Valeriu",  "Cosmin",
@@ -15,4 +15,14 @@ const std::vector<std::string> romanianFirstNamesMales = {
     "Matei",    "Sebastian", "Șerban",   "Viorel",     "Laurențiu", "Laurentiu", "Alin",       "Gavril",   "Ovidiu",
     "Sorin",    "Tiberiu",
 };
-}
\ No newline at end of file
+
+const std::vector<std::string> romanianFemalesFirstNames = {
+    "Maria",    "Ioana",     "Elena",   "Ana",      "Cristina", "Andreea",   "Georgiana", "Alexandra", "Laura",
+    "Diana",    "Raluca",    "Mihaela", "Larisa",   "Monica",   "Alina",     "Simona",    "Gabriela",  "Roxana",
+    "Denisa",   "Camelia",   "Adriana", "Nicoleta", "Mariana",  "Carmen",    "Loredana",  "Irina",     "Liliana",
+    "Eva",      "Elisabeta", "Aurelia", "Cătălina", "Silvia",   "Ana-Maria", "Doina",     "Florina",   "Magdalena",
+    "Stefania", "Valentina", "Iuliana", "Ruxandra", "Georgeta", "Marilena",  "Lidia",     "Anda",      "Marinela",
+    "Mirela",   "Flavia",    "Claudia", "Viorica",  "Sorina",   "Ramona",    "Sorana",    "Floriana",  "Livia",
+    "Teodora",  "Magda",     "Marina",  "Dana",     "Lavinia",  "Anca",      "Delia",     "Daria",     "Oana",
+};
+}
diff --git a/src/modules/person/data/romanian/RomanianFirstNamesFemales.h b/src/modules/person/data/romanian/RomanianFirstNamesFemales.h
deleted file mode 100644
index 2047fb6d3..000000000
--- a/src/modules/person/data/romanian/RomanianFirstNamesFemales.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> romanianFirstNamesFemales = {
-    "Maria",    "Ioana",     "Elena",   "Ana",      "Cristina", "Andreea",   "Georgiana", "Alexandra", "Laura",
-    "Diana",    "Raluca",    "Mihaela", "Larisa",   "Monica",   "Alina",     "Simona",    "Gabriela",  "Roxana",
-    "Denisa",   "Camelia",   "Adriana", "Nicoleta", "Mariana",  "Carmen",    "Loredana",  "Irina",     "Liliana",
-    "Eva",      "Elisabeta", "Aurelia", "Cătălina", "Silvia",   "Ana-Maria", "Doina",     "Florina",   "Magdalena",
-    "Stefania", "Valentina", "Iuliana", "Ruxandra", "Georgeta", "Marilena",  "Lidia",     "Anda",      "Marinela",
-    "Mirela",   "Flavia",    "Claudia", "Viorica",  "Sorina",   "Ramona",    "Sorana",    "Floriana",  "Livia",
-    "Teodora",  "Magda",     "Marina",  "Dana",     "Lavinia",  "Anca",      "Delia",     "Daria",     "Oana",
-};
-}
diff --git a/src/modules/person/data/romanian/RomanianPeopleNames.h b/src/modules/person/data/romanian/RomanianPeopleNames.h
new file mode 100644
index 000000000..e4b3b3d8a
--- /dev/null
+++ b/src/modules/person/data/romanian/RomanianPeopleNames.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "RomanianFirstNames.h"
+#include "RomanianLastNames.h"
+#include "RomanianPrefixes.h"
+#include "RomanianSuffixes.h"
+
+namespace faker
+{
+const NameFormats romanianPersonNameFormats{{{"{firstName} {lastName}", 49},
+                                             {"{lastName} {firstName}", 7},
+                                             {"{prefix} {firstName} {lastName}", 7},
+                                             {"{firstName} {lastName} {suffix}", 7},
+                                             {"{prefix} {firstName} {lastName} {suffix}", 1}}};
+
+const PeopleNames romanianPeopleNames{
+    {romanianMalesFirstNames, {}, romanianLastNames, romanianMalesPrefixes, romanianSuffixes},
+    {romanianFemalesFirstNames, {}, romanianLastNames, romanianFemalesPrefixes, romanianSuffixes},
+    romanianPersonNameFormats};
+
+}
diff --git a/src/modules/person/data/romanian/RomanianPrefixes.h b/src/modules/person/data/romanian/RomanianPrefixes.h
new file mode 100644
index 000000000..aee490a87
--- /dev/null
+++ b/src/modules/person/data/romanian/RomanianPrefixes.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> romanianMalesPrefixes{"Dl", "Dra"};
+
+const std::vector<std::string> romanianFemalesPrefixes{"Dna", "Dra"};
+}
diff --git a/src/modules/person/data/romanian/RomanianSuffixes.h b/src/modules/person/data/romanian/RomanianSuffixes.h
new file mode 100644
index 000000000..530f177e6
--- /dev/null
+++ b/src/modules/person/data/romanian/RomanianSuffixes.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> romanianSuffixes{"Jr.", "Sr."};
+}
diff --git a/src/modules/person/data/russian/RussianFirstNamesMales.h b/src/modules/person/data/russian/RussianFirstNames.h
similarity index 64%
rename from src/modules/person/data/russian/RussianFirstNamesMales.h
rename to src/modules/person/data/russian/RussianFirstNames.h
index b14909aec..bb794a014 100644
--- a/src/modules/person/data/russian/RussianFirstNamesMales.h
+++ b/src/modules/person/data/russian/RussianFirstNames.h
@@ -5,7 +5,7 @@
 
 namespace faker
 {
-const std::vector<std::string> russianFirstNamesMales = {
+const std::vector<std::string> russianMalesFirstNames = {
     "Авдей",      "Авксентий",  "Агапит",    "Агафон",    "Акакий",    "Акиндин",     "Александр", "Алексей",
     "Альберт",    "Анатолий",   "Андрей",    "Аникий",    "Аникита",   "Антон",       "Антонин",   "Анфим",
     "Аристарх",   "Аркадий",    "Арсений",   "Артём",     "Артемий",   "Артур",       "Архипп",    "Афанасий",
@@ -31,4 +31,20 @@ const std::vector<std::string> russianFirstNamesMales = {
     "Тимофей",    "Тимур",      "Тит",       "Тихон",     "Трифон",    "Трофим",      "Урбан",     "Фаддей",
     "Фёдор",      "Федосей",    "Федот",     "Феликс",    "Феоктист",  "Филат",       "Филимон",   "Филипп",
     "Фирс",       "Фока",       "Фома",      "Фотий",     "Фрол",      "Харитон",     "Хрисанф",   "Христофор"};
+
+const std::vector<std::string> russianFemalesFirstNames = {
+    "Агафья",    "Аглая",     "Агния",     "Агриппина", "Аза",        "Акулина",   "Алевтина",  "Александра",
+    "Алина",     "Алиса",     "Алла",      "Анастасия", "Ангелина",   "Анжела",    "Анжелика",  "Анна",
+    "Антонина",  "Анфиса",    "Валентина", "Валерия",   "Варвара",    "Василиса",  "Вера",      "Вероника",
+    "Виктория",  "Владимира", "Галина",    "Глафира",   "Гликерия",   "Дана",      "Дарья",     "Евгения",
+    "Евдокия",   "Евлалия",   "Евлампия",  "Евпраксия", "Евфросиния", "Екатерина", "Елена",     "Елизавета",
+    "Епистима",  "Ермиония",  "Жанна",     "Зинаида",   "Злата",      "Зоя",       "Инга",      "Инесса",
+    "Инна",      "Иоанна",    "Ираида",    "Ирина",     "Капитолина", "Карина",    "Каролина",  "Кира",
+    "Клавдия",   "Ксения",    "Лада",      "Лариса",    "Лидия",      "Лилия",     "Любовь",    "Людмила",
+    "Маргарита", "Марина",    "Мария",     "Марфа",     "Матрёна",    "Милана",    "Милица",    "Мирослава",
+    "Надежда",   "Наталья",   "Нина",      "Нонна",     "Оксана",     "Октябрина", "Олимпиада", "Ольга",
+    "Павлина",   "Пелагея",   "Пинна",     "Полина",    "Прасковья",  "Рада",      "Раиса",     "Регина",
+    "Римма",     "Рогнеда",   "Светлана",  "Серафима",  "Снежана",    "София",     "Сусанна",   "Таисия",
+    "Тамара",    "Татьяна",   "Улита",     "Ульяна",    "Урсула",     "Фаина",     "Феврония",  "Фёкла",
+    "Феодора",   "Целестина", "Элеонора",  "Юлия",      "Яна",        "Ярослава"};
 }
diff --git a/src/modules/person/data/russian/RussianFirstNamesFemales.h b/src/modules/person/data/russian/RussianFirstNamesFemales.h
deleted file mode 100644
index 9010aad7d..000000000
--- a/src/modules/person/data/russian/RussianFirstNamesFemales.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> russianFirstNamesFemales = {
-    "Агафья",    "Аглая",     "Агния",     "Агриппина", "Аза",        "Акулина",   "Алевтина",  "Александра",
-    "Алина",     "Алиса",     "Алла",      "Анастасия", "Ангелина",   "Анжела",    "Анжелика",  "Анна",
-    "Антонина",  "Анфиса",    "Валентина", "Валерия",   "Варвара",    "Василиса",  "Вера",      "Вероника",
-    "Виктория",  "Владимира", "Галина",    "Глафира",   "Гликерия",   "Дана",      "Дарья",     "Евгения",
-    "Евдокия",   "Евлалия",   "Евлампия",  "Евпраксия", "Евфросиния", "Екатерина", "Елена",     "Елизавета",
-    "Епистима",  "Ермиония",  "Жанна",     "Зинаида",   "Злата",      "Зоя",       "Инга",      "Инесса",
-    "Инна",      "Иоанна",    "Ираида",    "Ирина",     "Капитолина", "Карина",    "Каролина",  "Кира",
-    "Клавдия",   "Ксения",    "Лада",      "Лариса",    "Лидия",      "Лилия",     "Любовь",    "Людмила",
-    "Маргарита", "Марина",    "Мария",     "Марфа",     "Матрёна",    "Милана",    "Милица",    "Мирослава",
-    "Надежда",   "Наталья",   "Нина",      "Нонна",     "Оксана",     "Октябрина", "Олимпиада", "Ольга",
-    "Павлина",   "Пелагея",   "Пинна",     "Полина",    "Прасковья",  "Рада",      "Раиса",     "Регина",
-    "Римма",     "Рогнеда",   "Светлана",  "Серафима",  "Снежана",    "София",     "Сусанна",   "Таисия",
-    "Тамара",    "Татьяна",   "Улита",     "Ульяна",    "Урсула",     "Фаина",     "Феврония",  "Фёкла",
-    "Феодора",   "Целестина", "Элеонора",  "Юлия",      "Яна",        "Ярослава"};
-}
diff --git a/src/modules/person/data/russian/RussianLastNamesFemales.h b/src/modules/person/data/russian/RussianLastNames.h
similarity index 51%
rename from src/modules/person/data/russian/RussianLastNamesFemales.h
rename to src/modules/person/data/russian/RussianLastNames.h
index 5f87e8be3..4bfb5d753 100644
--- a/src/modules/person/data/russian/RussianLastNamesFemales.h
+++ b/src/modules/person/data/russian/RussianLastNames.h
@@ -5,7 +5,91 @@
 
 namespace faker
 {
-const std::vector<std::string> russianLastNamesFemales = {
+const std::vector<std::string> russianMalesLastNames = {
+    "Авдеев",     "Агапов",      "Агафонов",   "Агеев",       "Акимов",     "Аксёнов",      "Александров",
+    "Алексеев",   "Алёхин",      "Алешин",     "Алёшин",      "Ананьев",    "Андреев",      "Андрианов",
+    "Аникин",     "Анисимов",    "Анохин",     "Антипов",     "Антонов",    "Артамонов",    "Артёмов",
+    "Архипов",    "Астафьев",    "Астахов",    "Афанасьев",   "Бабушкин",   "Баженов",      "Балашов",
+    "Баранов",    "Барсуков",    "Басов",      "Безруков",    "Беликов",    "Белкин",       "Белов",
+    "Белоусов",   "Беляев",      "Беляков",    "Березин",     "Берия",      "Беспалов",     "Бессонов",
+    "Бирюков",    "Блинов",      "Блохин",     "Бобров",      "Богданов",   "Богомолов",    "Болдырев",
+    "Большаков",  "Бондарев",    "Борисов",    "Бородин",     "Бочаров",    "Булатов",      "Булгаков",
+    "Буров",      "Быков",       "Бычков",     "Вавилов",     "Вагин",      "Васильев",     "Вдовин",
+    "Верещагин",  "Вешняков",    "Виноградов", "Винокуров",   "Вишневский", "Владимиров",   "Власов",
+    "Волков",     "Волошин",     "Воробьёв",   "Воронин",     "Воронков",   "Воронов",      "Воронцов",
+    "Второв",     "Высоцкий",    "Гаврилов",   "Гайдуков",    "Гакабов",    "Галкин",       "Герасимов",
+    "Гладков",    "Глебов",      "Глухов",     "Глушков",     "Гноев",      "Голиков",      "Голованов",
+    "Головин",    "Голубев",     "Гончаров",   "Горбань",     "Горбачав",   "Горбачёв",     "Горбунов",
+    "Гордеев",    "Горелов",     "Горлов",     "Горохов",     "Горшков",    "Горюнов",      "Горячев",
+    "Грачёв",     "Греков",      "Грибков",    "Грибов",      "Григорьев",  "Гришин",       "Громов",
+    "Губанов",    "Гуляев",      "Гуров",      "Гусев",       "Гущин",      "Давыдов",      "Данилов",
+    "Дашков",     "Дегтярев",    "Дегтярёв",   "Дементьев",   "Демидов",    "Дёмин",        "Демьянов",
+    "Денисов",    "Дмитриев",    "Добрынин",   "Долгов",      "Дорофеев",   "Дорохов",      "Дроздов",
+    "Дружинин",   "Дубинин",     "Дубов",      "Дубровин",    "Дьяков",     "Дьяконов",     "Евдокимов",
+    "Евсеев",     "Егоров",      "Ежов",       "Елизаров",    "Елисеев",    "Ельцин",       "Емельянов",
+    "Еремеев",    "Ерёмин",      "Ермаков",    "Ермилов",     "Ермолаев",   "Ермолов",      "Еромлаев",
+    "Ерофеев",    "Ерохин",      "Ершов",      "Ефимов",      "Ефремов",    "Жаров",        "Жданов",
+    "Жилин",      "Жириновский", "Жуков",      "Журавлёв",    "Завьялов",   "Заец",         "Зайцев",
+    "Захаров",    "Зверев",      "Звягинцев",  "Зеленин",     "Зимин",      "Зиновьев",     "Злобин",
+    "Золотарев",  "Золотарёв",   "Золотов",    "Зорин",       "Зотов",      "Зубков",       "Зубов",
+    "Зуев",       "Зыков",       "Зюганов",    "Иванов",      "Ивашов",     "Игнатов",      "Игнатьев",
+    "Измайлов",   "Ильин",       "Ильинский",  "Ильюхин",     "Исаев",      "Исаков",       "Казаков",
+    "Казанцев",   "Калачев",     "Калачёв",    "Калашников",  "Калинин",    "Калмыков",     "Калугин",
+    "Капустин",   "Карасев",     "Карасёв",    "Карпов",      "Карташов",   "Касаткин",     "Касьянов",
+    "Киреев",     "Кириллов",    "Киселёв",    "Кислов",      "Климов",     "Клюев",        "Князев",
+    "Ковалёв",    "Коваленко",   "Коваль",     "Кожевников",  "Козин",      "Козлов",       "Козловский",
+    "Козырев",    "Колесников",  "Колесов",    "Колосов",     "Колпаков",   "Кольцов",      "Комаров",
+    "Комиссаров", "Кондратов",   "Кондратьев", "Кондрашов",   "Коновалов",  "Кононов",      "Константинов",
+    "Копылов",    "Корнев",      "Корнеев",    "Корнилов",    "Коровин",    "Королёв",      "Корольков",
+    "Коротков",   "Корчагин",    "Коршунов",   "Косарев",     "Костин",     "Котов",        "Кочергин",
+    "Кочетков",   "Кочетов",     "Кошелев",    "Кравцов",     "Краснов",    "Красоткин",    "Кролик",
+    "Кроликов",   "Круглов",     "Крылов",     "Крюков",      "Крючков",    "Кудрявцев",    "Кудряшов",
+    "Кузин",      "Кузнецов",    "Кузьмин",    "Кукушкин",    "Кулагин",    "Кулаков",      "Кулешов",
+    "Куликов",    "Куприянов",   "Курочкин",   "Лаврентьев",  "Лавров",     "Лазарев",      "Лапин",
+    "Лаптев",     "Лапшин",      "Ларин",      "Ларионов",    "Латышев",    "Лебедев",      "Левин",
+    "Леонов",     "Леонтьев",    "Литвинов",   "Лобанов",     "Логинов",    "Лопатин",      "Лосев",
+    "Лужков",     "Лукин",       "Лукьянов",   "Лыков",       "Львов",      "Любимов",      "Майоров",
+    "Макаров",    "Макеев",      "Максимов",   "Малахов",     "Малинин",    "Малофеев",     "Малышев",
+    "Мальцев",    "Маркелов",    "Маркин",     "Марков",      "Мартынов",   "Масленников",  "Маслов",
+    "Матвеев",    "Матвиенко",   "Медведев",   "Медейко",     "Мельников",  "Меньшов",      "Меркулов",
+    "Мешков",     "Мещеряков",   "Минаев",     "Минин",       "Миронов",    "Митрофанов",   "Михайлов",
+    "Михеев",     "Мишустин",    "Моисеев",    "Молчанов",    "Моргунов",   "Морозов",      "Москвин",
+    "Муравьёв",   "Муратов",     "Муромцев",   "Мухин",       "Мясников",   "Навальный",    "Назаров",
+    "Наумов",     "Некрасов",    "Нестеров",   "Нефёдов",     "Нечаев",     "Никитин",      "Никифоров",
+    "Николаев",   "Никольский",  "Никонов",    "Никулин",     "Новиков",    "Новодворский", "Носков",
+    "Носов",      "Овсянников",  "Овчинников", "Одинцов",     "Озеров",     "Окулов",       "Олейников",
+    "Орехов",     "Орлов",       "Осипов",     "Островский",  "Павлов",     "Павловский",   "Панин",
+    "Панков",     "Панкратов",   "Панов",      "Пантелеев",   "Панфилов",   "Парамонов",    "Парфёнов",
+    "Пастухов",   "Пахомов",     "Пекарев",    "Петров",      "Петровский", "Петухов",      "Пименов",
+    "Пирогов",    "Платонов",    "Плотников",  "Поздняков",   "Покровский", "Поликарпов",   "Поляков",
+    "Пономарев",  "Пономарёв",   "Попов",      "Порошин",     "Порывай",    "Постников",    "Потапов",
+    "Похлёбкин",  "Прокофьев",   "Прохоров",   "Прошин",      "Пугачёв",    "Путин",        "Раков",
+    "Резицкий",   "Рогов",       "Родин",      "Родионов",    "Рожков",     "Розанов",      "Романов",
+    "Рублёв",     "Рубцов",      "Рудаков",    "Руднев",      "Румянцев",   "Русаков",      "Русанов",
+    "Рыбаков",    "Рыбкин",      "Рыжиков",    "Рыжков",      "Рыжов",      "Рябинин",      "Рябов",
+    "Савельев",   "Савин",       "Савицкий",   "Сазонов",     "Сальников",  "Самойлов",     "Самсонов",
+    "Сафонов",    "Сахаров",     "Светличный", "Светлов",     "Свешников",  "Свиридов",     "Севастьянов",
+    "Седов",      "Селезнёв",    "Селиванов",  "Семёнов",     "Сёмин",      "Сергеев",      "Серебряков",
+    "Серов",      "Сидоров",     "Сизов",      "Симонов",     "Синицин",    "Синицын",      "Ситников",
+    "Скворцов",   "Смирнов",     "Снегирёв",   "Соболев",     "Собянин",    "Соколов",      "Соловьёв",
+    "Сомов",      "Сорокин",     "Сотников",   "Софронов",    "Спиридонов", "Стариков",     "Старостин",
+    "Степанов",   "Столяров",    "Стрелков",   "Стрельников", "Строев",     "Субботин",     "Суворов",
+    "Судаков",    "Сурганов",    "Сурков",     "Суслов",      "Суханов",    "Сухарев",      "Сухов",
+    "Сычёв",      "Тарасов",     "Терентьев",  "Терехов",     "Тимофеев",   "Титов",        "Тихомиров",
+    "Тихонов",    "Ткачёв",      "Токарев",    "Толкачёв",    "Торшин",     "Третьяков",    "Трифонов",
+    "Троицкий",   "Трофим",      "Трофимов",   "Троцкий",     "Трошин",     "Туманов",      "Уваров",
+    "Ульянов",    "Усов",        "Успенский",  "Устинов",     "Уткин",      "Ушаков",       "Фадеев",
+    "Фёдоров",    "Федосеев",    "Федосов",    "Федотов",     "Фетисов",    "Филатов",      "Филимонов",
+    "Филиппов",   "Фирсов",      "Фокин",      "Фомин",       "Фомичев",    "Фомичёв",      "Фролов",
+    "Харитонов",  "Хомяков",     "Хохлов",     "Хромов",      "Хрущёв",     "Худяков",      "Царёв",
+    "Цветков",    "Чеботарёв",   "Черепанов",  "Черкасов",    "Чернов",     "Черной",       "Чёрный",
+    "Черных",     "Чернышев",    "Чернышёв",   "Черняев",     "Чесноков",   "Чижов",        "Чистяков",
+    "Чумаков",    "Шаповалов",   "Шапошников", "Шаров",       "Швецов",     "Шевелёв",      "Шевцов",
+    "Шестаков",   "Шилов",       "Широков",    "Ширяев",      "Шишкин",     "Шмелёв",       "Шубин",
+    "Шувалов",    "Шульгин",     "Щеглов",     "Щербаков",    "Щукин",      "Юдин",         "Яковлев",
+    "Яшин"};
+
+const std::vector<std::string> russianFemalesLastNames = {
     "Авдеева",      "Агапова",       "Агафонова",   "Агеева",       "Акимова",     "Аксёнова",     "Александрова",
     "Алексеева",    "Алёхина",       "Алешина",     "Алёшина",      "Ананьева",    "Андреева",     "Андрианова",
     "Аникина",      "Анисимова",     "Анохина",     "Антипова",     "Антонова",    "Артамонова",   "Артёмова",
diff --git a/src/modules/person/data/russian/RussianLastNamesMales.h b/src/modules/person/data/russian/RussianLastNamesMales.h
deleted file mode 100644
index 5fcd0366f..000000000
--- a/src/modules/person/data/russian/RussianLastNamesMales.h
+++ /dev/null
@@ -1,91 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> russianLastNamesMales = {
-    "Авдеев",     "Агапов",      "Агафонов",   "Агеев",       "Акимов",     "Аксёнов",      "Александров",
-    "Алексеев",   "Алёхин",      "Алешин",     "Алёшин",      "Ананьев",    "Андреев",      "Андрианов",
-    "Аникин",     "Анисимов",    "Анохин",     "Антипов",     "Антонов",    "Артамонов",    "Артёмов",
-    "Архипов",    "Астафьев",    "Астахов",    "Афанасьев",   "Бабушкин",   "Баженов",      "Балашов",
-    "Баранов",    "Барсуков",    "Басов",      "Безруков",    "Беликов",    "Белкин",       "Белов",
-    "Белоусов",   "Беляев",      "Беляков",    "Березин",     "Берия",      "Беспалов",     "Бессонов",
-    "Бирюков",    "Блинов",      "Блохин",     "Бобров",      "Богданов",   "Богомолов",    "Болдырев",
-    "Большаков",  "Бондарев",    "Борисов",    "Бородин",     "Бочаров",    "Булатов",      "Булгаков",
-    "Буров",      "Быков",       "Бычков",     "Вавилов",     "Вагин",      "Васильев",     "Вдовин",
-    "Верещагин",  "Вешняков",    "Виноградов", "Винокуров",   "Вишневский", "Владимиров",   "Власов",
-    "Волков",     "Волошин",     "Воробьёв",   "Воронин",     "Воронков",   "Воронов",      "Воронцов",
-    "Второв",     "Высоцкий",    "Гаврилов",   "Гайдуков",    "Гакабов",    "Галкин",       "Герасимов",
-    "Гладков",    "Глебов",      "Глухов",     "Глушков",     "Гноев",      "Голиков",      "Голованов",
-    "Головин",    "Голубев",     "Гончаров",   "Горбань",     "Горбачав",   "Горбачёв",     "Горбунов",
-    "Гордеев",    "Горелов",     "Горлов",     "Горохов",     "Горшков",    "Горюнов",      "Горячев",
-    "Грачёв",     "Греков",      "Грибков",    "Грибов",      "Григорьев",  "Гришин",       "Громов",
-    "Губанов",    "Гуляев",      "Гуров",      "Гусев",       "Гущин",      "Давыдов",      "Данилов",
-    "Дашков",     "Дегтярев",    "Дегтярёв",   "Дементьев",   "Демидов",    "Дёмин",        "Демьянов",
-    "Денисов",    "Дмитриев",    "Добрынин",   "Долгов",      "Дорофеев",   "Дорохов",      "Дроздов",
-    "Дружинин",   "Дубинин",     "Дубов",      "Дубровин",    "Дьяков",     "Дьяконов",     "Евдокимов",
-    "Евсеев",     "Егоров",      "Ежов",       "Елизаров",    "Елисеев",    "Ельцин",       "Емельянов",
-    "Еремеев",    "Ерёмин",      "Ермаков",    "Ермилов",     "Ермолаев",   "Ермолов",      "Еромлаев",
-    "Ерофеев",    "Ерохин",      "Ершов",      "Ефимов",      "Ефремов",    "Жаров",        "Жданов",
-    "Жилин",      "Жириновский", "Жуков",      "Журавлёв",    "Завьялов",   "Заец",         "Зайцев",
-    "Захаров",    "Зверев",      "Звягинцев",  "Зеленин",     "Зимин",      "Зиновьев",     "Злобин",
-    "Золотарев",  "Золотарёв",   "Золотов",    "Зорин",       "Зотов",      "Зубков",       "Зубов",
-    "Зуев",       "Зыков",       "Зюганов",    "Иванов",      "Ивашов",     "Игнатов",      "Игнатьев",
-    "Измайлов",   "Ильин",       "Ильинский",  "Ильюхин",     "Исаев",      "Исаков",       "Казаков",
-    "Казанцев",   "Калачев",     "Калачёв",    "Калашников",  "Калинин",    "Калмыков",     "Калугин",
-    "Капустин",   "Карасев",     "Карасёв",    "Карпов",      "Карташов",   "Касаткин",     "Касьянов",
-    "Киреев",     "Кириллов",    "Киселёв",    "Кислов",      "Климов",     "Клюев",        "Князев",
-    "Ковалёв",    "Коваленко",   "Коваль",     "Кожевников",  "Козин",      "Козлов",       "Козловский",
-    "Козырев",    "Колесников",  "Колесов",    "Колосов",     "Колпаков",   "Кольцов",      "Комаров",
-    "Комиссаров", "Кондратов",   "Кондратьев", "Кондрашов",   "Коновалов",  "Кононов",      "Константинов",
-    "Копылов",    "Корнев",      "Корнеев",    "Корнилов",    "Коровин",    "Королёв",      "Корольков",
-    "Коротков",   "Корчагин",    "Коршунов",   "Косарев",     "Костин",     "Котов",        "Кочергин",
-    "Кочетков",   "Кочетов",     "Кошелев",    "Кравцов",     "Краснов",    "Красоткин",    "Кролик",
-    "Кроликов",   "Круглов",     "Крылов",     "Крюков",      "Крючков",    "Кудрявцев",    "Кудряшов",
-    "Кузин",      "Кузнецов",    "Кузьмин",    "Кукушкин",    "Кулагин",    "Кулаков",      "Кулешов",
-    "Куликов",    "Куприянов",   "Курочкин",   "Лаврентьев",  "Лавров",     "Лазарев",      "Лапин",
-    "Лаптев",     "Лапшин",      "Ларин",      "Ларионов",    "Латышев",    "Лебедев",      "Левин",
-    "Леонов",     "Леонтьев",    "Литвинов",   "Лобанов",     "Логинов",    "Лопатин",      "Лосев",
-    "Лужков",     "Лукин",       "Лукьянов",   "Лыков",       "Львов",      "Любимов",      "Майоров",
-    "Макаров",    "Макеев",      "Максимов",   "Малахов",     "Малинин",    "Малофеев",     "Малышев",
-    "Мальцев",    "Маркелов",    "Маркин",     "Марков",      "Мартынов",   "Масленников",  "Маслов",
-    "Матвеев",    "Матвиенко",   "Медведев",   "Медейко",     "Мельников",  "Меньшов",      "Меркулов",
-    "Мешков",     "Мещеряков",   "Минаев",     "Минин",       "Миронов",    "Митрофанов",   "Михайлов",
-    "Михеев",     "Мишустин",    "Моисеев",    "Молчанов",    "Моргунов",   "Морозов",      "Москвин",
-    "Муравьёв",   "Муратов",     "Муромцев",   "Мухин",       "Мясников",   "Навальный",    "Назаров",
-    "Наумов",     "Некрасов",    "Нестеров",   "Нефёдов",     "Нечаев",     "Никитин",      "Никифоров",
-    "Николаев",   "Никольский",  "Никонов",    "Никулин",     "Новиков",    "Новодворский", "Носков",
-    "Носов",      "Овсянников",  "Овчинников", "Одинцов",     "Озеров",     "Окулов",       "Олейников",
-    "Орехов",     "Орлов",       "Осипов",     "Островский",  "Павлов",     "Павловский",   "Панин",
-    "Панков",     "Панкратов",   "Панов",      "Пантелеев",   "Панфилов",   "Парамонов",    "Парфёнов",
-    "Пастухов",   "Пахомов",     "Пекарев",    "Петров",      "Петровский", "Петухов",      "Пименов",
-    "Пирогов",    "Платонов",    "Плотников",  "Поздняков",   "Покровский", "Поликарпов",   "Поляков",
-    "Пономарев",  "Пономарёв",   "Попов",      "Порошин",     "Порывай",    "Постников",    "Потапов",
-    "Похлёбкин",  "Прокофьев",   "Прохоров",   "Прошин",      "Пугачёв",    "Путин",        "Раков",
-    "Резицкий",   "Рогов",       "Родин",      "Родионов",    "Рожков",     "Розанов",      "Романов",
-    "Рублёв",     "Рубцов",      "Рудаков",    "Руднев",      "Румянцев",   "Русаков",      "Русанов",
-    "Рыбаков",    "Рыбкин",      "Рыжиков",    "Рыжков",      "Рыжов",      "Рябинин",      "Рябов",
-    "Савельев",   "Савин",       "Савицкий",   "Сазонов",     "Сальников",  "Самойлов",     "Самсонов",
-    "Сафонов",    "Сахаров",     "Светличный", "Светлов",     "Свешников",  "Свиридов",     "Севастьянов",
-    "Седов",      "Селезнёв",    "Селиванов",  "Семёнов",     "Сёмин",      "Сергеев",      "Серебряков",
-    "Серов",      "Сидоров",     "Сизов",      "Симонов",     "Синицин",    "Синицын",      "Ситников",
-    "Скворцов",   "Смирнов",     "Снегирёв",   "Соболев",     "Собянин",    "Соколов",      "Соловьёв",
-    "Сомов",      "Сорокин",     "Сотников",   "Софронов",    "Спиридонов", "Стариков",     "Старостин",
-    "Степанов",   "Столяров",    "Стрелков",   "Стрельников", "Строев",     "Субботин",     "Суворов",
-    "Судаков",    "Сурганов",    "Сурков",     "Суслов",      "Суханов",    "Сухарев",      "Сухов",
-    "Сычёв",      "Тарасов",     "Терентьев",  "Терехов",     "Тимофеев",   "Титов",        "Тихомиров",
-    "Тихонов",    "Ткачёв",      "Токарев",    "Толкачёв",    "Торшин",     "Третьяков",    "Трифонов",
-    "Троицкий",   "Трофим",      "Трофимов",   "Троцкий",     "Трошин",     "Туманов",      "Уваров",
-    "Ульянов",    "Усов",        "Успенский",  "Устинов",     "Уткин",      "Ушаков",       "Фадеев",
-    "Фёдоров",    "Федосеев",    "Федосов",    "Федотов",     "Фетисов",    "Филатов",      "Филимонов",
-    "Филиппов",   "Фирсов",      "Фокин",      "Фомин",       "Фомичев",    "Фомичёв",      "Фролов",
-    "Харитонов",  "Хомяков",     "Хохлов",     "Хромов",      "Хрущёв",     "Худяков",      "Царёв",
-    "Цветков",    "Чеботарёв",   "Черепанов",  "Черкасов",    "Чернов",     "Черной",       "Чёрный",
-    "Черных",     "Чернышев",    "Чернышёв",   "Черняев",     "Чесноков",   "Чижов",        "Чистяков",
-    "Чумаков",    "Шаповалов",   "Шапошников", "Шаров",       "Швецов",     "Шевелёв",      "Шевцов",
-    "Шестаков",   "Шилов",       "Широков",    "Ширяев",      "Шишкин",     "Шмелёв",       "Шубин",
-    "Шувалов",    "Шульгин",     "Щеглов",     "Щербаков",    "Щукин",      "Юдин",         "Яковлев",
-    "Яшин"};
-}
diff --git a/src/modules/person/data/russian/RussianMiddleNames.h b/src/modules/person/data/russian/RussianMiddleNames.h
new file mode 100644
index 000000000..93081d533
--- /dev/null
+++ b/src/modules/person/data/russian/RussianMiddleNames.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> russianMalesMiddleNames = {
+    "Ааронович",    "Абрамович",     "Августович",   "Авдеевич",     "Аверьянович",  "Адамович",      "Адрианович",
+    "Аксёнович",    "Александрович", "Алексеевич",   "Анатольевич",  "Андреевич",    "Анисимович",    "Антипович",
+    "Антонович",    "Ануфриевич",    "Арсенович",    "Арсеньевич",   "Артёмович",    "Артемьевич",    "Артурович",
+    "Архипович",    "Афанасьевич",   "Бенедиктович", "Богданович",   "Бориславович", "Борисович",     "Брониславович",
+    "Валентинович", "Валерианович",  "Валерьевич",   "Валерьянович", "Васильевич",   "Венедиктович",  "Викентьевич",
+    "Викторович",   "Виленович",     "Вилорович",    "Витальевич",   "Владиленович", "Владиславович", "Владленович",
+    "Власович",     "Всеволодович",  "Вячеславович", "Гавриилович",  "Гаврилович",   "Геннадиевич",   "Георгиевич",
+    "Герасимович",  "Германович",    "Гертрудович",  "Глебович",     "Гордеевич",    "Григорьевич",   "Гурьевич",
+    "Давидович",    "Давыдович",     "Даниилович",   "Данилович",    "Демидович",    "Демьянович",    "Денисович",
+    "Димитриевич",  "Дмитриевич",    "Дорофеевич",   "Евсеевич",     "Евстигнеевич", "Егорович",      "Елизарович",
+    "Елисеевич",    "Еремеевич",     "Ермилович",    "Ермолаевич",   "Ерофеевич",    "Ефимович",      "Ефимьевич",
+    "Ефремович",    "Ефстафьевич",   "Жанович",      "Жоресович",    "Захарьевич",   "Зиновьевич",    "Игнатович",
+    "Игнатьевич",   "Игоревич",      "Измаилович",   "Изотович",     "Иларионович",  "Ильич",         "Ильясович",
+    "Иосипович",    "Иосифович",     "Исидорович",   "Марсович",     "Матвеевич",    "Тарасович",     "Теймуразович",
+    "Терентьевич",  "Тимурович",     "Тихонович",    "Трифонович",   "Трофимович",   "Устинович",     "Фадеевич",
+    "Фёдорович",    "Федосеевич",    "Федосьевич",   "Федотович",    "Феликсович",   "Феодосьевич",   "Феоктистович",
+    "Феофанович",   "Филатович",     "Филимонович",  "Филиппович",   "Фокич",        "Фомич",         "Фролович",
+    "Харитонович",  "Харламович",    "Харлампович",  "Харлампьевич", "Чеславович",   "Эдгардович",    "Эдгарович",
+    "Эдуардович",   "Юлианович",     "Юльевич",      "Яковлевич",    "Якубович",     "Ярославович"};
+
+const std::vector<std::string> russianFemalesMiddleNames = {
+    "Александровна", "Андреевна",     "Архиповна",     "Алексеевна",     "Антоновна",    "Аскольдовна",
+    "Альбертовна",   "Аркадьевна",    "Афанасьевна",   "Анатольевна",    "Артемовна",    "Богдановна",
+    "Болеславовна",  "Борисовна",     "Вадимовна",     "Васильевна",     "Владимировна", "Валентиновна",
+    "Вениаминовна",  "Владиславовна", "Валериевна",    "Викторовна",     "Вячеславовна", "Геннадиевна",
+    "Георгиевна",    "Геннадьевна",   "Григорьевна",   "Даниловна",      "Дмитриевна",   "Евгеньевна",
+    "Егоровна",      "Ефимовна",      "Ждановна",      "Захаровна",      "Ивановна",     "Игоревна",
+    "Ильинична",     "Кирилловна",    "Кузьминична",   "Константиновна", "Леонидовна",   "Леоновна",
+    "Львовна",       "Макаровна",     "Матвеевна",     "Михайловна",     "Максимовна",   "Мироновна",
+    "Натановна",     "Никифоровна",   "Ниловна",       "Наумовна",       "Николаевна",   "Олеговна",
+    "Оскаровна",     "Павловна",      "Петровна",      "Робертовна",     "Рубеновна",    "Руслановна",
+    "Романовна",     "Рудольфовна",   "Святославовна", "Сергеевна",      "Степановна",   "Семеновна",
+    "Станиславовна", "Тарасовна",     "Тимофеевна",    "Тимуровна",      "Федоровна",    "Феликсовна",
+    "Филипповна",    "Харитоновна",   "Эдуардовна",    "Эльдаровна",     "Юльевна",      "Юрьевна",
+    "Яковлевна"};
+}
diff --git a/src/modules/person/data/russian/RussianPeopleNames.h b/src/modules/person/data/russian/RussianPeopleNames.h
new file mode 100644
index 000000000..e0cc06441
--- /dev/null
+++ b/src/modules/person/data/russian/RussianPeopleNames.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "RussianFirstNames.h"
+#include "RussianLastNames.h"
+#include "RussianMiddleNames.h"
+
+namespace faker
+{
+const NameFormats russianPersonNameFormats{{{"{firstName} {lastName}", 1},
+                                            {"{lastName} {firstName}", 1},
+                                            {"{lastName} {middleName} {firstName}", 1},
+                                            {"{lastName} {firstName} {middleName}", 1}}};
+
+const PeopleNames russianPeopleNames{
+    {russianMalesFirstNames, russianMalesMiddleNames, russianMalesLastNames, {}, {}},
+    {russianFemalesFirstNames, russianFemalesMiddleNames, russianFemalesLastNames, {}, {}},
+    russianPersonNameFormats};
+}
diff --git a/src/modules/person/data/spanish/SpanishFirstNamesFemales.h b/src/modules/person/data/spanish/SpanishFirstNames.h
similarity index 54%
rename from src/modules/person/data/spanish/SpanishFirstNamesFemales.h
rename to src/modules/person/data/spanish/SpanishFirstNames.h
index 5781b5f5a..76d014fa2 100644
--- a/src/modules/person/data/spanish/SpanishFirstNamesFemales.h
+++ b/src/modules/person/data/spanish/SpanishFirstNames.h
@@ -5,7 +5,25 @@
 
 namespace faker
 {
-const std::vector<std::string> spanishFirstNamesFemales = {
+const std::vector<std::string> spanishMalesFirstNames = {
+    "Agapetus", "Aimon",      "Ángel",     "Beltran",      "Berto",     "Bronco",    "Carles",    "Cipriano",
+    "Cisco",    "Cortez",     "Cruz",      "Cuba",         "Daniel",    "Dario",     "Desiderio", "Diego",
+    "Dimos",    "Fanuco",     "Federico",  "Fraco",        "Francisco", "Frisco",    "Gervasio",  "Gig",
+    "Gonzalo",  "Guido",      "Guillermo", "Hermenegildo", "Hernan",    "Hilario",   "Ignado",    "Isidro",
+    "Iván",     "Jaguar",     "Jair",      "Javier",       "Jerrold",   "Jordi",     "Jorge",     "Josep",
+    "Juan",     "Juan Ramón", "Kiki",      "Larenzo",      "Lisandro",  "Loredo",    "Lorenzo",   "Macario",
+    "Malvolio", "Manuel",     "Marjun",    "Miguel",       "Montana",   "Montego",   "Montel",    "Montenegro",
+    "Nasario",  "Nemesio",    "Neper",     "Neron ",       "Nicandro",  "Noe",       "Oihane",    "Oleos",
+    "Olindo",   "Onofre",     "Ora",       "Oro",          "Ovidio",    "Pablo",     "Paco",      "Pancho",
+    "Pedro",    "Pío",        "Ponce",     "Porfio",       "Quico",     "Quinto",    "Quiqui",    "Quito",
+    "Reyes",    "Reynaldo",   "Ricardo",   "Rico",         "Rio",       "Rogelio",   "Rubén",     "Ryo",
+    "Sagaz",    "Salvador",   "Santiago",  "Saturnin",     "Seferino",  "Selestino", "Senon",     "Sergi",
+    "Sierra",   "Tajo",       "Urvano",    "Vegas",        "Venacio",   "Vicente",   "Vidal",     "Xabat",
+    "Xalvador", "Xaver",      "Xaverius",  "Xavier",       "Xavion",    "Xeres",     "Ximen",     "Zelipe",
+    "Zenon ",
+};
+
+const std::vector<std::string> spanishFemalesFirstNames = {
     "Adalia",    "Aidia",    "Alva",       "Ana",       "Andrea",   "Anni",      "Aureliano", "Belinda",
     "Bettina",   "Carey",    "Carlotta",   "Coco",      "Damita",   "Delfina",   "Duenna",    "Dulcie",
     "Elvira",    "Enriqua",  "Esmerelda",  "Esperanza", "Fe",       "Fonda",     "Frida",     "Friera",
@@ -26,4 +44,4 @@ const std::vector<std::string> spanishFirstNamesFemales = {
     "Xiao",      "Xiomara",  "Yadra",      "Yomaris",   "Zaneta",   "Zarela",    "Zarita",    "Zaviera",
     "Zequinha",  "Zuriaa",   "Zurine ",
 };
-}
\ No newline at end of file
+}
diff --git a/src/modules/person/data/spanish/SpanishFirstNamesMales.h b/src/modules/person/data/spanish/SpanishFirstNamesMales.h
deleted file mode 100644
index be420ffb8..000000000
--- a/src/modules/person/data/spanish/SpanishFirstNamesMales.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker
-{
-const std::vector<std::string> spanishFirstNamesMales = {
-    "Agapetus", "Aimon",      "Ángel",     "Beltran",      "Berto",     "Bronco",    "Carles",    "Cipriano",
-    "Cisco",    "Cortez",     "Cruz",      "Cuba",         "Daniel",    "Dario",     "Desiderio", "Diego",
-    "Dimos",    "Fanuco",     "Federico",  "Fraco",        "Francisco", "Frisco",    "Gervasio",  "Gig",
-    "Gonzalo",  "Guido",      "Guillermo", "Hermenegildo", "Hernan",    "Hilario",   "Ignado",    "Isidro",
-    "Iván",     "Jaguar",     "Jair",      "Javier",       "Jerrold",   "Jordi",     "Jorge",     "Josep",
-    "Juan",     "Juan Ramón", "Kiki",      "Larenzo",      "Lisandro",  "Loredo",    "Lorenzo",   "Macario",
-    "Malvolio", "Manuel",     "Marjun",    "Miguel",       "Montana",   "Montego",   "Montel",    "Montenegro",
-    "Nasario",  "Nemesio",    "Neper",     "Neron ",       "Nicandro",  "Noe",       "Oihane",    "Oleos",
-    "Olindo",   "Onofre",     "Ora",       "Oro",          "Ovidio",    "Pablo",     "Paco",      "Pancho",
-    "Pedro",    "Pío",        "Ponce",     "Porfio",       "Quico",     "Quinto",    "Quiqui",    "Quito",
-    "Reyes",    "Reynaldo",   "Ricardo",   "Rico",         "Rio",       "Rogelio",   "Rubén",     "Ryo",
-    "Sagaz",    "Salvador",   "Santiago",  "Saturnin",     "Seferino",  "Selestino", "Senon",     "Sergi",
-    "Sierra",   "Tajo",       "Urvano",    "Vegas",        "Venacio",   "Vicente",   "Vidal",     "Xabat",
-    "Xalvador", "Xaver",      "Xaverius",  "Xavier",       "Xavion",    "Xeres",     "Ximen",     "Zelipe",
-    "Zenon ",
-};
-}
\ No newline at end of file
diff --git a/src/modules/person/data/spanish/SpanishLastNames.h b/src/modules/person/data/spanish/SpanishLastNames.h
index 42cc08de3..c85e9bf1b 100644
--- a/src/modules/person/data/spanish/SpanishLastNames.h
+++ b/src/modules/person/data/spanish/SpanishLastNames.h
@@ -5,631 +5,629 @@
 
 namespace faker
 {
-const std::vector<std::string> spanishLastNames = {
-    "Abeyta",
-    "Abrego",
-    "Abreu",
-    "Acevedo",
-    "Acosta",
-    "Acuña",
-    "Adame",
-    "Adorno",
-    "Agosto",
-    "Aguayo",
-    "Aguilar",
-    "Aguilera",
-    "Aguirre",
-    "Alanis",
-    "Alaníz",
-    "Alarcón",
-    "Alba",
-    "Alcalá",
-    "Alcántar",
-    "Alcaraz",
-    "Alejandro",
-    "Alemán",
-    "Alfaro",
-    "Alicea",
-    "Almanza",
-    "Almaráz",
-    "Almonte",
-    "Alonso",
-    "Alonzo",
-    "Altamirano",
-    "Alva",
-    "Alvarado",
-    "Álvarez",
-    "Amador",
-    "Amaya",
-    "Anaya",
-    "Anguiano",
-    "Angulo",
-    "Aparicio",
-    "Apodaca",
-    "Aponte",
-    "Aragón",
-    "Araña",
-    "Aranda",
-    "Arce",
-    "Archuleta",
-    "Arellano",
-    "Arenas",
-    "Arevalo",
-    "Argüello",
-    "Arias",
-    "Armas",
-    "Armendáriz",
-    "Armenta",
-    "Armijo",
-    "Arredondo",
-    "Arreola",
-    "Arriaga",
-    "Arroyo",
-    "Arteaga",
-    "Atencio",
-    "Ávalos",
-    "Ávila",
-    "Avilés",
-    "Ayala",
-    "Baca",
-    "Badillo",
-    "Báez",
-    "Baeza",
-    "Bahena",
-    "Balderas",
-    "Ballesteros",
-    "Banda",
-    "Bañuelos",
-    "Barajas",
-    "Barela",
-    "Barragán",
-    "Barraza",
-    "Barrera",
-    "Barreto",
-    "Barrientos",
-    "Barrios",
-    "Batista",
-    "Becerra",
-    "Beltrán",
-    "Benavides",
-    "Benavídez",
-    "Benítez",
-    "Bermúdez",
-    "Bernal",
-    "Berríos",
-    "Betancourt",
-    "Blanco",
-    "Bonilla",
-    "Borrego",
-    "Botello",
-    "Bravo",
-    "Briones",
-    "Briseño",
-    "Brito",
-    "Bueno",
-    "Burgos",
-    "Bustamante",
-    "Bustos",
-    "Caballero",
-    "Cabán",
-    "Cabrera",
-    "Cadena",
-    "Caldera",
-    "Calderón",
-    "Calvillo",
-    "Camacho",
-    "Camarillo",
-    "Campos",
-    "Canales",
-    "Candelaria",
-    "Cano",
-    "Cantú",
-    "Caraballo",
-    "Carbajal",
-    "Cárdenas",
-    "Cardona",
-    "Carmona",
-    "Carranza",
-    "Carrasco",
-    "Carrasquillo",
-    "Carreón",
-    "Carrera",
-    "Carrero",
-    "Carrillo",
-    "Carrión",
-    "Carvajal",
-    "Casanova",
-    "Casares",
-    "Casarez",
-    "Casas",
-    "Casillas",
-    "Castañeda",
-    "Castellanos",
-    "Castillo",
-    "Castro",
-    "Cavazos",
-    "Cazares",
-    "Ceballos",
-    "Cedillo",
-    "Ceja",
-    "Centeno",
-    "Cepeda",
-    "Cerda",
-    "Cervantes",
-    "Cervántez",
-    "Chacón",
-    "Chapa",
-    "Chavarría",
-    "Chávez",
-    "Cintrón",
-    "Cisneros",
-    "Collado",
-    "Collazo",
-    "Colón",
-    "Colunga",
-    "Concepción",
-    "Contreras",
-    "Cordero",
-    "Córdova",
-    "Cornejo",
-    "Corona",
-    "Coronado",
-    "Corral",
-    "Corrales",
-    "Correa",
-    "Cortés",
-    "Cortéz",
-    "Cotto",
-    "Covarrubias",
-    "Crespo",
-    "Cruz",
-    "Cuellar",
-    "Curiel",
-    "Dávila",
-    "de Anda",
-    "de Jesús",
-    "Delacrúz",
-    "Delafuente",
-    "Delagarza",
-    "Delao",
-    "Delapaz",
-    "Delarosa",
-    "Delatorre",
-    "Deleón",
-    "Delgadillo",
-    "Delgado",
-    "Delrío",
-    "Delvalle",
-    "Díaz",
-    "Domínguez",
-    "Duarte",
-    "Dueñas",
-    "Durán",
-    "Echevarría",
-    "Elizondo",
-    "Enríquez",
-    "Escalante",
-    "Escamilla",
-    "Escobar",
-    "Escobedo",
-    "Esparza",
-    "Espinal",
-    "Espino",
-    "Espinosa",
-    "Espinosa de los Monteros",
-    "Espinoza",
-    "Esquibel",
-    "Esquivel",
-    "Estévez",
-    "Estrada",
-    "Fajardo",
-    "Farías",
-    "Feliciano",
-    "Fernández",
-    "Ferrer",
-    "Fierro",
-    "Figueroa",
-    "Flores",
-    "Flórez",
-    "Fonseca",
-    "Frías",
-    "Fuentes",
-    "Gaitán",
-    "Galarza",
-    "Galindo",
-    "Gallardo",
-    "Gallegos",
-    "Galván",
-    "Gálvez",
-    "Gamboa",
-    "Gámez",
-    "Gaona",
-    "Garay",
-    "García",
-    "Garibay",
-    "Garica",
-    "Garrido",
-    "Garza",
-    "Gastélum",
-    "Gaytán",
-    "Gil",
-    "Girón",
-    "Godínez",
-    "Godoy",
-    "Gómez",
-    "González",
-    "Gracia",
-    "Granado",
-    "Granados",
-    "Griego",
-    "Grijalva",
-    "Guajardo",
-    "Guardado",
-    "Guerra",
-    "Guerrero",
-    "Guevara",
-    "Guillén",
-    "Gurule",
-    "Gutiérrez",
-    "Guzmán",
-    "Haro",
-    "Henríquez",
-    "Heredia",
-    "Hernández",
-    "Herrera",
-    "Hidalgo",
-    "Hinojosa",
-    "Holguín",
-    "Huerta",
-    "Hurtado",
-    "Ibarra",
-    "Iglesias",
-    "Irizarry",
-    "Jaime",
-    "Jaimes",
-    "Jáquez",
-    "Jaramillo",
-    "Jasso",
-    "Jiménez",
-    "Juárez",
-    "Jurado",
-    "Laboy",
-    "Lara",
-    "Laureano",
-    "Leal",
-    "Lebrón",
-    "Ledesma",
-    "Leiva",
-    "Lemus",
-    "León",
-    "Lerma",
-    "Leyva",
-    "Limón",
-    "Linares",
-    "Lira",
-    "Llamas",
-    "Loera",
-    "Lomeli",
-    "Longoria",
-    "López",
-    "Lovato",
-    "Loya",
-    "Lozada",
-    "Lozano",
-    "Lucero",
-    "Lucio",
-    "Luevano",
-    "Lugo",
-    "Luna",
-    "Macías",
-    "Madera",
-    "Madrid",
-    "Madrigal",
-    "Maestas",
-    "Magaña",
-    "Malave",
-    "Maldonado",
-    "Manzanares",
-    "Mares",
-    "Marín",
-    "Márquez",
-    "Marrero",
-    "Marroquín",
-    "Martínez",
-    "Mascareñas",
-    "Mata",
-    "Mateo",
-    "Matías",
-    "Matos",
-    "Maya",
-    "Mayorga",
-    "Medina",
-    "Medrano",
-    "Mejía",
-    "Meléndez",
-    "Melgar",
-    "Mena",
-    "Menchaca",
-    "Méndez",
-    "Mendoza",
-    "Menéndez",
-    "Meraz",
-    "Mercado",
-    "Merino",
-    "Mesa",
-    "Meza",
-    "Miramontes",
-    "Miranda",
-    "Mireles",
-    "Mojica",
-    "Molina",
-    "Mondragón",
-    "Monroy",
-    "Montalvo",
-    "Montañez",
-    "Montaño",
-    "Montemayor",
-    "Montenegro",
-    "Montero",
-    "Montes",
-    "Montéz",
-    "Montoya",
-    "Mora",
-    "Morales",
-    "Moreno",
-    "Mota",
-    "Moya",
-    "Munguía",
-    "Muñiz",
-    "Muñoz",
-    "Murillo",
-    "Muro",
-    "Nájera",
-    "Naranjo",
-    "Narváez",
-    "Nava",
-    "Navarrete",
-    "Navarro",
-    "Nazario",
-    "Negrete",
-    "Negrón",
-    "Nevárez",
-    "Nieto",
-    "Nieves",
-    "Niño",
-    "Noriega",
-    "Núñez",
-    "Ocampo",
-    "Ocasio",
-    "Ochoa",
-    "Ojeda",
-    "Olivares",
-    "Olivárez",
-    "Olivas",
-    "Olivera",
-    "Olivo",
-    "Olmos",
-    "Olvera",
-    "Ontiveros",
-    "Oquendo",
-    "Ordóñez",
-    "Orellana",
-    "Ornelas",
-    "Orosco",
-    "Orozco",
-    "Orta",
-    "Ortega",
-    "Ortiz",
-    "Osorio",
-    "Otero",
-    "Ozuna",
-    "Pabón",
-    "Pacheco",
-    "Padilla",
-    "Padrón",
-    "Páez",
-    "Pagan",
-    "Palacios",
-    "Palomino",
-    "Palomo",
-    "Pantoja",
-    "Paredes",
-    "Parra",
-    "Partida",
-    "Patiño",
-    "Paz",
-    "Pedraza",
-    "Pedroza",
-    "Pelayo",
-    "Peña",
-    "Perales",
-    "Peralta",
-    "Perea",
-    "Pérez",
-    "Pichardo",
-    "Piña",
-    "Pineda",
-    "Pizarro",
-    "Polanco",
-    "Ponce",
-    "Porras",
-    "Portillo",
-    "Posada",
-    "Prado",
-    "Preciado",
-    "Prieto",
-    "Puente",
-    "Puga",
-    "Pulido",
-    "Quesada",
-    "Quezada",
-    "Quiñones",
-    "Quiñónez",
-    "Quintana",
-    "Quintanilla",
-    "Quintero",
-    "Quiróz",
-    "Rael",
-    "Ramírez",
-    "Ramos",
-    "Rangel",
-    "Rascón",
-    "Raya",
-    "Razo",
-    "Regalado",
-    "Rendón",
-    "Rentería",
-    "Reséndez",
-    "Reyes",
-    "Reyna",
-    "Reynoso",
-    "Rico",
-    "Rincón",
-    "Riojas",
-    "Ríos",
-    "Rivas",
-    "Rivera",
-    "Rivero",
-    "Robledo",
-    "Robles",
-    "Rocha",
-    "Rodarte",
-    "Rodríguez",
-    "Rojas",
-    "Rojo",
-    "Roldán",
-    "Rolón",
-    "Romero",
-    "Romo",
-    "Roque",
-    "Rosado",
-    "Rosales",
-    "Rosario",
-    "Rosas",
-    "Roybal",
-    "Rubio",
-    "Ruelas",
-    "Ruíz",
-    "Saavedra",
-    "Sáenz",
-    "Saiz",
-    "Salas",
-    "Salazar",
-    "Salcedo",
-    "Salcido",
-    "Saldaña",
-    "Saldivar",
-    "Salgado",
-    "Salinas",
-    "Samaniego",
-    "Sanabria",
-    "Sánchez",
-    "Sandoval",
-    "Santacruz",
-    "Santana",
-    "Santiago",
-    "Santillán",
-    "Sarabia",
-    "Sauceda",
-    "Saucedo",
-    "Sedillo",
-    "Segovia",
-    "Segura",
-    "Sepúlveda",
-    "Serna",
-    "Serrano",
-    "Serrato",
-    "Sevilla",
-    "Sierra",
-    "Sisneros",
-    "Solano",
-    "Solís",
-    "Soliz",
-    "Solorio",
-    "Solorzano",
-    "Soria",
-    "Sosa",
-    "Sotelo",
-    "Soto",
-    "Suárez",
-    "Tafoya",
-    "Tamayo",
-    "Tamez",
-    "Tapia",
-    "Tejada",
-    "Tejeda",
-    "Téllez",
-    "Tello",
-    "Terán",
-    "Terrazas",
-    "Tijerina",
-    "Tirado",
-    "Toledo",
-    "Toro",
-    "Torres",
-    "Tórrez",
-    "Tovar",
-    "Trejo",
-    "Treviño",
-    "Trujillo",
-    "Ulibarri",
-    "Ulloa",
-    "Urbina",
-    "Ureña",
-    "Urías",
-    "Uribe",
-    "Urrutia",
-    "Vaca",
-    "Valadez",
-    "Valdés",
-    "Valdez",
-    "Valdivia",
-    "Valencia",
-    "Valentín",
-    "Valenzuela",
-    "Valladares",
-    "Valle",
-    "Vallejo",
-    "Valles",
-    "Valverde",
-    "Vanegas",
-    "Varela",
-    "Vargas",
-    "Vázquez",
-    "Vega",
-    "Vela",
-    "Velasco",
-    "Velásquez",
-    "Velázquez",
-    "Vélez",
-    "Véliz",
-    "Venegas",
-    "Vera",
-    "Verdugo",
-    "Verduzco",
-    "Vergara",
-    "Viera",
-    "Vigil",
-    "Villa",
-    "Villagómez",
-    "Villalobos",
-    "Villalpando",
-    "Villanueva",
-    "Villarreal",
-    "Villaseñor",
-    "Villegas",
-    "Yáñez",
-    "Ybarra",
-    "Zambrano",
-    "Zamora",
-    "Zamudio",
-    "Zapata",
-    "Zaragoza",
-    "Zarate",
-    "Zavala",
-    "Zayas",
-    "Zelaya",
-    "Zepeda",
-    "Zúñiga",
-};
+const std::vector<std::string> spanishLastNames = {"Abeyta",
+                                                   "Abrego",
+                                                   "Abreu",
+                                                   "Acevedo",
+                                                   "Acosta",
+                                                   "Acuña",
+                                                   "Adame",
+                                                   "Adorno",
+                                                   "Agosto",
+                                                   "Aguayo",
+                                                   "Aguilar",
+                                                   "Aguilera",
+                                                   "Aguirre",
+                                                   "Alanis",
+                                                   "Alaníz",
+                                                   "Alarcón",
+                                                   "Alba",
+                                                   "Alcalá",
+                                                   "Alcántar",
+                                                   "Alcaraz",
+                                                   "Alejandro",
+                                                   "Alemán",
+                                                   "Alfaro",
+                                                   "Alicea",
+                                                   "Almanza",
+                                                   "Almaráz",
+                                                   "Almonte",
+                                                   "Alonso",
+                                                   "Alonzo",
+                                                   "Altamirano",
+                                                   "Alva",
+                                                   "Alvarado",
+                                                   "Álvarez",
+                                                   "Amador",
+                                                   "Amaya",
+                                                   "Anaya",
+                                                   "Anguiano",
+                                                   "Angulo",
+                                                   "Aparicio",
+                                                   "Apodaca",
+                                                   "Aponte",
+                                                   "Aragón",
+                                                   "Araña",
+                                                   "Aranda",
+                                                   "Arce",
+                                                   "Archuleta",
+                                                   "Arellano",
+                                                   "Arenas",
+                                                   "Arevalo",
+                                                   "Argüello",
+                                                   "Arias",
+                                                   "Armas",
+                                                   "Armendáriz",
+                                                   "Armenta",
+                                                   "Armijo",
+                                                   "Arredondo",
+                                                   "Arreola",
+                                                   "Arriaga",
+                                                   "Arroyo",
+                                                   "Arteaga",
+                                                   "Atencio",
+                                                   "Ávalos",
+                                                   "Ávila",
+                                                   "Avilés",
+                                                   "Ayala",
+                                                   "Baca",
+                                                   "Badillo",
+                                                   "Báez",
+                                                   "Baeza",
+                                                   "Bahena",
+                                                   "Balderas",
+                                                   "Ballesteros",
+                                                   "Banda",
+                                                   "Bañuelos",
+                                                   "Barajas",
+                                                   "Barela",
+                                                   "Barragán",
+                                                   "Barraza",
+                                                   "Barrera",
+                                                   "Barreto",
+                                                   "Barrientos",
+                                                   "Barrios",
+                                                   "Batista",
+                                                   "Becerra",
+                                                   "Beltrán",
+                                                   "Benavides",
+                                                   "Benavídez",
+                                                   "Benítez",
+                                                   "Bermúdez",
+                                                   "Bernal",
+                                                   "Berríos",
+                                                   "Betancourt",
+                                                   "Blanco",
+                                                   "Bonilla",
+                                                   "Borrego",
+                                                   "Botello",
+                                                   "Bravo",
+                                                   "Briones",
+                                                   "Briseño",
+                                                   "Brito",
+                                                   "Bueno",
+                                                   "Burgos",
+                                                   "Bustamante",
+                                                   "Bustos",
+                                                   "Caballero",
+                                                   "Cabán",
+                                                   "Cabrera",
+                                                   "Cadena",
+                                                   "Caldera",
+                                                   "Calderón",
+                                                   "Calvillo",
+                                                   "Camacho",
+                                                   "Camarillo",
+                                                   "Campos",
+                                                   "Canales",
+                                                   "Candelaria",
+                                                   "Cano",
+                                                   "Cantú",
+                                                   "Caraballo",
+                                                   "Carbajal",
+                                                   "Cárdenas",
+                                                   "Cardona",
+                                                   "Carmona",
+                                                   "Carranza",
+                                                   "Carrasco",
+                                                   "Carrasquillo",
+                                                   "Carreón",
+                                                   "Carrera",
+                                                   "Carrero",
+                                                   "Carrillo",
+                                                   "Carrión",
+                                                   "Carvajal",
+                                                   "Casanova",
+                                                   "Casares",
+                                                   "Casarez",
+                                                   "Casas",
+                                                   "Casillas",
+                                                   "Castañeda",
+                                                   "Castellanos",
+                                                   "Castillo",
+                                                   "Castro",
+                                                   "Cavazos",
+                                                   "Cazares",
+                                                   "Ceballos",
+                                                   "Cedillo",
+                                                   "Ceja",
+                                                   "Centeno",
+                                                   "Cepeda",
+                                                   "Cerda",
+                                                   "Cervantes",
+                                                   "Cervántez",
+                                                   "Chacón",
+                                                   "Chapa",
+                                                   "Chavarría",
+                                                   "Chávez",
+                                                   "Cintrón",
+                                                   "Cisneros",
+                                                   "Collado",
+                                                   "Collazo",
+                                                   "Colón",
+                                                   "Colunga",
+                                                   "Concepción",
+                                                   "Contreras",
+                                                   "Cordero",
+                                                   "Córdova",
+                                                   "Cornejo",
+                                                   "Corona",
+                                                   "Coronado",
+                                                   "Corral",
+                                                   "Corrales",
+                                                   "Correa",
+                                                   "Cortés",
+                                                   "Cortéz",
+                                                   "Cotto",
+                                                   "Covarrubias",
+                                                   "Crespo",
+                                                   "Cruz",
+                                                   "Cuellar",
+                                                   "Curiel",
+                                                   "Dávila",
+                                                   "de Anda",
+                                                   "de Jesús",
+                                                   "Delacrúz",
+                                                   "Delafuente",
+                                                   "Delagarza",
+                                                   "Delao",
+                                                   "Delapaz",
+                                                   "Delarosa",
+                                                   "Delatorre",
+                                                   "Deleón",
+                                                   "Delgadillo",
+                                                   "Delgado",
+                                                   "Delrío",
+                                                   "Delvalle",
+                                                   "Díaz",
+                                                   "Domínguez",
+                                                   "Duarte",
+                                                   "Dueñas",
+                                                   "Durán",
+                                                   "Echevarría",
+                                                   "Elizondo",
+                                                   "Enríquez",
+                                                   "Escalante",
+                                                   "Escamilla",
+                                                   "Escobar",
+                                                   "Escobedo",
+                                                   "Esparza",
+                                                   "Espinal",
+                                                   "Espino",
+                                                   "Espinosa",
+                                                   "Espinosa de los Monteros",
+                                                   "Espinoza",
+                                                   "Esquibel",
+                                                   "Esquivel",
+                                                   "Estévez",
+                                                   "Estrada",
+                                                   "Fajardo",
+                                                   "Farías",
+                                                   "Feliciano",
+                                                   "Fernández",
+                                                   "Ferrer",
+                                                   "Fierro",
+                                                   "Figueroa",
+                                                   "Flores",
+                                                   "Flórez",
+                                                   "Fonseca",
+                                                   "Frías",
+                                                   "Fuentes",
+                                                   "Gaitán",
+                                                   "Galarza",
+                                                   "Galindo",
+                                                   "Gallardo",
+                                                   "Gallegos",
+                                                   "Galván",
+                                                   "Gálvez",
+                                                   "Gamboa",
+                                                   "Gámez",
+                                                   "Gaona",
+                                                   "Garay",
+                                                   "García",
+                                                   "Garibay",
+                                                   "Garica",
+                                                   "Garrido",
+                                                   "Garza",
+                                                   "Gastélum",
+                                                   "Gaytán",
+                                                   "Gil",
+                                                   "Girón",
+                                                   "Godínez",
+                                                   "Godoy",
+                                                   "Gómez",
+                                                   "González",
+                                                   "Gracia",
+                                                   "Granado",
+                                                   "Granados",
+                                                   "Griego",
+                                                   "Grijalva",
+                                                   "Guajardo",
+                                                   "Guardado",
+                                                   "Guerra",
+                                                   "Guerrero",
+                                                   "Guevara",
+                                                   "Guillén",
+                                                   "Gurule",
+                                                   "Gutiérrez",
+                                                   "Guzmán",
+                                                   "Haro",
+                                                   "Henríquez",
+                                                   "Heredia",
+                                                   "Hernández",
+                                                   "Herrera",
+                                                   "Hidalgo",
+                                                   "Hinojosa",
+                                                   "Holguín",
+                                                   "Huerta",
+                                                   "Hurtado",
+                                                   "Ibarra",
+                                                   "Iglesias",
+                                                   "Irizarry",
+                                                   "Jaime",
+                                                   "Jaimes",
+                                                   "Jáquez",
+                                                   "Jaramillo",
+                                                   "Jasso",
+                                                   "Jiménez",
+                                                   "Juárez",
+                                                   "Jurado",
+                                                   "Laboy",
+                                                   "Lara",
+                                                   "Laureano",
+                                                   "Leal",
+                                                   "Lebrón",
+                                                   "Ledesma",
+                                                   "Leiva",
+                                                   "Lemus",
+                                                   "León",
+                                                   "Lerma",
+                                                   "Leyva",
+                                                   "Limón",
+                                                   "Linares",
+                                                   "Lira",
+                                                   "Llamas",
+                                                   "Loera",
+                                                   "Lomeli",
+                                                   "Longoria",
+                                                   "López",
+                                                   "Lovato",
+                                                   "Loya",
+                                                   "Lozada",
+                                                   "Lozano",
+                                                   "Lucero",
+                                                   "Lucio",
+                                                   "Luevano",
+                                                   "Lugo",
+                                                   "Luna",
+                                                   "Macías",
+                                                   "Madera",
+                                                   "Madrid",
+                                                   "Madrigal",
+                                                   "Maestas",
+                                                   "Magaña",
+                                                   "Malave",
+                                                   "Maldonado",
+                                                   "Manzanares",
+                                                   "Mares",
+                                                   "Marín",
+                                                   "Márquez",
+                                                   "Marrero",
+                                                   "Marroquín",
+                                                   "Martínez",
+                                                   "Mascareñas",
+                                                   "Mata",
+                                                   "Mateo",
+                                                   "Matías",
+                                                   "Matos",
+                                                   "Maya",
+                                                   "Mayorga",
+                                                   "Medina",
+                                                   "Medrano",
+                                                   "Mejía",
+                                                   "Meléndez",
+                                                   "Melgar",
+                                                   "Mena",
+                                                   "Menchaca",
+                                                   "Méndez",
+                                                   "Mendoza",
+                                                   "Menéndez",
+                                                   "Meraz",
+                                                   "Mercado",
+                                                   "Merino",
+                                                   "Mesa",
+                                                   "Meza",
+                                                   "Miramontes",
+                                                   "Miranda",
+                                                   "Mireles",
+                                                   "Mojica",
+                                                   "Molina",
+                                                   "Mondragón",
+                                                   "Monroy",
+                                                   "Montalvo",
+                                                   "Montañez",
+                                                   "Montaño",
+                                                   "Montemayor",
+                                                   "Montenegro",
+                                                   "Montero",
+                                                   "Montes",
+                                                   "Montéz",
+                                                   "Montoya",
+                                                   "Mora",
+                                                   "Morales",
+                                                   "Moreno",
+                                                   "Mota",
+                                                   "Moya",
+                                                   "Munguía",
+                                                   "Muñiz",
+                                                   "Muñoz",
+                                                   "Murillo",
+                                                   "Muro",
+                                                   "Nájera",
+                                                   "Naranjo",
+                                                   "Narváez",
+                                                   "Nava",
+                                                   "Navarrete",
+                                                   "Navarro",
+                                                   "Nazario",
+                                                   "Negrete",
+                                                   "Negrón",
+                                                   "Nevárez",
+                                                   "Nieto",
+                                                   "Nieves",
+                                                   "Niño",
+                                                   "Noriega",
+                                                   "Núñez",
+                                                   "Ocampo",
+                                                   "Ocasio",
+                                                   "Ochoa",
+                                                   "Ojeda",
+                                                   "Olivares",
+                                                   "Olivárez",
+                                                   "Olivas",
+                                                   "Olivera",
+                                                   "Olivo",
+                                                   "Olmos",
+                                                   "Olvera",
+                                                   "Ontiveros",
+                                                   "Oquendo",
+                                                   "Ordóñez",
+                                                   "Orellana",
+                                                   "Ornelas",
+                                                   "Orosco",
+                                                   "Orozco",
+                                                   "Orta",
+                                                   "Ortega",
+                                                   "Ortiz",
+                                                   "Osorio",
+                                                   "Otero",
+                                                   "Ozuna",
+                                                   "Pabón",
+                                                   "Pacheco",
+                                                   "Padilla",
+                                                   "Padrón",
+                                                   "Páez",
+                                                   "Pagan",
+                                                   "Palacios",
+                                                   "Palomino",
+                                                   "Palomo",
+                                                   "Pantoja",
+                                                   "Paredes",
+                                                   "Parra",
+                                                   "Partida",
+                                                   "Patiño",
+                                                   "Paz",
+                                                   "Pedraza",
+                                                   "Pedroza",
+                                                   "Pelayo",
+                                                   "Peña",
+                                                   "Perales",
+                                                   "Peralta",
+                                                   "Perea",
+                                                   "Pérez",
+                                                   "Pichardo",
+                                                   "Piña",
+                                                   "Pineda",
+                                                   "Pizarro",
+                                                   "Polanco",
+                                                   "Ponce",
+                                                   "Porras",
+                                                   "Portillo",
+                                                   "Posada",
+                                                   "Prado",
+                                                   "Preciado",
+                                                   "Prieto",
+                                                   "Puente",
+                                                   "Puga",
+                                                   "Pulido",
+                                                   "Quesada",
+                                                   "Quezada",
+                                                   "Quiñones",
+                                                   "Quiñónez",
+                                                   "Quintana",
+                                                   "Quintanilla",
+                                                   "Quintero",
+                                                   "Quiróz",
+                                                   "Rael",
+                                                   "Ramírez",
+                                                   "Ramos",
+                                                   "Rangel",
+                                                   "Rascón",
+                                                   "Raya",
+                                                   "Razo",
+                                                   "Regalado",
+                                                   "Rendón",
+                                                   "Rentería",
+                                                   "Reséndez",
+                                                   "Reyes",
+                                                   "Reyna",
+                                                   "Reynoso",
+                                                   "Rico",
+                                                   "Rincón",
+                                                   "Riojas",
+                                                   "Ríos",
+                                                   "Rivas",
+                                                   "Rivera",
+                                                   "Rivero",
+                                                   "Robledo",
+                                                   "Robles",
+                                                   "Rocha",
+                                                   "Rodarte",
+                                                   "Rodríguez",
+                                                   "Rojas",
+                                                   "Rojo",
+                                                   "Roldán",
+                                                   "Rolón",
+                                                   "Romero",
+                                                   "Romo",
+                                                   "Roque",
+                                                   "Rosado",
+                                                   "Rosales",
+                                                   "Rosario",
+                                                   "Rosas",
+                                                   "Roybal",
+                                                   "Rubio",
+                                                   "Ruelas",
+                                                   "Ruíz",
+                                                   "Saavedra",
+                                                   "Sáenz",
+                                                   "Saiz",
+                                                   "Salas",
+                                                   "Salazar",
+                                                   "Salcedo",
+                                                   "Salcido",
+                                                   "Saldaña",
+                                                   "Saldivar",
+                                                   "Salgado",
+                                                   "Salinas",
+                                                   "Samaniego",
+                                                   "Sanabria",
+                                                   "Sánchez",
+                                                   "Sandoval",
+                                                   "Santacruz",
+                                                   "Santana",
+                                                   "Santiago",
+                                                   "Santillán",
+                                                   "Sarabia",
+                                                   "Sauceda",
+                                                   "Saucedo",
+                                                   "Sedillo",
+                                                   "Segovia",
+                                                   "Segura",
+                                                   "Sepúlveda",
+                                                   "Serna",
+                                                   "Serrano",
+                                                   "Serrato",
+                                                   "Sevilla",
+                                                   "Sierra",
+                                                   "Sisneros",
+                                                   "Solano",
+                                                   "Solís",
+                                                   "Soliz",
+                                                   "Solorio",
+                                                   "Solorzano",
+                                                   "Soria",
+                                                   "Sosa",
+                                                   "Sotelo",
+                                                   "Soto",
+                                                   "Suárez",
+                                                   "Tafoya",
+                                                   "Tamayo",
+                                                   "Tamez",
+                                                   "Tapia",
+                                                   "Tejada",
+                                                   "Tejeda",
+                                                   "Téllez",
+                                                   "Tello",
+                                                   "Terán",
+                                                   "Terrazas",
+                                                   "Tijerina",
+                                                   "Tirado",
+                                                   "Toledo",
+                                                   "Toro",
+                                                   "Torres",
+                                                   "Tórrez",
+                                                   "Tovar",
+                                                   "Trejo",
+                                                   "Treviño",
+                                                   "Trujillo",
+                                                   "Ulibarri",
+                                                   "Ulloa",
+                                                   "Urbina",
+                                                   "Ureña",
+                                                   "Urías",
+                                                   "Uribe",
+                                                   "Urrutia",
+                                                   "Vaca",
+                                                   "Valadez",
+                                                   "Valdés",
+                                                   "Valdez",
+                                                   "Valdivia",
+                                                   "Valencia",
+                                                   "Valentín",
+                                                   "Valenzuela",
+                                                   "Valladares",
+                                                   "Valle",
+                                                   "Vallejo",
+                                                   "Valles",
+                                                   "Valverde",
+                                                   "Vanegas",
+                                                   "Varela",
+                                                   "Vargas",
+                                                   "Vázquez",
+                                                   "Vega",
+                                                   "Vela",
+                                                   "Velasco",
+                                                   "Velásquez",
+                                                   "Velázquez",
+                                                   "Vélez",
+                                                   "Véliz",
+                                                   "Venegas",
+                                                   "Vera",
+                                                   "Verdugo",
+                                                   "Verduzco",
+                                                   "Vergara",
+                                                   "Viera",
+                                                   "Vigil",
+                                                   "Villa",
+                                                   "Villagómez",
+                                                   "Villalobos",
+                                                   "Villalpando",
+                                                   "Villanueva",
+                                                   "Villarreal",
+                                                   "Villaseñor",
+                                                   "Villegas",
+                                                   "Yáñez",
+                                                   "Ybarra",
+                                                   "Zambrano",
+                                                   "Zamora",
+                                                   "Zamudio",
+                                                   "Zapata",
+                                                   "Zaragoza",
+                                                   "Zarate",
+                                                   "Zavala",
+                                                   "Zayas",
+                                                   "Zelaya",
+                                                   "Zepeda",
+                                                   "Zúñiga"};
 }
diff --git a/src/modules/person/data/spanish/SpanishPeopleNames.h b/src/modules/person/data/spanish/SpanishPeopleNames.h
new file mode 100644
index 000000000..bed0160a5
--- /dev/null
+++ b/src/modules/person/data/spanish/SpanishPeopleNames.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "SpanishFirstNames.h"
+#include "SpanishLastNames.h"
+#include "SpanishPrefixes.h"
+
+namespace faker
+{
+const NameFormats spanishPersonNameFormats{{{"{prefix} {firstName} {lastName}", 1}, {"{firstName} {lastName}", 9}}};
+
+const PeopleNames spanishPeopleNames{{spanishMalesFirstNames, {}, spanishLastNames, spanishMalesPrefixes, {}},
+                                     {spanishFemalesFirstNames, {}, spanishLastNames, spanishFemalesPrefixes, {}},
+                                     spanishPersonNameFormats};
+
+}
diff --git a/src/modules/person/data/spanish/SpanishPrefixes.h b/src/modules/person/data/spanish/SpanishPrefixes.h
new file mode 100644
index 000000000..7938132ec
--- /dev/null
+++ b/src/modules/person/data/spanish/SpanishPrefixes.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> spanishMalesPrefixes{"Sr."};
+
+const std::vector<std::string> spanishFemalesPrefixes{"Sra.", "Sta."};
+}
diff --git a/src/modules/person/data/turkish/TurkishFirstNames.h b/src/modules/person/data/turkish/TurkishFirstNames.h
new file mode 100644
index 000000000..92d125906
--- /dev/null
+++ b/src/modules/person/data/turkish/TurkishFirstNames.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> turkishMalesFirstNames = {
+    "Ahmet",  "Mehmet", "Mustafa", "Ali",    "Emre",   "Burak", "Can",   "Cem",    "Eren",   "Onur",  "Kaan",
+    "Serkan", "Hakan",  "Yusuf",   "Okan",   "Barış",  "Tolga", "Kerem", "Deniz",  "Oğuz",   "Umut",  "Gökhan",
+    "İsmail", "Metin",  "Orhan",   "İlker",  "Levent", "Selim", "Berk",  "Uğur",   "Murat",  "Tarık", "Cihan",
+    "Fatih",  "Furkan", "Yiğit",   "Tarkan", "Volkan", "Mert",  "Alp",   "Taylan", "Burhan", "Ege",   "Koray"};
+
+const std::vector<std::string> turkishFemalesFirstNames = {
+    "Ayşe",  "Fatma", "Zeynep",  "Emine", "Merve", "Elif",  "Melis",  "Esra",  "İrem",  "Ebru",   "Selma",
+    "Leyla", "Selin", "Gamze",   "Gizem", "Ceren", "Deniz", "Aslı",   "Nazlı", "Pınar", "İlayda", "Dilara",
+    "Büşra", "Rabia", "Yasemin", "Gül",   "Nur",   "Melek", "Sude",   "Şeyma", "Beren", "Eylül",  "İpek",
+    "Hande", "Cansu", "Özge",    "Hilal", "Bilge", "Serra", "İlknur", "Cemre", "Tuğba", "Yelda"};
+}
diff --git a/src/modules/person/data/turkish/TurkishFirstNamesFemales.h b/src/modules/person/data/turkish/TurkishFirstNamesFemales.h
deleted file mode 100644
index 270176445..000000000
--- a/src/modules/person/data/turkish/TurkishFirstNamesFemales.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker {
-    const std::vector<std::string> turkishFirstNamesFemales = {
-        "Ayşe",
-        "Fatma",
-        "Zeynep",
-        "Emine",
-        "Merve",
-        "Elif",
-        "Melis",
-        "Esra",
-        "İrem",
-        "Ebru",
-        "Selma",
-        "Leyla",
-        "Selin",
-        "Gamze",
-        "Gizem",
-        "Ceren",
-        "Deniz",
-        "Aslı",
-        "Nazlı",
-        "Pınar",
-        "İlayda",
-        "Dilara",
-        "Büşra",
-        "Rabia",
-        "Yasemin",
-        "Gül",
-        "Nur",
-        "Melek",
-        "Sude",
-        "Şeyma",
-        "Beren",
-        "Eylül",
-        "İpek",
-        "Hande",
-        "Cansu",
-        "Özge",
-        "Hilal",
-        "Bilge",
-        "Serra",
-        "İlknur",
-        "Cemre",
-        "Tuğba",
-        "Yelda",
-    };
-}
\ No newline at end of file
diff --git a/src/modules/person/data/turkish/TurkishFirstNamesMales.h b/src/modules/person/data/turkish/TurkishFirstNamesMales.h
deleted file mode 100644
index a9d456cbf..000000000
--- a/src/modules/person/data/turkish/TurkishFirstNamesMales.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace faker {
-    const std::vector<std::string> turkishFirstNamesMales = {
-        "Ahmet",
-        "Mehmet",
-        "Mustafa",
-        "Ali",
-        "Emre",
-        "Burak",
-        "Can",
-        "Cem",
-        "Eren",
-        "Onur",
-        "Kaan",
-        "Serkan",
-        "Hakan",
-        "Yusuf",
-        "Okan",
-        "Barış",
-        "Tolga",
-        "Kerem",
-        "Deniz",
-        "Oğuz",
-        "Umut",
-        "Gökhan",
-        "İsmail",
-        "Metin",
-        "Orhan",
-        "İlker",
-        "Levent",
-        "Selim",
-        "Berk",
-        "Uğur",
-        "Murat",
-        "Tarık",
-        "Cihan",
-        "Fatih",
-        "Furkan",
-        "Yiğit",
-        "Tarkan",
-        "Volkan",
-        "Mert",
-        "Alp",
-        "Taylan",
-        "Burhan",
-        "Ege",
-        "Koray",
-    };
-}
\ No newline at end of file
diff --git a/src/modules/person/data/turkish/TurkishLastNames.h b/src/modules/person/data/turkish/TurkishLastNames.h
index acc032660..659cd5f4f 100644
--- a/src/modules/person/data/turkish/TurkishLastNames.h
+++ b/src/modules/person/data/turkish/TurkishLastNames.h
@@ -3,59 +3,13 @@
 #include <string>
 #include <vector>
 
-namespace faker {
-    const std::vector<std::string> turkishLastNames = {
-        "Yılmaz",
-        "Demir",
-        "Kaya",
-        "Çelik",
-        "Yıldız",
-        "Türk",
-        "Güneş",
-        "Ergin",
-        "Arslan",
-        "Doğan",
-        "Kurt",
-        "Şahin",
-        "Güler",
-        "Çetin",
-        "Aydın",
-        "Yalçın",
-        "Kaplan",
-        "Aksoy",
-        "Taş",
-        "Koç",
-        "Erdoğan",
-        "Yılmazer",
-        "Bulut",
-        "Acar",
-        "Uçar",
-        "Kılıç",
-        "Karahan",
-        "Tekin",
-        "Soydan",
-        "Çalışkan",
-        "Öztürk",
-        "Yalın",
-        "Kara",
-        "Özkan",
-        "Akın",
-        "Aktaş",
-        "Büyükcengiz",
-        "Okan",
-        "Şimşek",
-        "Keskin",
-        "Kayabaş",
-        "Kayabaşı",
-        "Atalay",
-        "Ünal",
-        "Demirci",
-        "Yaman",
-        "Gündoğdu",
-        "Çevik",
-        "Durmaz",
-        "Aslan",
-        "Güzel",
-        "Kahraman",
-    };
-}
\ No newline at end of file
+namespace faker
+{
+const std::vector<std::string> turkishLastNames = {
+    "Yılmaz",      "Demir",    "Kaya",     "Çelik",    "Yıldız",  "Türk",     "Güneş",   "Ergin",  "Arslan",
+    "Doğan",       "Kurt",     "Şahin",    "Güler",    "Çetin",   "Aydın",    "Yalçın",  "Kaplan", "Aksoy",
+    "Taş",         "Koç",      "Erdoğan",  "Yılmazer", "Bulut",   "Acar",     "Uçar",    "Kılıç",  "Karahan",
+    "Tekin",       "Soydan",   "Çalışkan", "Öztürk",   "Yalın",   "Kara",     "Özkan",   "Akın",   "Aktaş",
+    "Büyükcengiz", "Okan",     "Şimşek",   "Keskin",   "Kayabaş", "Kayabaşı", "Atalay",  "Ünal",   "Demirci",
+    "Yaman",       "Gündoğdu", "Çevik",    "Durmaz",   "Aslan",   "Güzel",    "Kahraman"};
+}
diff --git a/src/modules/person/data/turkish/TurkishPeopleNames.h b/src/modules/person/data/turkish/TurkishPeopleNames.h
new file mode 100644
index 000000000..a9054ea44
--- /dev/null
+++ b/src/modules/person/data/turkish/TurkishPeopleNames.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "../NameFormats.h"
+#include "../PeopleNames.h"
+#include "TurkishFirstNames.h"
+#include "TurkishLastNames.h"
+#include "TurkishPrefixes.h"
+
+namespace faker
+{
+const NameFormats turkishPersonNameFormats{{{"{prefix} {firstName} {lastName}", 1}, {"{firstName} {lastName}", 8}}};
+
+const PeopleNames turkishPeopleNames{{turkishMalesFirstNames, {}, turkishLastNames, turkishMalesPrefixes, {}},
+                                     {turkishFemalesFirstNames, {}, turkishLastNames, turkishFemalesPrefixes, {}},
+                                     turkishPersonNameFormats};
+
+}
diff --git a/src/modules/person/data/turkish/TurkishPrefixes.h b/src/modules/person/data/turkish/TurkishPrefixes.h
new file mode 100644
index 000000000..46ca1428b
--- /dev/null
+++ b/src/modules/person/data/turkish/TurkishPrefixes.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace faker
+{
+const std::vector<std::string> turkishMalesPrefixes{"Bay", "Dr.", "Prof. Dr."};
+
+const std::vector<std::string> turkishFemalesPrefixes{"Bayan", "Dr.", "Prof. Dr."};
+}