diff --git a/crates/common_enums/src/enums.rs b/crates/common_enums/src/enums.rs
index 25e28112f6..bbb1be10b8 100644
--- a/crates/common_enums/src/enums.rs
+++ b/crates/common_enums/src/enums.rs
@@ -3281,6 +3281,620 @@ pub enum UsStatesAbbreviation {
     WY,
 }
 
+#[derive(
+    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, strum::Display, strum::EnumString,
+)]
+pub enum AustraliaStatesAbbreviation {
+    ACT,
+    NT,
+    NSW,
+    QLD,
+    SA,
+    TAS,
+    VIC,
+    WA,
+}
+
+#[derive(
+    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, strum::Display, strum::EnumString,
+)]
+pub enum JapanStatesAbbreviation {
+    #[strum(serialize = "23")]
+    Aichi,
+    #[strum(serialize = "05")]
+    Akita,
+    #[strum(serialize = "02")]
+    Aomori,
+    #[strum(serialize = "38")]
+    Ehime,
+    #[strum(serialize = "21")]
+    Gifu,
+    #[strum(serialize = "10")]
+    Gunma,
+    #[strum(serialize = "34")]
+    Hiroshima,
+    #[strum(serialize = "01")]
+    Hokkaido,
+    #[strum(serialize = "18")]
+    Fukui,
+    #[strum(serialize = "40")]
+    Fukuoka,
+    #[strum(serialize = "07")]
+    Fukushima,
+    #[strum(serialize = "28")]
+    Hyogo,
+    #[strum(serialize = "08")]
+    Ibaraki,
+    #[strum(serialize = "17")]
+    Ishikawa,
+    #[strum(serialize = "03")]
+    Iwate,
+    #[strum(serialize = "37")]
+    Kagawa,
+    #[strum(serialize = "46")]
+    Kagoshima,
+    #[strum(serialize = "14")]
+    Kanagawa,
+    #[strum(serialize = "39")]
+    Kochi,
+    #[strum(serialize = "43")]
+    Kumamoto,
+    #[strum(serialize = "26")]
+    Kyoto,
+    #[strum(serialize = "24")]
+    Mie,
+    #[strum(serialize = "04")]
+    Miyagi,
+    #[strum(serialize = "45")]
+    Miyazaki,
+    #[strum(serialize = "20")]
+    Nagano,
+    #[strum(serialize = "42")]
+    Nagasaki,
+    #[strum(serialize = "29")]
+    Nara,
+    #[strum(serialize = "15")]
+    Niigata,
+    #[strum(serialize = "44")]
+    Oita,
+    #[strum(serialize = "33")]
+    Okayama,
+    #[strum(serialize = "47")]
+    Okinawa,
+    #[strum(serialize = "27")]
+    Osaka,
+    #[strum(serialize = "41")]
+    Saga,
+    #[strum(serialize = "11")]
+    Saitama,
+    #[strum(serialize = "25")]
+    Shiga,
+    #[strum(serialize = "32")]
+    Shimane,
+    #[strum(serialize = "22")]
+    Shizuoka,
+    #[strum(serialize = "12")]
+    Chiba,
+    #[strum(serialize = "36")]
+    Tokusima,
+    #[strum(serialize = "13")]
+    Tokyo,
+    #[strum(serialize = "09")]
+    Tochigi,
+    #[strum(serialize = "31")]
+    Tottori,
+    #[strum(serialize = "16")]
+    Toyama,
+    #[strum(serialize = "30")]
+    Wakayama,
+    #[strum(serialize = "06")]
+    Yamagata,
+    #[strum(serialize = "35")]
+    Yamaguchi,
+    #[strum(serialize = "19")]
+    Yamanashi,
+}
+
+#[derive(
+    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, strum::Display, strum::EnumString,
+)]
+pub enum NewZealandStatesAbbreviation {
+    #[strum(serialize = "AUK")]
+    Auckland,
+    #[strum(serialize = "BOP")]
+    BayOfPlenty,
+    #[strum(serialize = "CAN")]
+    Canterbury,
+    #[strum(serialize = "GIS")]
+    Gisborne,
+    #[strum(serialize = "HKB")]
+    HawkesBay,
+    #[strum(serialize = "MWT")]
+    ManawatūWhanganui,
+    #[strum(serialize = "MBH")]
+    Marlborough,
+    #[strum(serialize = "NSN")]
+    Nelson,
+    #[strum(serialize = "NTL")]
+    Northland,
+    #[strum(serialize = "OTA")]
+    Otago,
+    #[strum(serialize = "STL")]
+    Southland,
+    #[strum(serialize = "TKI")]
+    Taranaki,
+    #[strum(serialize = "TAS")]
+    Tasman,
+    #[strum(serialize = "WKO")]
+    Waikato,
+    #[strum(serialize = "CIT")]
+    ChathamIslandsTerritory,
+    #[strum(serialize = "WGN")]
+    GreaterWellington,
+    #[strum(serialize = "WTC")]
+    WestCoast,
+}
+
+#[derive(
+    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, strum::Display, strum::EnumString,
+)]
+pub enum SingaporeStatesAbbreviation {
+    #[strum(serialize = "01")]
+    CentralSingapore,
+    #[strum(serialize = "02")]
+    NorthEast,
+    #[strum(serialize = "03")]
+    NorthWest,
+    #[strum(serialize = "04")]
+    SouthEast,
+    #[strum(serialize = "05")]
+    SouthWest,
+}
+
+#[derive(
+    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, strum::Display, strum::EnumString,
+)]
+pub enum ThailandStatesAbbreviation {
+    #[strum(serialize = "37")]
+    AmnatCharoen,
+    #[strum(serialize = "15")]
+    AngThong,
+    #[strum(serialize = "10")]
+    Bangkok,
+    #[strum(serialize = "38")]
+    BuengKan,
+    #[strum(serialize = "31")]
+    BuriRam,
+    #[strum(serialize = "24")]
+    Chachoengsao,
+    #[strum(serialize = "18")]
+    ChaiNat,
+    #[strum(serialize = "36")]
+    Chaiyaphum,
+    #[strum(serialize = "22")]
+    Chanthaburi,
+    #[strum(serialize = "57")]
+    ChiangRai,
+    #[strum(serialize = "50")]
+    ChiangMai,
+    #[strum(serialize = "20")]
+    ChonBuri,
+    #[strum(serialize = "86")]
+    Chumphon,
+    #[strum(serialize = "46")]
+    Kalasin,
+    #[strum(serialize = "62")]
+    KamphaengPhet,
+    #[strum(serialize = "71")]
+    Kanchanaburi,
+    #[strum(serialize = "40")]
+    KhonKaen,
+    #[strum(serialize = "81")]
+    Krabi,
+    #[strum(serialize = "52")]
+    Lampang,
+    #[strum(serialize = "51")]
+    Lamphun,
+    #[strum(serialize = "42")]
+    Loei,
+    #[strum(serialize = "16")]
+    LopBuri,
+    #[strum(serialize = "58")]
+    MaeHongSon,
+    #[strum(serialize = "44")]
+    MahaSarakham,
+    #[strum(serialize = "49")]
+    Mukdahan,
+    #[strum(serialize = "26")]
+    NakhonNayok,
+    #[strum(serialize = "73")]
+    NakhonPathom,
+    #[strum(serialize = "48")]
+    NakhonPhanom,
+    #[strum(serialize = "30")]
+    NakhonRatchasima,
+    #[strum(serialize = "60")]
+    NakhonSawan,
+    #[strum(serialize = "80")]
+    NakhonSiThammarat,
+    #[strum(serialize = "55")]
+    Nan,
+    #[strum(serialize = "96")]
+    Narathiwat,
+    #[strum(serialize = "39")]
+    NongBuaLamPhu,
+    #[strum(serialize = "43")]
+    NongKhai,
+    #[strum(serialize = "12")]
+    Nonthaburi,
+    #[strum(serialize = "13")]
+    PathumThani,
+    #[strum(serialize = "94")]
+    Pattani,
+    #[strum(serialize = "82")]
+    Phangnga,
+    #[strum(serialize = "93")]
+    Phatthalung,
+    #[strum(serialize = "56")]
+    Phayao,
+    #[strum(serialize = "S")]
+    Phatthaya,
+    #[strum(serialize = "67")]
+    Phetchabun,
+    #[strum(serialize = "76")]
+    Phetchaburi,
+    #[strum(serialize = "66")]
+    Phichit,
+    #[strum(serialize = "65")]
+    Phitsanulok,
+    #[strum(serialize = "54")]
+    Phrae,
+    #[strum(serialize = "14")]
+    PhraNakhonSiAyutthaya,
+    #[strum(serialize = "83")]
+    Phuket,
+    #[strum(serialize = "25")]
+    PrachinBuri,
+    #[strum(serialize = "77")]
+    PrachuapKhiriKhan,
+    #[strum(serialize = "85")]
+    Ranong,
+    #[strum(serialize = "70")]
+    Ratchaburi,
+    #[strum(serialize = "21")]
+    Rayong,
+    #[strum(serialize = "45")]
+    RoiEt,
+    #[strum(serialize = "27")]
+    SaKaeo,
+    #[strum(serialize = "47")]
+    SakonNakhon,
+    #[strum(serialize = "11")]
+    SamutPrakan,
+    #[strum(serialize = "74")]
+    SamutSakhon,
+    #[strum(serialize = "75")]
+    SamutSongkhram,
+    #[strum(serialize = "19")]
+    Saraburi,
+    #[strum(serialize = "91")]
+    Satun,
+    #[strum(serialize = "33")]
+    SiSaKet,
+    #[strum(serialize = "17")]
+    SingBuri,
+    #[strum(serialize = "90")]
+    Songkhla,
+    #[strum(serialize = "64")]
+    Sukhothai,
+    #[strum(serialize = "72")]
+    SuphanBuri,
+    #[strum(serialize = "84")]
+    SuratThani,
+    #[strum(serialize = "32")]
+    Surin,
+    #[strum(serialize = "63")]
+    Tak,
+    #[strum(serialize = "92")]
+    Trang,
+    #[strum(serialize = "23")]
+    Trat,
+    #[strum(serialize = "34")]
+    UbonRatchathani,
+    #[strum(serialize = "41")]
+    UdonThani,
+    #[strum(serialize = "61")]
+    UthaiThani,
+    #[strum(serialize = "53")]
+    Uttaradit,
+    #[strum(serialize = "95")]
+    Yala,
+    #[strum(serialize = "35")]
+    Yasothon,
+}
+
+#[derive(
+    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, strum::Display, strum::EnumString,
+)]
+pub enum PhilippinesStatesAbbreviation {
+    #[strum(serialize = "ABR")]
+    Abra,
+    #[strum(serialize = "AGN")]
+    AgusanDelNorte,
+    #[strum(serialize = "AGS")]
+    AgusanDelSur,
+    #[strum(serialize = "AKL")]
+    Aklan,
+    #[strum(serialize = "ALB")]
+    Albay,
+    #[strum(serialize = "ANT")]
+    Antique,
+    #[strum(serialize = "APA")]
+    Apayao,
+    #[strum(serialize = "AUR")]
+    Aurora,
+    #[strum(serialize = "14")]
+    AutonomousRegionInMuslimMindanao,
+    #[strum(serialize = "BAS")]
+    Basilan,
+    #[strum(serialize = "BAN")]
+    Bataan,
+    #[strum(serialize = "BTN")]
+    Batanes,
+    #[strum(serialize = "BTG")]
+    Batangas,
+    #[strum(serialize = "BEN")]
+    Benguet,
+    #[strum(serialize = "05")]
+    Bicol,
+    #[strum(serialize = "BIL")]
+    Biliran,
+    #[strum(serialize = "BOH")]
+    Bohol,
+    #[strum(serialize = "BUK")]
+    Bukidnon,
+    #[strum(serialize = "BUL")]
+    Bulacan,
+    #[strum(serialize = "CAG")]
+    Cagayan,
+    #[strum(serialize = "02")]
+    CagayanValley,
+    #[strum(serialize = "40")]
+    Calabarzon,
+    #[strum(serialize = "CAN")]
+    CamarinesNorte,
+    #[strum(serialize = "CAS")]
+    CamarinesSur,
+    #[strum(serialize = "CAM")]
+    Camiguin,
+    #[strum(serialize = "CAP")]
+    Capiz,
+    #[strum(serialize = "13")]
+    Caraga,
+    #[strum(serialize = "CAT")]
+    Catanduanes,
+    #[strum(serialize = "CAV")]
+    Cavite,
+    #[strum(serialize = "CEB")]
+    Cebu,
+    #[strum(serialize = "03")]
+    CentralLuzon,
+    #[strum(serialize = "07")]
+    CentralVisayas,
+    #[strum(serialize = "15")]
+    CordilleraAdministrativeRegion,
+    #[strum(serialize = "NCO")]
+    Cotabato,
+    #[strum(serialize = "11")]
+    Davao,
+    #[strum(serialize = "DVO")]
+    DavaoOccidental,
+    #[strum(serialize = "DAO")]
+    DavaoOriental,
+    #[strum(serialize = "COM")]
+    DavaoDeOro,
+    #[strum(serialize = "DAV")]
+    DavaoDelNorte,
+    #[strum(serialize = "DAS")]
+    DavaoDelSur,
+    #[strum(serialize = "DIN")]
+    DinagatIslands,
+    #[strum(serialize = "EAS")]
+    EasternSamar,
+    #[strum(serialize = "08")]
+    EasternVisayas,
+    #[strum(serialize = "GUI")]
+    Guimaras,
+    #[strum(serialize = "ILN")]
+    HilagangIloko,
+    #[strum(serialize = "LAN")]
+    HilagangLanaw,
+    #[strum(serialize = "MGN")]
+    HilagangMagindanaw,
+    #[strum(serialize = "NSA")]
+    HilagangSamar,
+    #[strum(serialize = "ZAN")]
+    HilagangSambuwangga,
+    #[strum(serialize = "SUN")]
+    HilagangSurigaw,
+    #[strum(serialize = "IFU")]
+    Ifugao,
+    #[strum(serialize = "01")]
+    Ilocos,
+    #[strum(serialize = "ILS")]
+    IlocosSur,
+    #[strum(serialize = "ILI")]
+    Iloilo,
+    #[strum(serialize = "ISA")]
+    Isabela,
+    #[strum(serialize = "KAL")]
+    Kalinga,
+    #[strum(serialize = "MDC")]
+    KanlurangMindoro,
+    #[strum(serialize = "MSC")]
+    KanlurangMisamis,
+    #[strum(serialize = "NEC")]
+    KanlurangNegros,
+    #[strum(serialize = "SLE")]
+    KatimogangLeyte,
+    #[strum(serialize = "QUE")]
+    Keson,
+    #[strum(serialize = "QUI")]
+    Kirino,
+    #[strum(serialize = "LUN")]
+    LaUnion,
+    #[strum(serialize = "LAG")]
+    Laguna,
+    #[strum(serialize = "MOU")]
+    LalawigangBulubundukin,
+    #[strum(serialize = "LAS")]
+    LanaoDelSur,
+    #[strum(serialize = "LEY")]
+    Leyte,
+    #[strum(serialize = "MGS")]
+    MaguindanaoDelSur,
+    #[strum(serialize = "MAD")]
+    Marinduque,
+    #[strum(serialize = "MAS")]
+    Masbate,
+    #[strum(serialize = "41")]
+    Mimaropa,
+    #[strum(serialize = "MDR")]
+    MindoroOriental,
+    #[strum(serialize = "MSR")]
+    MisamisOccidental,
+    #[strum(serialize = "00")]
+    NationalCapitalRegion,
+    #[strum(serialize = "NER")]
+    NegrosOriental,
+    #[strum(serialize = "10")]
+    NorthernMindanao,
+    #[strum(serialize = "NUE")]
+    NuevaEcija,
+    #[strum(serialize = "NUV")]
+    NuevaVizcaya,
+    #[strum(serialize = "PLW")]
+    Palawan,
+    #[strum(serialize = "PAM")]
+    Pampanga,
+    #[strum(serialize = "PAN")]
+    Pangasinan,
+    #[strum(serialize = "06")]
+    RehiyonNgKanlurangBisaya,
+    #[strum(serialize = "12")]
+    RehiyonNgSoccsksargen,
+    #[strum(serialize = "09")]
+    RehiyonNgTangwayNgSambuwangga,
+    #[strum(serialize = "RIZ")]
+    Risal,
+    #[strum(serialize = "ROM")]
+    Romblon,
+    #[strum(serialize = "WSA")]
+    Samar,
+    #[strum(serialize = "ZMB")]
+    Sambales,
+    #[strum(serialize = "ZSI")]
+    SambuwanggaSibugay,
+    #[strum(serialize = "SAR")]
+    Sarangani,
+    #[strum(serialize = "SIG")]
+    Sikihor,
+    #[strum(serialize = "SOR")]
+    Sorsogon,
+    #[strum(serialize = "SCO")]
+    SouthCotabato,
+    #[strum(serialize = "SUK")]
+    SultanKudarat,
+    #[strum(serialize = "SLU")]
+    Sulu,
+    #[strum(serialize = "SUR")]
+    SurigaoDelSur,
+    #[strum(serialize = "TAR")]
+    Tarlac,
+    #[strum(serialize = "TAW")]
+    TawiTawi,
+    #[strum(serialize = "ZAS")]
+    TimogSambuwangga,
+}
+
+#[derive(
+    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, strum::Display, strum::EnumString,
+)]
+pub enum IndiaStatesAbbreviation {
+    #[strum(serialize = "AN")]
+    AndamanAndNicobarIslands,
+    #[strum(serialize = "AP")]
+    AndhraPradesh,
+    #[strum(serialize = "AR")]
+    ArunachalPradesh,
+    #[strum(serialize = "AS")]
+    Assam,
+    #[strum(serialize = "BR")]
+    Bihar,
+    #[strum(serialize = "CH")]
+    Chandigarh,
+    #[strum(serialize = "CG")]
+    Chhattisgarh,
+    #[strum(serialize = "DL")]
+    Delhi,
+    #[strum(serialize = "DH")]
+    DadraAndNagarHaveliAndDamanAndDiu,
+    #[strum(serialize = "GA")]
+    Goa,
+    #[strum(serialize = "GJ")]
+    Gujarat,
+    #[strum(serialize = "HR")]
+    Haryana,
+    #[strum(serialize = "HP")]
+    HimachalPradesh,
+    #[strum(serialize = "JK")]
+    JammuAndKashmir,
+    #[strum(serialize = "JH")]
+    Jharkhand,
+    #[strum(serialize = "KA")]
+    Karnataka,
+    #[strum(serialize = "KL")]
+    Kerala,
+    #[strum(serialize = "LA")]
+    Ladakh,
+    #[strum(serialize = "LD")]
+    Lakshadweep,
+    #[strum(serialize = "MP")]
+    MadhyaPradesh,
+    #[strum(serialize = "MH")]
+    Maharashtra,
+    #[strum(serialize = "MN")]
+    Manipur,
+    #[strum(serialize = "ML")]
+    Meghalaya,
+    #[strum(serialize = "MZ")]
+    Mizoram,
+    #[strum(serialize = "NL")]
+    Nagaland,
+    #[strum(serialize = "OD")]
+    Odisha,
+    #[strum(serialize = "PY")]
+    Puducherry,
+    #[strum(serialize = "PB")]
+    Punjab,
+    #[strum(serialize = "RJ")]
+    Rajasthan,
+    #[strum(serialize = "SK")]
+    Sikkim,
+    #[strum(serialize = "TN")]
+    TamilNadu,
+    #[strum(serialize = "TG")]
+    Telangana,
+    #[strum(serialize = "TR")]
+    Tripura,
+    #[strum(serialize = "UP")]
+    UttarPradesh,
+    #[strum(serialize = "UK")]
+    Uttarakhand,
+    #[strum(serialize = "WB")]
+    WestBengal,
+}
+
 #[derive(
     Debug, Clone, PartialEq, Eq, Serialize, Deserialize, strum::Display, strum::EnumString,
 )]
diff --git a/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs b/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs
index 6b679f40b1..040f2de0ce 100644
--- a/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs
@@ -2281,6 +2281,7 @@ impl TryFrom<&utils::CardIssuer> for CardBrand {
             utils::CardIssuer::JCB => Ok(Self::Jcb),
             utils::CardIssuer::CarteBlanche => Ok(Self::Cartebancaire),
             utils::CardIssuer::CartesBancaires => Ok(Self::Cartebancaire),
+            utils::CardIssuer::UnionPay => Ok(Self::Cup),
         }
     }
 }
diff --git a/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs b/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs
index 1b12ed42f8..b7d175b648 100644
--- a/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs
@@ -100,6 +100,7 @@ impl From<CardIssuer> for String {
             CardIssuer::CarteBlanche => "006",
             CardIssuer::JCB => "007",
             CardIssuer::CartesBancaires => "036",
+            CardIssuer::UnionPay => "062",
         };
         card_type.to_string()
     }
diff --git a/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs b/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs
index e39c57d5ca..5b88536c66 100644
--- a/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs
@@ -499,6 +499,7 @@ impl TryFrom<utils::CardIssuer> for Gateway {
             utils::CardIssuer::DinersClub
             | utils::CardIssuer::JCB
             | utils::CardIssuer::CarteBlanche
+            | utils::CardIssuer::UnionPay
             | utils::CardIssuer::CartesBancaires => Err(errors::ConnectorError::NotImplemented(
                 utils::get_unimplemented_payment_method_error_message("Multisafe pay"),
             )
diff --git a/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs b/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs
index 2092fc40a2..4483412424 100644
--- a/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs
@@ -1,4 +1,4 @@
-use common_enums::{enums, CaptureMethod, CardNetwork, FutureUsage, PaymentChannel};
+use common_enums::{enums, CaptureMethod, FutureUsage, PaymentChannel};
 use common_types::payments::{ApplePayPaymentData, GpayTokenizationData};
 use common_utils::{
     crypto::{self, GenerateDigest},
@@ -48,7 +48,7 @@ use crate::{
     },
     utils::{
         self, convert_amount, missing_field_err, AddressData, AddressDetailsData,
-        BrowserInformationData, ForeignTryFrom, PaymentsAuthorizeRequestData,
+        BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
         PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
         PaymentsSetupMandateRequestData, RouterData as _,
     },
@@ -554,6 +554,63 @@ pub enum NuveiBIC {
     Moneyou,
 }
 
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum NuveiCardType {
+    Visa,
+    MasterCard,
+    AmericanExpress,
+    Discover,
+    DinersClub,
+    Interac,
+    JCB,
+    UnionPay,
+    CartesBancaires,
+}
+
+impl TryFrom<common_enums::CardNetwork> for NuveiCardType {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(card_network: common_enums::CardNetwork) -> Result<Self, Self::Error> {
+        match card_network {
+            common_enums::CardNetwork::Visa => Ok(Self::Visa),
+            common_enums::CardNetwork::Mastercard => Ok(Self::MasterCard),
+            common_enums::CardNetwork::AmericanExpress => Ok(Self::AmericanExpress),
+            common_enums::CardNetwork::Discover => Ok(Self::Discover),
+            common_enums::CardNetwork::DinersClub => Ok(Self::DinersClub),
+            common_enums::CardNetwork::JCB => Ok(Self::JCB),
+            common_enums::CardNetwork::UnionPay => Ok(Self::UnionPay),
+            common_enums::CardNetwork::CartesBancaires => Ok(Self::CartesBancaires),
+            common_enums::CardNetwork::Interac => Ok(Self::Interac),
+            _ => Err(errors::ConnectorError::NotSupported {
+                message: "Card network".to_string(),
+                connector: "nuvei",
+            }
+            .into()),
+        }
+    }
+}
+
+impl TryFrom<&utils::CardIssuer> for NuveiCardType {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(card_issuer: &utils::CardIssuer) -> Result<Self, Self::Error> {
+        match card_issuer {
+            utils::CardIssuer::Visa => Ok(Self::Visa),
+            utils::CardIssuer::Master => Ok(Self::MasterCard),
+            utils::CardIssuer::AmericanExpress => Ok(Self::AmericanExpress),
+            utils::CardIssuer::Discover => Ok(Self::Discover),
+            utils::CardIssuer::DinersClub => Ok(Self::DinersClub),
+            utils::CardIssuer::JCB => Ok(Self::JCB),
+            utils::CardIssuer::CartesBancaires => Ok(Self::CartesBancaires),
+            &utils::CardIssuer::UnionPay => Ok(Self::UnionPay),
+            _ => Err(errors::ConnectorError::NotSupported {
+                message: "Card network".to_string(),
+                connector: "nuvei",
+            }
+            .into()),
+        }
+    }
+}
+
 #[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -647,7 +704,7 @@ impl From<&Address> for BillingAddress {
             address: address_details.and_then(|address| address.get_optional_line1()),
             street_number: None,
             zip: address_details.and_then(|details| details.get_optional_zip()),
-            state: None,
+            state: address_details.and_then(|details| details.to_state_code_as_optional().ok()?),
             cell: None,
             address_match: None,
             address_line2: address_details.and_then(|address| address.get_optional_line2()),
@@ -941,7 +998,7 @@ struct GooglePayInfoCamelCase {
 #[serde(rename_all = "camelCase")]
 pub struct ExternalSchemeDetails {
     transaction_id: Secret<String>, // This is sensitive information
-    brand: Option<CardNetwork>,
+    brand: Option<NuveiCardType>,
 }
 #[derive(Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
@@ -1426,6 +1483,11 @@ fn get_ntid_card_info<F, Req>(
 where
     Req: NuveiAuthorizePreprocessingCommon,
 {
+    let card_type = match data.card_network.clone() {
+        Some(card_type) => NuveiCardType::try_from(card_type)?,
+        None => NuveiCardType::try_from(&data.get_card_issuer()?)?,
+    };
+
     let external_scheme_details = Some(ExternalSchemeDetails {
         transaction_id: router_data
             .request
@@ -1433,10 +1495,7 @@ where
             .ok_or_else(missing_field_err("network_transaction_id"))
             .attach_printable("Nuvei unable to find NTID for MIT")?
             .into(),
-        brand: Some(
-            data.card_network
-                .ok_or_else(missing_field_err("recurring_details.data.card_network"))?,
-        ),
+        brand: Some(card_type),
     });
     let payment_option: PaymentOption = PaymentOption {
         card: Some(Card {
@@ -2680,11 +2739,9 @@ fn process_nuvei_payment_response(
             }),
     };
 
-    let connector_response_data = convert_to_additional_payment_method_connector_response(
-        data.payment_option.clone(),
-        data.merchant_advice_code,
-    )
-    .map(ConnectorResponseData::with_additional_payment_method_data);
+    let connector_response_data =
+        convert_to_additional_payment_method_connector_response(data.payment_option.clone())
+            .map(ConnectorResponseData::with_additional_payment_method_data);
     let status = get_payment_status(
         data.amount,
         data.is_post_capture_void,
@@ -3378,28 +3435,6 @@ fn get_avs_response_description(code: &str) -> Option<&str> {
     }
 }
 
-fn get_merchant_advice_code_description(code: &str) -> Option<&str> {
-    match code {
-        "01" => Some("New Account Information Available"),
-        "02" => Some("Cannot approve at this time, try again later"),
-        "03" => Some("Do Not Try Again"),
-        "04" => Some("Token requirements not fulfilled for this token type"),
-        "21" => Some("Payment Cancellation, do not try again"),
-        "24" => Some("Retry after 1 hour"),
-        "25" => Some("Retry after 24 hours"),
-        "26" => Some("Retry after 2 days"),
-        "27" => Some("Retry after 4 days"),
-        "28" => Some("Retry after 6 days"),
-        "29" => Some("Retry after 8 days"),
-        "30" => Some("Retry after 10 days"),
-        "40" => Some("Card is a consumer non-reloadable prepaid card"),
-        "41" => Some("Card is a consumer single-use virtual card number"),
-        "42" => Some("Transaction type exceeds issuer's risk threshold. Please retry with another payment account."),
-        "43" => Some("Card is a consumer multi-use virtual card number"),
-        _ => None,
-    }
-}
-
 /// Concatenates a vector of strings without any separator
 /// This is useful for creating verification messages for webhooks
 pub fn concat_strings(strings: &[String]) -> String {
@@ -3408,24 +3443,19 @@ pub fn concat_strings(strings: &[String]) -> String {
 
 fn convert_to_additional_payment_method_connector_response(
     payment_option: Option<PaymentOption>,
-    merchant_advice_code: Option<String>,
 ) -> Option<AdditionalPaymentMethodConnectorResponse> {
     let card = payment_option.as_ref()?.card.as_ref()?;
     let avs_code = card.avs_code.as_ref();
     let cvv2_code = card.cvv2_reply.as_ref();
+
     let avs_description = avs_code.and_then(|code| get_avs_response_description(code));
     let cvv_description = cvv2_code.and_then(|code| get_cvv2_response_description(code));
-    let merchant_advice_description = merchant_advice_code
-        .as_ref()
-        .and_then(|code| get_merchant_advice_code_description(code));
 
     let payment_checks = serde_json::json!({
         "avs_result": avs_code,
         "avs_description": avs_description,
-        "cvv_2_reply": cvv2_code,
-        "cvv_2_description": cvv_description,
-        "merchant_advice_code": merchant_advice_code,
-        "merchant_advice_code_description": merchant_advice_description
+        "card_validation_result": cvv2_code,
+        "card_validation_description": cvv_description,
     });
 
     let card_network = card.brand.clone();
diff --git a/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs b/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs
index 46715408ad..2d97b2fb9b 100644
--- a/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs
@@ -77,6 +77,7 @@ impl TryFrom<CardIssuer> for PayeezyCardType {
             | CardIssuer::DinersClub
             | CardIssuer::JCB
             | CardIssuer::CarteBlanche
+            | CardIssuer::UnionPay
             | CardIssuer::CartesBancaires => Err(ConnectorError::NotImplemented(
                 get_unimplemented_payment_method_error_message("Payeezy"),
             ))?,
diff --git a/crates/hyperswitch_connectors/src/connectors/payone/transformers.rs b/crates/hyperswitch_connectors/src/connectors/payone/transformers.rs
index b8cb87d54c..25c0320a5e 100644
--- a/crates/hyperswitch_connectors/src/connectors/payone/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/payone/transformers.rs
@@ -197,6 +197,7 @@ impl TryFrom<CardIssuer> for PaymentProductId {
             | CardIssuer::DinersClub
             | CardIssuer::JCB
             | CardIssuer::CarteBlanche
+            | CardIssuer::UnionPay
             | CardIssuer::CartesBancaires => Err(ConnectorError::NotImplemented(
                 get_unimplemented_payment_method_error_message("payone"),
             )
diff --git a/crates/hyperswitch_connectors/src/utils.rs b/crates/hyperswitch_connectors/src/utils.rs
index e153ec1fdb..8505169310 100644
--- a/crates/hyperswitch_connectors/src/utils.rs
+++ b/crates/hyperswitch_connectors/src/utils.rs
@@ -13,21 +13,24 @@ use common_enums::{
     enums,
     enums::{
         AlbaniaStatesAbbreviation, AndorraStatesAbbreviation, AttemptStatus,
-        AustriaStatesAbbreviation, BelarusStatesAbbreviation, BelgiumStatesAbbreviation,
-        BosniaAndHerzegovinaStatesAbbreviation, BrazilStatesAbbreviation,
-        BulgariaStatesAbbreviation, CanadaStatesAbbreviation, CroatiaStatesAbbreviation,
-        CzechRepublicStatesAbbreviation, DenmarkStatesAbbreviation, FinlandStatesAbbreviation,
-        FranceStatesAbbreviation, FutureUsage, GermanyStatesAbbreviation, GreeceStatesAbbreviation,
-        HungaryStatesAbbreviation, IcelandStatesAbbreviation, IrelandStatesAbbreviation,
-        ItalyStatesAbbreviation, LatviaStatesAbbreviation, LiechtensteinStatesAbbreviation,
-        LithuaniaStatesAbbreviation, LuxembourgStatesAbbreviation, MaltaStatesAbbreviation,
-        MoldovaStatesAbbreviation, MonacoStatesAbbreviation, MontenegroStatesAbbreviation,
-        NetherlandsStatesAbbreviation, NorthMacedoniaStatesAbbreviation, NorwayStatesAbbreviation,
+        AustraliaStatesAbbreviation, AustriaStatesAbbreviation, BelarusStatesAbbreviation,
+        BelgiumStatesAbbreviation, BosniaAndHerzegovinaStatesAbbreviation,
+        BrazilStatesAbbreviation, BulgariaStatesAbbreviation, CanadaStatesAbbreviation,
+        CroatiaStatesAbbreviation, CzechRepublicStatesAbbreviation, DenmarkStatesAbbreviation,
+        FinlandStatesAbbreviation, FranceStatesAbbreviation, FutureUsage,
+        GermanyStatesAbbreviation, GreeceStatesAbbreviation, HungaryStatesAbbreviation,
+        IcelandStatesAbbreviation, IndiaStatesAbbreviation, IrelandStatesAbbreviation,
+        ItalyStatesAbbreviation, JapanStatesAbbreviation, LatviaStatesAbbreviation,
+        LiechtensteinStatesAbbreviation, LithuaniaStatesAbbreviation, LuxembourgStatesAbbreviation,
+        MaltaStatesAbbreviation, MoldovaStatesAbbreviation, MonacoStatesAbbreviation,
+        MontenegroStatesAbbreviation, NetherlandsStatesAbbreviation, NewZealandStatesAbbreviation,
+        NorthMacedoniaStatesAbbreviation, NorwayStatesAbbreviation, PhilippinesStatesAbbreviation,
         PolandStatesAbbreviation, PortugalStatesAbbreviation, RomaniaStatesAbbreviation,
         RussiaStatesAbbreviation, SanMarinoStatesAbbreviation, SerbiaStatesAbbreviation,
-        SlovakiaStatesAbbreviation, SloveniaStatesAbbreviation, SpainStatesAbbreviation,
-        SwedenStatesAbbreviation, SwitzerlandStatesAbbreviation, UkraineStatesAbbreviation,
-        UnitedKingdomStatesAbbreviation, UsStatesAbbreviation,
+        SingaporeStatesAbbreviation, SlovakiaStatesAbbreviation, SloveniaStatesAbbreviation,
+        SpainStatesAbbreviation, SwedenStatesAbbreviation, SwitzerlandStatesAbbreviation,
+        ThailandStatesAbbreviation, UkraineStatesAbbreviation, UnitedKingdomStatesAbbreviation,
+        UsStatesAbbreviation,
     },
 };
 use common_utils::{
@@ -1104,6 +1107,7 @@ pub enum CardIssuer {
     JCB,
     CarteBlanche,
     CartesBancaires,
+    UnionPay,
 }
 
 pub trait CardData {
@@ -1362,20 +1366,21 @@ static CARD_REGEX: LazyLock<HashMap<CardIssuer, Result<Regex, regex::Error>>> =
         map.insert(CardIssuer::Master, Regex::new(r"^5[1-5][0-9]{14}$"));
         map.insert(CardIssuer::AmericanExpress, Regex::new(r"^3[47][0-9]{13}$"));
         map.insert(CardIssuer::Visa, Regex::new(r"^4[0-9]{12}(?:[0-9]{3})?$"));
-        map.insert(CardIssuer::Discover, Regex::new(r"^65[4-9][0-9]{13}|64[4-9][0-9]{13}|6011[0-9]{12}|(622(?:12[6-9]|1[3-9][0-9]|[2-8][0-9][0-9]|9[01][0-9]|92[0-5])[0-9]{10})$"));
+        map.insert(CardIssuer::Discover, Regex::new(r"^65[0-9]{14}|64[4-9][0-9]{13}|6011[0-9]{12}|(622(?:12[6-9]|1[3-9][0-9]|[2-8][0-9][0-9]|9[01][0-9]|92[0-5])[0-9]{10})$"));
         map.insert(
             CardIssuer::Maestro,
             Regex::new(r"^(5018|5020|5038|5893|6304|6759|6761|6762|6763)[0-9]{8,15}$"),
         );
         map.insert(
             CardIssuer::DinersClub,
-            Regex::new(r"^3(?:0[0-5]|[68][0-9])[0-9]{11}$"),
+            Regex::new(r"^3(?:0[0-5][0-9]{11}|[68][0-9][0-9]{11,13})$"),
         );
         map.insert(
             CardIssuer::JCB,
             Regex::new(r"^(3(?:088|096|112|158|337|5(?:2[89]|[3-8][0-9]))\d{12})$"),
         );
         map.insert(CardIssuer::CarteBlanche, Regex::new(r"^389[0-9]{11}$"));
+        map.insert(CardIssuer::UnionPay, Regex::new(r"^(62[0-9]{14,17})$"));
         map
     },
 );
@@ -1539,6 +1544,9 @@ impl AddressDetailsData for AddressDetails {
             api_models::enums::CountryAlpha2::IT => Ok(Secret::new(
                 ItalyStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
             )),
+            api_models::enums::CountryAlpha2::JP => Ok(Secret::new(
+                JapanStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
+            )),
             api_models::enums::CountryAlpha2::LI => Ok(Secret::new(
                 LiechtensteinStatesAbbreviation::foreign_try_from(state.peek().to_string())?
                     .to_string(),
@@ -1564,6 +1572,10 @@ impl AddressDetailsData for AddressDetails {
                 NetherlandsStatesAbbreviation::foreign_try_from(state.peek().to_string())?
                     .to_string(),
             )),
+            api_models::enums::CountryAlpha2::NZ => Ok(Secret::new(
+                NewZealandStatesAbbreviation::foreign_try_from(state.peek().to_string())?
+                    .to_string(),
+            )),
             api_models::enums::CountryAlpha2::MK => Ok(Secret::new(
                 NorthMacedoniaStatesAbbreviation::foreign_try_from(state.peek().to_string())?
                     .to_string(),
@@ -1591,6 +1603,24 @@ impl AddressDetailsData for AddressDetails {
             api_models::enums::CountryAlpha2::BR => Ok(Secret::new(
                 BrazilStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
             )),
+            api_models::enums::CountryAlpha2::AU => Ok(Secret::new(
+                AustraliaStatesAbbreviation::foreign_try_from(state.peek().to_string())?
+                    .to_string(),
+            )),
+            api_models::enums::CountryAlpha2::SG => Ok(Secret::new(
+                SingaporeStatesAbbreviation::foreign_try_from(state.peek().to_string())?
+                    .to_string(),
+            )),
+            api_models::enums::CountryAlpha2::TH => Ok(Secret::new(
+                ThailandStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
+            )),
+            api_models::enums::CountryAlpha2::PH => Ok(Secret::new(
+                PhilippinesStatesAbbreviation::foreign_try_from(state.peek().to_string())?
+                    .to_string(),
+            )),
+            api_models::enums::CountryAlpha2::IN => Ok(Secret::new(
+                IndiaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
+            )),
             _ => Ok(state.clone()),
         }
     }
@@ -2792,6 +2822,28 @@ impl ForeignTryFrom<String> for CanadaStatesAbbreviation {
     }
 }
 
+impl ForeignTryFrom<String> for AustraliaStatesAbbreviation {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
+        let state =
+            parse_state_enum::<Self>(value, "AustraliaStatesAbbreviation", "address.state")?;
+        match state.as_str() {
+            "newsouthwales" => Ok(Self::NSW),
+            "queensland" => Ok(Self::QLD),
+            "southaustralia" => Ok(Self::SA),
+            "westernaustralia" => Ok(Self::WA),
+            "victoria" => Ok(Self::VIC),
+            "northernterritory" => Ok(Self::NT),
+            "australiancapitalterritory" => Ok(Self::ACT),
+            "tasmania" => Ok(Self::TAS),
+            _ => Err(errors::ConnectorError::InvalidDataFormat {
+                field_name: "address.state",
+            }
+            .into()),
+        }
+    }
+}
+
 impl ForeignTryFrom<String> for PolandStatesAbbreviation {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
@@ -3137,6 +3189,157 @@ impl ForeignTryFrom<String> for ItalyStatesAbbreviation {
     }
 }
 
+impl ForeignTryFrom<String> for JapanStatesAbbreviation {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
+        let state = parse_state_enum::<Self>(value, "JapanStatesAbbreviation", "address.state")?;
+        match state.as_str() {
+            "aichi" => Ok(Self::Aichi),
+            "akita" => Ok(Self::Akita),
+            "aomori" => Ok(Self::Aomori),
+            "chiba" => Ok(Self::Chiba),
+            "ehime" => Ok(Self::Ehime),
+            "fukui" => Ok(Self::Fukui),
+            "fukuoka" => Ok(Self::Fukuoka),
+            "fukushima" | "hukusima" => Ok(Self::Fukushima),
+            "gifu" => Ok(Self::Gifu),
+            "gunma" => Ok(Self::Gunma),
+            "hiroshima" => Ok(Self::Hiroshima),
+            "hokkaido" => Ok(Self::Hokkaido),
+            "hyogo" => Ok(Self::Hyogo),
+            "ibaraki" => Ok(Self::Ibaraki),
+            "ishikawa" => Ok(Self::Ishikawa),
+            "iwate" => Ok(Self::Iwate),
+            "kagawa" => Ok(Self::Kagawa),
+            "kagoshima" => Ok(Self::Kagoshima),
+            "kanagawa" => Ok(Self::Kanagawa),
+            "kochi" => Ok(Self::Kochi),
+            "kumamoto" => Ok(Self::Kumamoto),
+            "kyoto" => Ok(Self::Kyoto),
+            "mie" => Ok(Self::Mie),
+            "miyagi" => Ok(Self::Miyagi),
+            "miyazaki" => Ok(Self::Miyazaki),
+            "nagano" => Ok(Self::Nagano),
+            "nagasaki" => Ok(Self::Nagasaki),
+            "nara" => Ok(Self::Nara),
+            "niigata" => Ok(Self::Niigata),
+            "oita" => Ok(Self::Oita),
+            "okayama" => Ok(Self::Okayama),
+            "okinawa" => Ok(Self::Okinawa),
+            "osaka" => Ok(Self::Osaka),
+            "saga" => Ok(Self::Saga),
+            "saitama" => Ok(Self::Saitama),
+            "shiga" => Ok(Self::Shiga),
+            "shimane" => Ok(Self::Shimane),
+            "shizuoka" => Ok(Self::Shizuoka),
+            "tochigi" => Ok(Self::Tochigi),
+            "tokushima" | "tokusima" => Ok(Self::Tokusima),
+            "tokyo" => Ok(Self::Tokyo),
+            "tottori" => Ok(Self::Tottori),
+            "toyama" => Ok(Self::Toyama),
+            "wakayama" => Ok(Self::Wakayama),
+            "yamagata" => Ok(Self::Yamagata),
+            "yamaguchi" => Ok(Self::Yamaguchi),
+            "yamanashi" => Ok(Self::Yamanashi),
+            _ => Err(errors::ConnectorError::InvalidDataFormat {
+                field_name: "address.state",
+            }
+            .into()),
+        }
+    }
+}
+
+impl ForeignTryFrom<String> for ThailandStatesAbbreviation {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
+        let state = parse_state_enum::<Self>(value, "ThailandStatesAbbreviation", "address.state")?;
+        match state.as_str() {
+            "amnatcharoen" => Ok(Self::AmnatCharoen),
+            "angthong" => Ok(Self::AngThong),
+            "bangkok" => Ok(Self::Bangkok),
+            "buengkan" => Ok(Self::BuengKan),
+            "buriram" => Ok(Self::BuriRam),
+            "chachoengsao" => Ok(Self::Chachoengsao),
+            "chainat" => Ok(Self::ChaiNat),
+            "chaiyaphum" => Ok(Self::Chaiyaphum),
+            "chanthaburi" => Ok(Self::Chanthaburi),
+            "chiangmai" => Ok(Self::ChiangMai),
+            "chiangrai" => Ok(Self::ChiangRai),
+            "chonburi" => Ok(Self::ChonBuri),
+            "chumphon" => Ok(Self::Chumphon),
+            "kalasin" => Ok(Self::Kalasin),
+            "kamphaengphet" => Ok(Self::KamphaengPhet),
+            "kanchanaburi" => Ok(Self::Kanchanaburi),
+            "khonkaen" => Ok(Self::KhonKaen),
+            "krabi" => Ok(Self::Krabi),
+            "lampang" => Ok(Self::Lampang),
+            "lamphun" => Ok(Self::Lamphun),
+            "loei" => Ok(Self::Loei),
+            "lopburi" => Ok(Self::LopBuri),
+            "maehongson" => Ok(Self::MaeHongSon),
+            "mahasarakham" => Ok(Self::MahaSarakham),
+            "mukdahan" => Ok(Self::Mukdahan),
+            "nakhonnayok" => Ok(Self::NakhonNayok),
+            "nakhonpathom" => Ok(Self::NakhonPathom),
+            "nakhonphanom" => Ok(Self::NakhonPhanom),
+            "nakhonratchasima" => Ok(Self::NakhonRatchasima),
+            "nakhonsawan" => Ok(Self::NakhonSawan),
+            "nakhonsithammarat" => Ok(Self::NakhonSiThammarat),
+            "nan" => Ok(Self::Nan),
+            "narathiwat" => Ok(Self::Narathiwat),
+            "nongbualamphu" => Ok(Self::NongBuaLamPhu),
+            "nongkhai" => Ok(Self::NongKhai),
+            "nonthaburi" => Ok(Self::Nonthaburi),
+            "pathumthani" => Ok(Self::PathumThani),
+            "pattani" => Ok(Self::Pattani),
+            "phangnga" => Ok(Self::Phangnga),
+            "phatthalung" => Ok(Self::Phatthalung),
+            "phayao" => Ok(Self::Phayao),
+            "phatthaya" => Ok(Self::Phatthaya),
+            "phetchabun" => Ok(Self::Phetchabun),
+            "phetchaburi" => Ok(Self::Phetchaburi),
+            "phichit" => Ok(Self::Phichit),
+            "phitsanulok" => Ok(Self::Phitsanulok),
+            "phrae" => Ok(Self::Phrae),
+            "phuket" => Ok(Self::Phuket),
+            "prachinburi" => Ok(Self::PrachinBuri),
+            "phranakhonsiayutthaya" => Ok(Self::PhraNakhonSiAyutthaya),
+            "prachuapkhirikhan" => Ok(Self::PrachuapKhiriKhan),
+            "ranong" => Ok(Self::Ranong),
+            "ratchaburi" => Ok(Self::Ratchaburi),
+            "rayong" => Ok(Self::Rayong),
+            "roiet" => Ok(Self::RoiEt),
+            "sakaeo" => Ok(Self::SaKaeo),
+            "sakonnakhon" => Ok(Self::SakonNakhon),
+            "samutprakan" => Ok(Self::SamutPrakan),
+            "samutsakhon" => Ok(Self::SamutSakhon),
+            "samutsongkhram" => Ok(Self::SamutSongkhram),
+            "saraburi" => Ok(Self::Saraburi),
+            "satun" => Ok(Self::Satun),
+            "sisaket" => Ok(Self::SiSaKet),
+            "singburi" => Ok(Self::SingBuri),
+            "songkhla" => Ok(Self::Songkhla),
+            "sukhothai" => Ok(Self::Sukhothai),
+            "suphanburi" => Ok(Self::SuphanBuri),
+            "suratthani" => Ok(Self::SuratThani),
+            "surin" => Ok(Self::Surin),
+            "tak" => Ok(Self::Tak),
+            "trang" => Ok(Self::Trang),
+            "trat" => Ok(Self::Trat),
+            "ubonratchathani" => Ok(Self::UbonRatchathani),
+            "udonthani" => Ok(Self::UdonThani),
+            "uthaithani" => Ok(Self::UthaiThani),
+            "uttaradit" => Ok(Self::Uttaradit),
+            "yala" => Ok(Self::Yala),
+            "yasothon" => Ok(Self::Yasothon),
+            _ => Err(errors::ConnectorError::InvalidDataFormat {
+                field_name: "address.state",
+            }
+            .into()),
+        }
+    }
+}
+
 impl ForeignTryFrom<String> for NorwayStatesAbbreviation {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
@@ -3579,6 +3782,224 @@ impl ForeignTryFrom<String> for NetherlandsStatesAbbreviation {
     }
 }
 
+impl ForeignTryFrom<String> for NewZealandStatesAbbreviation {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
+        let state =
+            parse_state_enum::<Self>(value, "NewZealandStatesAbbreviation", "address.state")?;
+        match state.as_str() {
+            "auckland" | "tamakimakaurau" => Ok(Self::Auckland),
+            "bayofplenty" | "toimoana" => Ok(Self::BayOfPlenty),
+            "canterbury" | "waitaha" => Ok(Self::Canterbury),
+            "chathamislandsterritory" | "wharekauri" => Ok(Self::ChathamIslandsTerritory),
+            "gisborne" | "tetairawhiti" => Ok(Self::Gisborne),
+            "hawkesbay" | "tematauamaui" => Ok(Self::HawkesBay),
+            "manawatuwanganui" => Ok(Self::ManawatūWhanganui),
+            "marlborough" => Ok(Self::Marlborough),
+            "nelson" | "whakatu" => Ok(Self::Nelson),
+            "northland" | "tetaitokerau" => Ok(Self::Northland),
+            "otago" | "otakou" => Ok(Self::Otago),
+            "southland" | "tetaiaotonga" => Ok(Self::Southland),
+            "taranaki" => Ok(Self::Taranaki),
+            "tasman" | "tetaioaorere" => Ok(Self::Tasman),
+            "waikato" => Ok(Self::Waikato),
+            "greaterwellington" | "tepanematuataiao" => Ok(Self::GreaterWellington),
+            "westcoast" | "tetaiopoutini" => Ok(Self::WestCoast),
+            _ => Err(errors::ConnectorError::InvalidDataFormat {
+                field_name: "address.state",
+            }
+            .into()),
+        }
+    }
+}
+
+impl ForeignTryFrom<String> for SingaporeStatesAbbreviation {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
+        let state =
+            parse_state_enum::<Self>(value, "SingaporeStatesAbbreviation", "address.state")?;
+        match state.as_str() {
+            "centralsingapore" => Ok(Self::CentralSingapore),
+            "northeast" => Ok(Self::NorthEast),
+            "northwest" => Ok(Self::NorthWest),
+            "southeast" => Ok(Self::SouthEast),
+            "southwest" => Ok(Self::SouthWest),
+            _ => Err(errors::ConnectorError::InvalidDataFormat {
+                field_name: "address.state",
+            }
+            .into()),
+        }
+    }
+}
+
+impl ForeignTryFrom<String> for PhilippinesStatesAbbreviation {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
+        let state =
+            parse_state_enum::<Self>(value, "PhilippinesStatesAbbreviation", "address.state")?;
+        match state.as_str() {
+            "abra" => Ok(Self::Abra),
+            "agusandelnorte" | "hilagangagusan" => Ok(Self::AgusanDelNorte),
+            "agusandelsur" | "timogagusan" => Ok(Self::AgusanDelSur),
+            "aklan" => Ok(Self::Aklan),
+            "albay" => Ok(Self::Albay),
+            "antique" | "antike" => Ok(Self::Antique),
+            "apayao" | "apayaw" => Ok(Self::Apayao),
+            "aurora" => Ok(Self::Aurora),
+            "autonomousregioninmuslimmindanao" | "nagsasarilingrehiyonngmuslimsamindanaw" => {
+                Ok(Self::AutonomousRegionInMuslimMindanao)
+            }
+            "basilan" => Ok(Self::Basilan),
+            "bataan" => Ok(Self::Bataan),
+            "batanes" => Ok(Self::Batanes),
+            "batangas" => Ok(Self::Batangas),
+            "benguet" | "benget" => Ok(Self::Benguet),
+            "bicol" | "rehiyonngbikol" => Ok(Self::Bicol),
+            "biliran" => Ok(Self::Biliran),
+            "bohol" => Ok(Self::Bohol),
+            "bukidnon" => Ok(Self::Bukidnon),
+            "bulacan" | "bulakan" => Ok(Self::Bulacan),
+            "cagayan" | "kagayan" => Ok(Self::Cagayan),
+            "cagayanvalley" | "rehiyonnglambakngkagayan" => Ok(Self::CagayanValley),
+            "calabarzon" | "rehiyonngcalabarzon" => Ok(Self::Calabarzon),
+            "camarinesnorte" | "hilagangkamarines" => Ok(Self::CamarinesNorte),
+            "camarinessur" | "timogkamarines" => Ok(Self::CamarinesSur),
+            "camiguin" | "kamigin" => Ok(Self::Camiguin),
+            "capiz" | "kapis" => Ok(Self::Capiz),
+            "caraga" | "rehiyonngkaraga" => Ok(Self::Caraga),
+            "catanduanes" | "katanduanes" => Ok(Self::Catanduanes),
+            "cavite" | "kabite" => Ok(Self::Cavite),
+            "cebu" | "sebu" => Ok(Self::Cebu),
+            "centralluzon" | "rehiyonnggitnangluzon" => Ok(Self::CentralLuzon),
+            "centralvisayas" | "rehiyonnggitnangbisaya" => Ok(Self::CentralVisayas),
+            "cordilleraadministrativeregion" | "rehiyonngadministratibongkordilyera" => {
+                Ok(Self::CordilleraAdministrativeRegion)
+            }
+            "cotabato" | "kotabato" => Ok(Self::Cotabato),
+            "davao" | "rehiyonngdabaw" => Ok(Self::Davao),
+            "davaooccidental" | "kanlurangdabaw" => Ok(Self::DavaoOccidental),
+            "davaooriental" | "silangangdabaw" => Ok(Self::DavaoOriental),
+            "davaodeoro" => Ok(Self::DavaoDeOro),
+            "davaodelnorte" | "hilagangdabaw" => Ok(Self::DavaoDelNorte),
+            "davaodelsur" | "timogdabaw" => Ok(Self::DavaoDelSur),
+            "dinagatislands" | "pulongdinagat" => Ok(Self::DinagatIslands),
+            "easternsamar" | "silangangsamar" => Ok(Self::EasternSamar),
+            "easternvisayas" | "rehiyonngsilangangbisaya" => Ok(Self::EasternVisayas),
+            "guimaras" | "gimaras" => Ok(Self::Guimaras),
+            "hilagangiloko" | "ilocosnorte" => Ok(Self::HilagangIloko),
+            "hilaganglanaw" | "lanaodelnorte" => Ok(Self::HilagangLanaw),
+            "hilagangmagindanaw" | "maguindanaodelnorte" => Ok(Self::HilagangMagindanaw),
+            "hilagangsamar" | "northernsamar" => Ok(Self::HilagangSamar),
+            "hilagangsambuwangga" | "zamboangadelnorte" => Ok(Self::HilagangSambuwangga),
+            "hilagangsurigaw" | "surigaodelnorte" => Ok(Self::HilagangSurigaw),
+            "ifugao" | "ipugaw" => Ok(Self::Ifugao),
+            "ilocos" | "rehiyonngiloko" => Ok(Self::Ilocos),
+            "ilocossur" | "timogiloko" => Ok(Self::IlocosSur),
+            "iloilo" | "iloylo" => Ok(Self::Iloilo),
+            "isabela" => Ok(Self::Isabela),
+            "kalinga" => Ok(Self::Kalinga),
+            "kanlurangmindoro" | "mindorooccidental" => Ok(Self::KanlurangMindoro),
+            "kanlurangmisamis" | "misamisoriental" => Ok(Self::KanlurangMisamis),
+            "kanlurangnegros" | "negrosoccidental" => Ok(Self::KanlurangNegros),
+            "katimogangleyte" | "southernleyte" => Ok(Self::KatimogangLeyte),
+            "keson" | "quezon" => Ok(Self::Keson),
+            "kirino" | "quirino" => Ok(Self::Kirino),
+            "launion" => Ok(Self::LaUnion),
+            "laguna" => Ok(Self::Laguna),
+            "lalawigangbulubundukin" | "mountainprovince" => Ok(Self::LalawigangBulubundukin),
+            "lanaodelsur" | "timoglanaw" => Ok(Self::LanaoDelSur),
+            "leyte" => Ok(Self::Leyte),
+            "maguidanaodelsur" | "timogmaguindanao" => Ok(Self::MaguindanaoDelSur),
+            "marinduque" => Ok(Self::Marinduque),
+            "masbate" => Ok(Self::Masbate),
+            "mimaropa" | "rehiyonngmimaropa" => Ok(Self::Mimaropa),
+            "mindorooriental" | "silingangmindoro" => Ok(Self::MindoroOriental),
+            "misamisoccidental" | "silingangmisamis" => Ok(Self::MisamisOccidental),
+            "nationalcapitalregion" | "pambansangpunonglungsod" => Ok(Self::NationalCapitalRegion),
+            "negrosoriental" | "silingangnegros" => Ok(Self::NegrosOriental),
+            "northernmindanao" | "rehiyonnghilagangmindanao" => Ok(Self::NorthernMindanao),
+            "nuevaecija" | "nuwevaesiha" => Ok(Self::NuevaEcija),
+            "nuevavizcaya" => Ok(Self::NuevaVizcaya),
+            "palawan" => Ok(Self::Palawan),
+            "pampanga" => Ok(Self::Pampanga),
+            "pangasinan" => Ok(Self::Pangasinan),
+            "rehiyonngkanlurangbisaya" | "westernvisayas" => Ok(Self::RehiyonNgKanlurangBisaya),
+            "rehiyonngsoccsksargen" | "soccsksargen" => Ok(Self::RehiyonNgSoccsksargen),
+            "rehiyonngtangwayngsambuwangga" | "zamboangapeninsula" => {
+                Ok(Self::RehiyonNgTangwayNgSambuwangga)
+            }
+            "risal" | "rizal" => Ok(Self::Risal),
+            "romblon" => Ok(Self::Romblon),
+            "samar" => Ok(Self::Samar),
+            "sambales" | "zambales" => Ok(Self::Sambales),
+            "sambuwanggasibugay" | "zamboangasibugay" => Ok(Self::SambuwanggaSibugay),
+            "sarangani" => Ok(Self::Sarangani),
+            "siquijor" | "sikihor" => Ok(Self::Sikihor),
+            "sorsogon" => Ok(Self::Sorsogon),
+            "southcotabato" | "timogkotabato" => Ok(Self::SouthCotabato),
+            "sultankudarat" => Ok(Self::SultanKudarat),
+            "sulu" => Ok(Self::Sulu),
+            "surigaodelsur" | "timogsurigaw" => Ok(Self::SurigaoDelSur),
+            "tarlac" => Ok(Self::Tarlac),
+            "tawitawi" => Ok(Self::TawiTawi),
+            "timogsambuwangga" | "zamboangadelsur" => Ok(Self::TimogSambuwangga),
+            _ => Err(errors::ConnectorError::InvalidDataFormat {
+                field_name: "address.state",
+            }
+            .into()),
+        }
+    }
+}
+
+impl ForeignTryFrom<String> for IndiaStatesAbbreviation {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
+        let state = parse_state_enum::<Self>(value, "IndiaStatesAbbreviation", "address.state")?;
+        match state.as_str() {
+            "andamanandnicobarislands" => Ok(Self::AndamanAndNicobarIslands),
+            "andhrapradesh" => Ok(Self::AndhraPradesh),
+            "arunachalpradesh" => Ok(Self::ArunachalPradesh),
+            "assam" => Ok(Self::Assam),
+            "bihar" => Ok(Self::Bihar),
+            "chandigarh" => Ok(Self::Chandigarh),
+            "chhattisgarh" => Ok(Self::Chhattisgarh),
+            "dadraandnagarhavelianddamananddiu" => Ok(Self::DadraAndNagarHaveliAndDamanAndDiu),
+            "delhi" => Ok(Self::Delhi),
+            "goa" => Ok(Self::Goa),
+            "gujarat" => Ok(Self::Gujarat),
+            "haryana" => Ok(Self::Haryana),
+            "himachalpradesh" => Ok(Self::HimachalPradesh),
+            "jammuandkashmir" => Ok(Self::JammuAndKashmir),
+            "jharkhand" => Ok(Self::Jharkhand),
+            "karnataka" => Ok(Self::Karnataka),
+            "kerala" => Ok(Self::Kerala),
+            "ladakh" => Ok(Self::Ladakh),
+            "lakshadweep" => Ok(Self::Lakshadweep),
+            "madhyapradesh" => Ok(Self::MadhyaPradesh),
+            "maharashtra" => Ok(Self::Maharashtra),
+            "manipur" => Ok(Self::Manipur),
+            "meghalaya" => Ok(Self::Meghalaya),
+            "mizoram" => Ok(Self::Mizoram),
+            "nagaland" => Ok(Self::Nagaland),
+            "odisha" => Ok(Self::Odisha),
+            "puducherry" | "pondicherry" => Ok(Self::Puducherry),
+            "punjab" => Ok(Self::Punjab),
+            "rajasthan" => Ok(Self::Rajasthan),
+            "sikkim" => Ok(Self::Sikkim),
+            "tamilnadu" => Ok(Self::TamilNadu),
+            "telangana" => Ok(Self::Telangana),
+            "tripura" => Ok(Self::Tripura),
+            "uttarpradesh" => Ok(Self::UttarPradesh),
+            "uttarakhand" => Ok(Self::Uttarakhand),
+            "westbengal" => Ok(Self::WestBengal),
+            _ => Err(errors::ConnectorError::InvalidDataFormat {
+                field_name: "address.state",
+            }
+            .into()),
+        }
+    }
+}
+
 impl ForeignTryFrom<String> for MoldovaStatesAbbreviation {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
@@ -6417,6 +6838,32 @@ pub fn normalize_string(value: String) -> Result<String, regex::Error> {
     let normalized = regex.replace_all(&lowercase_value, "").to_string();
     Ok(normalized)
 }
+
+fn normalize_state(value: String) -> Result<String, error_stack::Report<errors::ConnectorError>> {
+    normalize_string(value).map_err(|_e| {
+        error_stack::Report::new(errors::ConnectorError::InvalidDataFormat {
+            field_name: "address.state",
+        })
+    })
+}
+
+pub fn parse_state_enum<T>(
+    value: String,
+    enum_name: &'static str,
+    field_name: &'static str,
+) -> Result<String, error_stack::Report<errors::ConnectorError>>
+where
+    T: FromStr,
+    <T as FromStr>::Err: std::error::Error + Send + Sync + 'static,
+{
+    match StringExt::<T>::parse_enum(value.clone(), enum_name) {
+        Ok(_) => Ok(value),
+        Err(_) => normalize_state(value).map_err(|_e| {
+            error_stack::Report::new(errors::ConnectorError::InvalidDataFormat { field_name })
+        }),
+    }
+}
+
 #[cfg(feature = "frm")]
 pub trait FrmTransactionRouterDataRequest {
     fn is_payment_successful(&self) -> Option<bool>;