Issue:
Bug: [CI] Add mock credentials for alpha connectors in CI



updating the creds for alpha connectors makes no sense. we've complete control over the alpha connector's behavior. so, better add a mock / fake credentials that mimic this behavior.

Pull request description:
## Type of Change
<!-- Put an `x` in the boxes that apply -->

- [ ] Bugfix
- [x] New feature
- [ ] Enhancement
- [ ] Refactoring
- [ ] Dependency updates
- [ ] Documentation
- [ ] CI/CD

## Description
<!-- Describe your changes in detail -->
Integrate celero commerce connector

Doc : https://sandbox.gotnpgateway.com/docs/api/transactions
[x] Cards
[x] Avs

### Additional Changes

- [x] This PR modifies the API contract
- [ ] This PR modifies the database schema
- [ ] This PR modifies application configuration/environment variables

<!--

Provide links to the files with corresponding changes.

Following are the paths where you can find config files:
1. `config`
2. `crates/router/src/configs`
3. `loadtest/config`
-->


MOCK SERVER results

<img width="803" height="920" alt="Screenshot 2025-08-05 at 11 37 29 AM" src="https://github.com/user-attachments/assets/19bee0c6-f0e4-4123-b423-b959c229899b" />
<img width="560" height="926" alt="Screenshot 2025-08-05 at 11 37 38 AM" src="https://github.com/user-attachments/assets/2e9c08e7-aba4-4799-b3b5-4a0f3df9360e" />
<img width="930" height="1001" alt="Screenshot 2025-08-05 at 11 37 54 AM" src="https://github.com/user-attachments/assets/e8b202e1-a5a0-4afe-8574-93944b61d816" />
![Uploading Screenshot 2025-08-06 at 3.00.16 PM.png…]()


## Motivation and Context
<!--
Why is this change required? What problem does it solve?
If it fixes an open issue, please link to the issue here.

If you don't have an issue, we'd recommend starting with one first so the PR
can focus on the implementation (unless it is an obvious bug or documentation fix
that will have little conversation).
-->
https://github.com/juspay/hyperswitch/issues/8575

## How did you test it?
<!--
Did you write an integration/unit/API test to verify the code changes?
Or did you test this change manually (provide relevant screenshots)?
-->
No creds for testing 

## Checklist
<!-- Put an `x` in the boxes that apply -->

- [x] I formatted the code `cargo +nightly fmt --all`
- [x] I addressed lints thrown by `cargo clippy`
- [x] I reviewed the submitted code
- [x] I added unit tests for my changes where possible


Testing:

No creds for testing 

Patch:
diff --git a/crates/connector_configs/toml/development.toml b/crates/connector_configs/toml/development.toml
index 83544e40cc1..160a29aa1a3 100644
--- a/crates/connector_configs/toml/development.toml
+++ b/crates/connector_configs/toml/development.toml
@@ -1446,6 +1446,35 @@ merchant_id_evoucher="MerchantId Evoucher"
 [cashtocode.connector_webhook_details]
 merchant_secret="Source verification key"
 
+[celero]
+[[celero.credit]]
+  payment_method_type = "AmericanExpress"
+[[celero.credit]]
+  payment_method_type = "Discover"
+[[celero.credit]]
+  payment_method_type = "DinersClub"
+[[celero.credit]]
+  payment_method_type = "JCB"
+[[celero.credit]]
+  payment_method_type = "Mastercard"
+[[celero.credit]]
+  payment_method_type = "Visa"
+[[celero.debit]]
+  payment_method_type = "AmericanExpress"
+[[celero.debit]]
+  payment_method_type = "Discover"
+[[celero.debit]]
+  payment_method_type = "DinersClub"
+[[celero.debit]]
+  payment_method_type = "JCB"
+[[celero.debit]]
+  payment_method_type = "Mastercard"
+[[celero.debit]]
+  payment_method_type = "Visa"
+[celero.connector_auth.HeaderKey]
+api_key="Celero API Key"
+
+
 [checkbook]
 [[checkbook.bank_transfer]]
 payment_method_type = "ach"
diff --git a/crates/connector_configs/toml/production.toml b/crates/connector_configs/toml/production.toml
index 019d842b8d1..47aff66d845 100644
--- a/crates/connector_configs/toml/production.toml
+++ b/crates/connector_configs/toml/production.toml
@@ -1212,6 +1212,34 @@ key1 = "Secret Key"
 [cryptopay.connector_webhook_details]
 merchant_secret = "Source verification key"
 
+[celero]
+[[celero.credit]]
+  payment_method_type = "AmericanExpress"
+[[celero.credit]]
+  payment_method_type = "Discover"
+[[celero.credit]]
+  payment_method_type = "DinersClub"
+[[celero.credit]]
+  payment_method_type = "JCB"
+[[celero.credit]]
+  payment_method_type = "Mastercard"
+[[celero.credit]]
+  payment_method_type = "Visa"
+[[celero.debit]]
+  payment_method_type = "AmericanExpress"
+[[celero.debit]]
+  payment_method_type = "Discover"
+[[celero.debit]]
+  payment_method_type = "DinersClub"
+[[celero.debit]]
+  payment_method_type = "JCB"
+[[celero.debit]]
+  payment_method_type = "Mastercard"
+[[celero.debit]]
+  payment_method_type = "Visa"
+[celero.connector_auth.HeaderKey]
+api_key="Celero API Key"
+
 [checkbook]
 [[checkbook.bank_transfer]]
   payment_method_type = "ach"
diff --git a/crates/connector_configs/toml/sandbox.toml b/crates/connector_configs/toml/sandbox.toml
index 8571315082e..d1ea6ba609f 100644
--- a/crates/connector_configs/toml/sandbox.toml
+++ b/crates/connector_configs/toml/sandbox.toml
@@ -1445,6 +1445,35 @@ merchant_id_evoucher = "MerchantId Evoucher"
 [cashtocode.connector_webhook_details]
 merchant_secret = "Source verification key"
 
+[celero]
+[[celero.credit]]
+  payment_method_type = "AmericanExpress"
+[[celero.credit]]
+  payment_method_type = "Discover"
+[[celero.credit]]
+  payment_method_type = "DinersClub"
+[[celero.credit]]
+  payment_method_type = "JCB"
+[[celero.credit]]
+  payment_method_type = "Mastercard"
+[[celero.credit]]
+  payment_method_type = "Visa"
+[[celero.debit]]
+  payment_method_type = "AmericanExpress"
+[[celero.debit]]
+  payment_method_type = "Discover"
+[[celero.debit]]
+  payment_method_type = "DinersClub"
+[[celero.debit]]
+  payment_method_type = "JCB"
+[[celero.debit]]
+  payment_method_type = "Mastercard"
+[[celero.debit]]
+  payment_method_type = "Visa"
+[celero.connector_auth.HeaderKey]
+api_key="Celero API Key"
+
+
 [checkbook]
 [[checkbook.bank_transfer]]
   payment_method_type = "ach"
diff --git a/crates/hyperswitch_connectors/src/connectors/celero.rs b/crates/hyperswitch_connectors/src/connectors/celero.rs
index 9db111a10e4..726791a72eb 100644
--- a/crates/hyperswitch_connectors/src/connectors/celero.rs
+++ b/crates/hyperswitch_connectors/src/connectors/celero.rs
@@ -1,10 +1,13 @@
 pub mod transformers;
 
+use std::sync::LazyLock;
+
+use common_enums::enums;
 use common_utils::{
     errors::CustomResult,
     ext_traits::BytesExt,
     request::{Method, Request, RequestBuilder, RequestContent},
-    types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
+    types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
 };
 use error_stack::{report, ResultExt};
 use hyperswitch_domain_models::{
@@ -19,7 +22,10 @@ use hyperswitch_domain_models::{
         PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
         RefundsData, SetupMandateRequestData,
     },
-    router_response_types::{PaymentsResponseData, RefundsResponseData},
+    router_response_types::{
+        ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
+        SupportedPaymentMethods, SupportedPaymentMethodsExt,
+    },
     types::{
         PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
         RefundSyncRouterData, RefundsRouterData,
@@ -43,13 +49,13 @@ use crate::{constants::headers, types::ResponseRouterData, utils};
 
 #[derive(Clone)]
 pub struct Celero {
-    amount_converter: &'static (dyn AmountConvertor<Output = StringMinorUnit> + Sync),
+    amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
 }
 
 impl Celero {
     pub fn new() -> &'static Self {
         &Self {
-            amount_converter: &StringMinorUnitForConnector,
+            amount_converter: &MinorUnitForConnector,
         }
     }
 }
@@ -98,10 +104,7 @@ impl ConnectorCommon for Celero {
     }
 
     fn get_currency_unit(&self) -> api::CurrencyUnit {
-        api::CurrencyUnit::Base
-        //    TODO! Check connector documentation, on which unit they are processing the currency.
-        //    If the connector accepts amount in lower unit ( i.e cents for USD) then return api::CurrencyUnit::Minor,
-        //    if connector accepts amount in base unit (i.e dollars for USD) then return api::CurrencyUnit::Base
+        api::CurrencyUnit::Minor
     }
 
     fn common_get_content_type(&self) -> &'static str {
@@ -137,23 +140,53 @@ impl ConnectorCommon for Celero {
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
 
+        // Extract error details from the response
+        let error_details = celero::CeleroErrorDetails::from(response);
+
         Ok(ErrorResponse {
             status_code: res.status_code,
-            code: response.code,
-            message: response.message,
-            reason: response.reason,
+            code: error_details
+                .error_code
+                .unwrap_or_else(|| "UNKNOWN_ERROR".to_string()),
+            message: error_details.error_message,
+            reason: error_details.decline_reason,
             attempt_status: None,
             connector_transaction_id: None,
-            network_decline_code: None,
+            network_decline_code: error_details.processor_response_code.clone(),
             network_advice_code: None,
-            network_error_message: None,
+            network_error_message: error_details.processor_response_code,
             connector_metadata: None,
         })
     }
 }
 
 impl ConnectorValidation for Celero {
-    //TODO: implement functions when support enabled
+    fn validate_connector_against_payment_request(
+        &self,
+        capture_method: Option<enums::CaptureMethod>,
+        _payment_method: enums::PaymentMethod,
+        _pmt: Option<enums::PaymentMethodType>,
+    ) -> CustomResult<(), errors::ConnectorError> {
+        let capture_method = capture_method.unwrap_or_default();
+
+        // CeleroCommerce supports both automatic (sale) and manual (authorize + capture) flows
+        let is_capture_method_supported = matches!(
+            capture_method,
+            enums::CaptureMethod::Automatic
+                | enums::CaptureMethod::Manual
+                | enums::CaptureMethod::SequentialAutomatic
+        );
+
+        if is_capture_method_supported {
+            Ok(())
+        } else {
+            Err(errors::ConnectorError::NotSupported {
+                message: capture_method.to_string(),
+                connector: self.id(),
+            }
+            .into())
+        }
+    }
 }
 
 impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Celero {
@@ -180,9 +213,9 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
     fn get_url(
         &self,
         _req: &PaymentsAuthorizeRouterData,
-        _connectors: &Connectors,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        Ok(format!("{}/api/transaction", self.base_url(connectors)))
     }
 
     fn get_request_body(
@@ -196,7 +229,7 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
             req.request.currency,
         )?;
 
-        let connector_router_data = celero::CeleroRouterData::from((amount, req));
+        let connector_router_data = celero::CeleroRouterData::try_from((amount, req))?;
         let connector_req = celero::CeleroPaymentsRequest::try_from(&connector_router_data)?;
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
@@ -267,9 +300,22 @@ impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Cel
     fn get_url(
         &self,
         _req: &PaymentsSyncRouterData,
-        _connectors: &Connectors,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        // CeleroCommerce uses search API for payment sync
+        Ok(format!(
+            "{}/api/transaction/search",
+            self.base_url(connectors)
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &PaymentsSyncRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, errors::ConnectorError> {
+        let connector_req = celero::CeleroSearchRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
@@ -279,10 +325,13 @@ impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Cel
     ) -> CustomResult<Option<Request>, errors::ConnectorError> {
         Ok(Some(
             RequestBuilder::new()
-                .method(Method::Get)
+                .method(Method::Post)
                 .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
                 .attach_default_headers()
                 .headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
+                .set_body(types::PaymentsSyncType::get_request_body(
+                    self, req, connectors,
+                )?)
                 .build(),
         ))
     }
@@ -330,18 +379,31 @@ impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> fo
 
     fn get_url(
         &self,
-        _req: &PaymentsCaptureRouterData,
-        _connectors: &Connectors,
+        req: &PaymentsCaptureRouterData,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let connector_payment_id = req.request.connector_transaction_id.clone();
+        Ok(format!(
+            "{}/api/transaction/{}/capture",
+            self.base_url(connectors),
+            connector_payment_id
+        ))
     }
 
     fn get_request_body(
         &self,
-        _req: &PaymentsCaptureRouterData,
+        req: &PaymentsCaptureRouterData,
         _connectors: &Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_request_body method".to_string()).into())
+        let amount = utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_amount_to_capture,
+            req.request.currency,
+        )?;
+
+        let connector_router_data = celero::CeleroRouterData::try_from((amount, req))?;
+        let connector_req = celero::CeleroCaptureRequest::try_from(&connector_router_data)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
@@ -370,7 +432,7 @@ impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> fo
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
-        let response: celero::CeleroPaymentsResponse = res
+        let response: celero::CeleroCaptureResponse = res
             .response
             .parse_struct("Celero PaymentsCaptureResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
@@ -392,7 +454,77 @@ impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> fo
     }
 }
 
-impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Celero {}
+impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Celero {
+    fn get_headers(
+        &self,
+        req: &RouterData<Void, PaymentsCancelData, PaymentsResponseData>,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &RouterData<Void, PaymentsCancelData, PaymentsResponseData>,
+        connectors: &Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        let connector_payment_id = req.request.connector_transaction_id.clone();
+        Ok(format!(
+            "{}/api/transaction/{}/void",
+            self.base_url(connectors),
+            connector_payment_id
+        ))
+    }
+
+    fn build_request(
+        &self,
+        req: &RouterData<Void, PaymentsCancelData, PaymentsResponseData>,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, errors::ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &RouterData<Void, PaymentsCancelData, PaymentsResponseData>,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<
+        RouterData<Void, PaymentsCancelData, PaymentsResponseData>,
+        errors::ConnectorError,
+    > {
+        let response: celero::CeleroVoidResponse = res
+            .response
+            .parse_struct("Celero PaymentsVoidResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
 
 impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Celero {
     fn get_headers(
@@ -409,10 +541,15 @@ impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Celero
 
     fn get_url(
         &self,
-        _req: &RefundsRouterData<Execute>,
-        _connectors: &Connectors,
+        req: &RefundsRouterData<Execute>,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let connector_payment_id = req.request.connector_transaction_id.clone();
+        Ok(format!(
+            "{}/api/transaction/{}/refund",
+            self.base_url(connectors),
+            connector_payment_id
+        ))
     }
 
     fn get_request_body(
@@ -426,7 +563,7 @@ impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Celero
             req.request.currency,
         )?;
 
-        let connector_router_data = celero::CeleroRouterData::from((refund_amount, req));
+        let connector_router_data = celero::CeleroRouterData::try_from((refund_amount, req))?;
         let connector_req = celero::CeleroRefundRequest::try_from(&connector_router_data)?;
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
@@ -456,10 +593,10 @@ impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Celero
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
-        let response: celero::RefundResponse =
-            res.response
-                .parse_struct("celero RefundResponse")
-                .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        let response: celero::CeleroRefundResponse = res
+            .response
+            .parse_struct("celero RefundResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
         RouterData::try_from(ResponseRouterData {
@@ -494,9 +631,22 @@ impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Celero {
     fn get_url(
         &self,
         _req: &RefundSyncRouterData,
-        _connectors: &Connectors,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        // CeleroCommerce uses search API for refund sync
+        Ok(format!(
+            "{}/api/transaction/search",
+            self.base_url(connectors)
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &RefundSyncRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, errors::ConnectorError> {
+        let connector_req = celero::CeleroSearchRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
@@ -506,7 +656,7 @@ impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Celero {
     ) -> CustomResult<Option<Request>, errors::ConnectorError> {
         Ok(Some(
             RequestBuilder::new()
-                .method(Method::Get)
+                .method(Method::Post)
                 .url(&types::RefundSyncType::get_url(self, req, connectors)?)
                 .attach_default_headers()
                 .headers(types::RefundSyncType::get_headers(self, req, connectors)?)
@@ -523,7 +673,7 @@ impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Celero {
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
-        let response: celero::RefundResponse = res
+        let response: celero::CeleroRefundResponse = res
             .response
             .parse_struct("celero RefundSyncResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
@@ -569,4 +719,80 @@ impl webhooks::IncomingWebhook for Celero {
     }
 }
 
-impl ConnectorSpecifications for Celero {}
+static CELERO_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> = LazyLock::new(|| {
+    let supported_capture_methods = vec![
+        enums::CaptureMethod::Automatic,
+        enums::CaptureMethod::Manual,
+        enums::CaptureMethod::SequentialAutomatic,
+    ];
+    let supported_card_network = vec![
+        common_enums::CardNetwork::AmericanExpress,
+        common_enums::CardNetwork::Discover,
+        common_enums::CardNetwork::DinersClub,
+        common_enums::CardNetwork::JCB,
+        common_enums::CardNetwork::Mastercard,
+        common_enums::CardNetwork::Visa,
+    ];
+
+    let mut celero_supported_payment_methods = SupportedPaymentMethods::new();
+
+    celero_supported_payment_methods.add(
+        enums::PaymentMethod::Card,
+        enums::PaymentMethodType::Credit,
+        PaymentMethodDetails {
+            mandates: enums::FeatureStatus::NotSupported,
+            refunds: enums::FeatureStatus::Supported,
+            supported_capture_methods: supported_capture_methods.clone(),
+            specific_features: Some(
+                api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
+                    api_models::feature_matrix::CardSpecificFeatures {
+                        three_ds: common_enums::FeatureStatus::NotSupported,
+                        no_three_ds: common_enums::FeatureStatus::Supported,
+                        supported_card_networks: supported_card_network.clone(),
+                    }
+                }),
+            ),
+        },
+    );
+
+    celero_supported_payment_methods.add(
+        enums::PaymentMethod::Card,
+        enums::PaymentMethodType::Debit,
+        PaymentMethodDetails {
+            mandates: enums::FeatureStatus::NotSupported,
+            refunds: enums::FeatureStatus::Supported,
+            supported_capture_methods: supported_capture_methods.clone(),
+            specific_features: Some(
+                api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
+                    api_models::feature_matrix::CardSpecificFeatures {
+                        three_ds: common_enums::FeatureStatus::NotSupported,
+                        no_three_ds: common_enums::FeatureStatus::Supported,
+                        supported_card_networks: supported_card_network.clone(),
+                    }
+                }),
+            ),
+        },
+    );
+
+    celero_supported_payment_methods
+});
+
+static CELERO_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
+    display_name: "Celero",
+    description: "Celero is your trusted provider for payment processing technology and solutions, with a commitment to helping small to mid-sized businesses thrive",
+    connector_type: enums::PaymentConnectorCategory::PaymentGateway,
+};
+
+impl ConnectorSpecifications for Celero {
+    fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
+        Some(&CELERO_CONNECTOR_INFO)
+    }
+
+    fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
+        Some(&*CELERO_SUPPORTED_PAYMENT_METHODS)
+    }
+
+    fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
+        None
+    }
+}
diff --git a/crates/hyperswitch_connectors/src/connectors/celero/transformers.rs b/crates/hyperswitch_connectors/src/connectors/celero/transformers.rs
index 2579c81ae6b..76990260923 100644
--- a/crates/hyperswitch_connectors/src/connectors/celero/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/celero/transformers.rs
@@ -1,80 +1,260 @@
-use common_enums::enums;
-use common_utils::types::StringMinorUnit;
+use common_enums::{enums, Currency};
+use common_utils::{pii::Email, types::MinorUnit};
 use hyperswitch_domain_models::{
+    address::Address as DomainAddress,
     payment_method_data::PaymentMethodData,
-    router_data::{ConnectorAuthType, RouterData},
-    router_flow_types::refunds::{Execute, RSync},
-    router_request_types::ResponseId,
+    router_data::{
+        AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
+        RouterData,
+    },
+    router_flow_types::{
+        payments::Capture,
+        refunds::{Execute, RSync},
+    },
+    router_request_types::{PaymentsCaptureData, ResponseId},
     router_response_types::{PaymentsResponseData, RefundsResponseData},
-    types::{PaymentsAuthorizeRouterData, RefundsRouterData},
+    types::{
+        PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
+        RefundSyncRouterData, RefundsRouterData,
+    },
 };
-use hyperswitch_interfaces::errors;
-use masking::Secret;
+use hyperswitch_interfaces::{consts, errors};
+use masking::{PeekInterface, Secret};
 use serde::{Deserialize, Serialize};
 
 use crate::{
     types::{RefundsResponseRouterData, ResponseRouterData},
-    utils::PaymentsAuthorizeRequestData,
+    utils::{
+        AddressDetailsData, PaymentsAuthorizeRequestData, RefundsRequestData, RouterData as _,
+    },
 };
 
 //TODO: Fill the struct with respective fields
 pub struct CeleroRouterData<T> {
-    pub amount: StringMinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
+    pub amount: MinorUnit, // CeleroCommerce expects integer cents
     pub router_data: T,
 }
 
-impl<T> From<(StringMinorUnit, T)> for CeleroRouterData<T> {
-    fn from((amount, item): (StringMinorUnit, T)) -> Self {
-        //Todo :  use utils to convert the amount to the type of amount that a connector accepts
-        Self {
+impl<T> TryFrom<(MinorUnit, T)> for CeleroRouterData<T> {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
+        Ok(Self {
             amount,
             router_data: item,
-        }
+        })
     }
 }
+// CeleroCommerce Search Request for sync operations - POST /api/transaction/search
+#[derive(Debug, Serialize, PartialEq)]
+pub struct CeleroSearchRequest {
+    transaction_id: String,
+}
 
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Serialize, PartialEq)]
+impl TryFrom<&PaymentsSyncRouterData> for CeleroSearchRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
+        let transaction_id = match &item.request.connector_transaction_id {
+            ResponseId::ConnectorTransactionId(id) => id.clone(),
+            _ => {
+                return Err(errors::ConnectorError::MissingConnectorTransactionID.into());
+            }
+        };
+        Ok(Self { transaction_id })
+    }
+}
+
+impl TryFrom<&RefundSyncRouterData> for CeleroSearchRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
+        Ok(Self {
+            transaction_id: item.request.get_connector_refund_id()?,
+        })
+    }
+}
+
+// CeleroCommerce Payment Request according to API specs
+#[derive(Debug, Serialize, PartialEq)]
 pub struct CeleroPaymentsRequest {
-    amount: StringMinorUnit,
-    card: CeleroCard,
+    idempotency_key: String,
+    #[serde(rename = "type")]
+    transaction_type: TransactionType,
+    amount: MinorUnit, // CeleroCommerce expects integer cents
+    currency: Currency,
+    payment_method: CeleroPaymentMethod,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    billing_address: Option<CeleroAddress>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    shipping_address: Option<CeleroAddress>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    create_vault_record: Option<bool>,
+}
+
+#[derive(Debug, Serialize, PartialEq)]
+pub struct CeleroAddress {
+    first_name: Option<Secret<String>>,
+    last_name: Option<Secret<String>>,
+    address_line_1: Option<Secret<String>>,
+    address_line_2: Option<Secret<String>>,
+    city: Option<String>,
+    state: Option<Secret<String>>,
+    postal_code: Option<Secret<String>>,
+    country: Option<common_enums::CountryAlpha2>,
+    phone: Option<Secret<String>>,
+    email: Option<Email>,
 }
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
+impl TryFrom<&DomainAddress> for CeleroAddress {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(address: &DomainAddress) -> Result<Self, Self::Error> {
+        let address_details = address.address.as_ref();
+        match address_details {
+            Some(address_details) => Ok(Self {
+                first_name: address_details.get_optional_first_name(),
+                last_name: address_details.get_optional_last_name(),
+                address_line_1: address_details.get_optional_line1(),
+                address_line_2: address_details.get_optional_line2(),
+                city: address_details.get_optional_city(),
+                state: address_details.get_optional_state(),
+                postal_code: address_details.get_optional_zip(),
+                country: address_details.get_optional_country(),
+                phone: address
+                    .phone
+                    .as_ref()
+                    .and_then(|phone| phone.number.clone()),
+                email: address.email.clone(),
+            }),
+            None => Err(errors::ConnectorError::MissingRequiredField {
+                field_name: "address_details",
+            }
+            .into()),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum CeleroPaymentMethod {
+    Card(CeleroCard),
+}
+
+#[derive(Debug, Serialize, PartialEq, Clone, Copy)]
+#[serde(rename_all = "lowercase")]
+pub enum CeleroEntryType {
+    Keyed,
+}
+
+#[derive(Debug, Serialize, PartialEq)]
 pub struct CeleroCard {
+    entry_type: CeleroEntryType,
     number: cards::CardNumber,
-    expiry_month: Secret<String>,
-    expiry_year: Secret<String>,
+    expiration_date: Secret<String>,
     cvc: Secret<String>,
-    complete: bool,
 }
 
-impl TryFrom<&CeleroRouterData<&PaymentsAuthorizeRouterData>> for CeleroPaymentsRequest {
+impl TryFrom<&PaymentMethodData> for CeleroPaymentMethod {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: &CeleroRouterData<&PaymentsAuthorizeRouterData>,
-    ) -> Result<Self, Self::Error> {
-        match item.router_data.request.payment_method_data.clone() {
+    fn try_from(item: &PaymentMethodData) -> Result<Self, Self::Error> {
+        match item {
             PaymentMethodData::Card(req_card) => {
                 let card = CeleroCard {
-                    number: req_card.card_number,
-                    expiry_month: req_card.card_exp_month,
-                    expiry_year: req_card.card_exp_year,
-                    cvc: req_card.card_cvc,
-                    complete: item.router_data.request.is_auto_capture()?,
+                    entry_type: CeleroEntryType::Keyed,
+                    number: req_card.card_number.clone(),
+                    expiration_date: Secret::new(format!(
+                        "{}/{}",
+                        req_card.card_exp_month.peek(),
+                        req_card.card_exp_year.peek()
+                    )),
+                    cvc: req_card.card_cvc.clone(),
                 };
-                Ok(Self {
-                    amount: item.amount.clone(),
-                    card,
-                })
+                Ok(Self::Card(card))
             }
-            _ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
+            PaymentMethodData::CardDetailsForNetworkTransactionId(_)
+            | PaymentMethodData::CardRedirect(_)
+            | PaymentMethodData::Wallet(_)
+            | PaymentMethodData::PayLater(_)
+            | PaymentMethodData::BankRedirect(_)
+            | PaymentMethodData::BankDebit(_)
+            | PaymentMethodData::BankTransfer(_)
+            | PaymentMethodData::Crypto(_)
+            | PaymentMethodData::MandatePayment
+            | PaymentMethodData::Reward
+            | PaymentMethodData::RealTimePayment(_)
+            | PaymentMethodData::Upi(_)
+            | PaymentMethodData::Voucher(_)
+            | PaymentMethodData::GiftCard(_)
+            | PaymentMethodData::CardToken(_)
+            | PaymentMethodData::OpenBanking(_)
+            | PaymentMethodData::NetworkToken(_)
+            | PaymentMethodData::MobilePayment(_) => Err(errors::ConnectorError::NotImplemented(
+                "Selected payment method through celero".to_string(),
+            )
+            .into()),
         }
     }
 }
 
-//TODO: Fill the struct with respective fields
-// Auth Struct
+// Implementation for handling 3DS specifically
+impl TryFrom<(&PaymentMethodData, bool)> for CeleroPaymentMethod {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from((item, is_three_ds): (&PaymentMethodData, bool)) -> Result<Self, Self::Error> {
+        // If 3DS is requested, return an error
+        if is_three_ds {
+            return Err(errors::ConnectorError::NotSupported {
+                message: "Cards 3DS".to_string(),
+                connector: "celero",
+            }
+            .into());
+        }
+
+        // Otherwise, delegate to the standard implementation
+        Self::try_from(item)
+    }
+}
+
+impl TryFrom<&CeleroRouterData<&PaymentsAuthorizeRouterData>> for CeleroPaymentsRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: &CeleroRouterData<&PaymentsAuthorizeRouterData>,
+    ) -> Result<Self, Self::Error> {
+        let is_auto_capture = item.router_data.request.is_auto_capture()?;
+        let transaction_type = if is_auto_capture {
+            TransactionType::Sale
+        } else {
+            TransactionType::Authorize
+        };
+
+        let billing_address: Option<CeleroAddress> = item
+            .router_data
+            .get_optional_billing()
+            .and_then(|address| address.try_into().ok());
+
+        let shipping_address: Option<CeleroAddress> = item
+            .router_data
+            .get_optional_shipping()
+            .and_then(|address| address.try_into().ok());
+
+        // Check if 3DS is requested
+        let is_three_ds = item.router_data.is_three_ds();
+
+        let request = Self {
+            idempotency_key: item.router_data.connector_request_reference_id.clone(),
+            transaction_type,
+            amount: item.amount,
+            currency: item.router_data.request.currency,
+            payment_method: CeleroPaymentMethod::try_from((
+                &item.router_data.request.payment_method_data,
+                is_three_ds,
+            ))?,
+            billing_address,
+            shipping_address,
+            create_vault_record: Some(false),
+        };
+
+        Ok(request)
+    }
+}
+
+// Auth Struct for CeleroCommerce API key authentication
 pub struct CeleroAuthType {
     pub(super) api_key: Secret<String>,
 }
@@ -84,38 +264,100 @@ impl TryFrom<&ConnectorAuthType> for CeleroAuthType {
     fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
         match auth_type {
             ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
-                api_key: api_key.to_owned(),
+                api_key: api_key.clone(),
             }),
             _ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
         }
     }
 }
-// PaymentsResponse
-//TODO: Append the remaining status flags
-#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "lowercase")]
-pub enum CeleroPaymentStatus {
-    Succeeded,
-    Failed,
-    #[default]
-    Processing,
+// CeleroCommerce API Response Structures
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum CeleroResponseStatus {
+    #[serde(alias = "success", alias = "Success", alias = "SUCCESS")]
+    Success,
+    #[serde(alias = "error", alias = "Error", alias = "ERROR")]
+    Error,
 }
 
-impl From<CeleroPaymentStatus> for common_enums::AttemptStatus {
-    fn from(item: CeleroPaymentStatus) -> Self {
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum CeleroTransactionStatus {
+    Approved,
+    Declined,
+    Error,
+    Pending,
+    PendingSettlement,
+    Settled,
+    Voided,
+    Reversed,
+}
+
+impl From<CeleroTransactionStatus> for common_enums::AttemptStatus {
+    fn from(item: CeleroTransactionStatus) -> Self {
         match item {
-            CeleroPaymentStatus::Succeeded => Self::Charged,
-            CeleroPaymentStatus::Failed => Self::Failure,
-            CeleroPaymentStatus::Processing => Self::Authorizing,
+            CeleroTransactionStatus::Approved => Self::Authorized,
+            CeleroTransactionStatus::Settled => Self::Charged,
+            CeleroTransactionStatus::Declined | CeleroTransactionStatus::Error => Self::Failure,
+            CeleroTransactionStatus::Pending | CeleroTransactionStatus::PendingSettlement => {
+                Self::Pending
+            }
+            CeleroTransactionStatus::Voided | CeleroTransactionStatus::Reversed => Self::Voided,
         }
     }
 }
+#[serde_with::skip_serializing_none]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct CeleroCardResponse {
+    pub status: CeleroTransactionStatus,
+    pub auth_code: Option<String>,
+    pub processor_response_code: Option<String>,
+    pub avs_response_code: Option<String>,
+}
 
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum CeleroPaymentMethodResponse {
+    Card(CeleroCardResponse),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum TransactionType {
+    Sale,
+    Authorize,
+}
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+#[serde_with::skip_serializing_none]
+pub struct CeleroTransactionResponseData {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub transaction_type: TransactionType,
+    pub amount: i64,
+    pub currency: String,
+    pub response: CeleroPaymentMethodResponse,
+    pub billing_address: Option<CeleroAddressResponse>,
+    pub shipping_address: Option<CeleroAddressResponse>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+pub struct CeleroAddressResponse {
+    first_name: Option<Secret<String>>,
+    last_name: Option<Secret<String>>,
+    address_line_1: Option<Secret<String>>,
+    address_line_2: Option<Secret<String>>,
+    city: Option<String>,
+    state: Option<Secret<String>>,
+    postal_code: Option<Secret<String>>,
+    country: Option<common_enums::CountryAlpha2>,
+    phone: Option<Secret<String>>,
+    email: Option<Secret<String>>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
 pub struct CeleroPaymentsResponse {
-    status: CeleroPaymentStatus,
-    id: String,
+    pub status: CeleroResponseStatus,
+    pub msg: String,
+    pub data: Option<CeleroTransactionResponseData>,
 }
 
 impl<F, T> TryFrom<ResponseRouterData<F, CeleroPaymentsResponse, T, PaymentsResponseData>>
@@ -125,104 +367,508 @@ impl<F, T> TryFrom<ResponseRouterData<F, CeleroPaymentsResponse, T, PaymentsResp
     fn try_from(
         item: ResponseRouterData<F, CeleroPaymentsResponse, T, PaymentsResponseData>,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            status: common_enums::AttemptStatus::from(item.response.status),
-            response: Ok(PaymentsResponseData::TransactionResponse {
-                resource_id: ResponseId::ConnectorTransactionId(item.response.id),
-                redirection_data: Box::new(None),
-                mandate_reference: Box::new(None),
-                connector_metadata: None,
-                network_txn_id: None,
-                connector_response_reference_id: None,
-                incremental_authorization_allowed: None,
-                charges: None,
-            }),
-            ..item.data
-        })
+        match item.response.status {
+            CeleroResponseStatus::Success => {
+                if let Some(data) = item.response.data {
+                    let CeleroPaymentMethodResponse::Card(response) = &data.response;
+                    // Check if transaction itself failed despite successful API call
+                    match response.status {
+                        CeleroTransactionStatus::Declined | CeleroTransactionStatus::Error => {
+                            // Transaction failed - create error response with transaction details
+                            let error_details = CeleroErrorDetails::from_transaction_response(
+                                response,
+                                item.response.msg,
+                            );
+
+                            Ok(Self {
+                                status: common_enums::AttemptStatus::Failure,
+                                response: Err(
+                                    hyperswitch_domain_models::router_data::ErrorResponse {
+                                        code: error_details
+                                            .error_code
+                                            .unwrap_or_else(|| "TRANSACTION_FAILED".to_string()),
+                                        message: error_details.error_message,
+                                        reason: error_details.decline_reason,
+                                        status_code: item.http_code,
+                                        attempt_status: None,
+                                        connector_transaction_id: Some(data.id),
+                                        network_decline_code: None,
+                                        network_advice_code: None,
+                                        network_error_message: None,
+                                        connector_metadata: None,
+                                    },
+                                ),
+                                ..item.data
+                            })
+                        }
+                        _ => {
+                            let connector_response_data =
+                                convert_to_additional_payment_method_connector_response(
+                                    response.avs_response_code.clone(),
+                                )
+                                .map(ConnectorResponseData::with_additional_payment_method_data);
+                            let final_status: enums::AttemptStatus = response.status.into();
+                            Ok(Self {
+                                status: final_status,
+                                response: Ok(PaymentsResponseData::TransactionResponse {
+                                    resource_id: ResponseId::ConnectorTransactionId(data.id),
+                                    redirection_data: Box::new(None),
+                                    mandate_reference: Box::new(None),
+                                    connector_metadata: None,
+                                    network_txn_id: None,
+                                    connector_response_reference_id: response.auth_code.clone(),
+                                    incremental_authorization_allowed: None,
+                                    charges: None,
+                                }),
+                                connector_response: connector_response_data,
+                                ..item.data
+                            })
+                        }
+                    }
+                } else {
+                    // No transaction data in successful response
+                    Ok(Self {
+                        status: common_enums::AttemptStatus::Failure,
+                        response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
+                            code: "MISSING_DATA".to_string(),
+                            message: "No transaction data in response".to_string(),
+                            reason: Some(item.response.msg),
+                            status_code: item.http_code,
+                            attempt_status: None,
+                            connector_transaction_id: None,
+                            network_decline_code: None,
+                            network_advice_code: None,
+                            network_error_message: None,
+                            connector_metadata: None,
+                        }),
+                        ..item.data
+                    })
+                }
+            }
+            CeleroResponseStatus::Error => {
+                // Top-level API error
+                let error_details =
+                    CeleroErrorDetails::from_top_level_error(item.response.msg.clone());
+
+                Ok(Self {
+                    status: common_enums::AttemptStatus::Failure,
+                    response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
+                        code: error_details
+                            .error_code
+                            .unwrap_or_else(|| "API_ERROR".to_string()),
+                        message: error_details.error_message,
+                        reason: error_details.decline_reason,
+                        status_code: item.http_code,
+                        attempt_status: None,
+                        connector_transaction_id: None,
+                        network_decline_code: None,
+                        network_advice_code: None,
+                        network_error_message: None,
+                        connector_metadata: None,
+                    }),
+                    ..item.data
+                })
+            }
+        }
     }
 }
 
-//TODO: Fill the struct with respective fields
-// REFUND :
-// Type definition for RefundRequest
+// CAPTURE:
+// Type definition for CaptureRequest
 #[derive(Default, Debug, Serialize)]
-pub struct CeleroRefundRequest {
-    pub amount: StringMinorUnit,
+pub struct CeleroCaptureRequest {
+    pub amount: MinorUnit,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub order_id: Option<String>,
 }
 
-impl<F> TryFrom<&CeleroRouterData<&RefundsRouterData<F>>> for CeleroRefundRequest {
+impl TryFrom<&CeleroRouterData<&PaymentsCaptureRouterData>> for CeleroCaptureRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &CeleroRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
+    fn try_from(item: &CeleroRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
         Ok(Self {
-            amount: item.amount.to_owned(),
+            amount: item.amount,
+            order_id: Some(item.router_data.payment_id.clone()),
         })
     }
 }
 
-// Type definition for Refund Response
-
-#[allow(dead_code)]
-#[derive(Debug, Serialize, Default, Deserialize, Clone)]
-pub enum RefundStatus {
-    Succeeded,
-    Failed,
-    #[default]
-    Processing,
+// CeleroCommerce Capture Response
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct CeleroCaptureResponse {
+    pub status: CeleroResponseStatus,
+    pub msg: Option<String>,
+    pub data: Option<serde_json::Value>, // Usually null for capture responses
 }
 
-impl From<RefundStatus> for enums::RefundStatus {
-    fn from(item: RefundStatus) -> Self {
-        match item {
-            RefundStatus::Succeeded => Self::Success,
-            RefundStatus::Failed => Self::Failure,
-            RefundStatus::Processing => Self::Pending,
-            //TODO: Review mapping
+impl
+    TryFrom<
+        ResponseRouterData<
+            Capture,
+            CeleroCaptureResponse,
+            PaymentsCaptureData,
+            PaymentsResponseData,
+        >,
+    > for RouterData<Capture, PaymentsCaptureData, PaymentsResponseData>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: ResponseRouterData<
+            Capture,
+            CeleroCaptureResponse,
+            PaymentsCaptureData,
+            PaymentsResponseData,
+        >,
+    ) -> Result<Self, Self::Error> {
+        match item.response.status {
+            CeleroResponseStatus::Success => Ok(Self {
+                status: common_enums::AttemptStatus::Charged,
+                response: Ok(PaymentsResponseData::TransactionResponse {
+                    resource_id: ResponseId::ConnectorTransactionId(
+                        item.data.request.connector_transaction_id.clone(),
+                    ),
+                    redirection_data: Box::new(None),
+                    mandate_reference: Box::new(None),
+                    connector_metadata: None,
+                    network_txn_id: None,
+                    connector_response_reference_id: None,
+                    incremental_authorization_allowed: None,
+                    charges: None,
+                }),
+                ..item.data
+            }),
+            CeleroResponseStatus::Error => Ok(Self {
+                status: common_enums::AttemptStatus::Failure,
+                response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
+                    code: "CAPTURE_FAILED".to_string(),
+                    message: item
+                        .response
+                        .msg
+                        .clone()
+                        .unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
+                    reason: None,
+                    status_code: item.http_code,
+                    attempt_status: None,
+                    connector_transaction_id: Some(
+                        item.data.request.connector_transaction_id.clone(),
+                    ),
+                    network_decline_code: None,
+                    network_advice_code: None,
+                    network_error_message: None,
+                    connector_metadata: None,
+                }),
+                ..item.data
+            }),
         }
     }
 }
 
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
-pub struct RefundResponse {
-    id: String,
-    status: RefundStatus,
+// CeleroCommerce Void Response - matches API spec format
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct CeleroVoidResponse {
+    pub status: CeleroResponseStatus,
+    pub msg: String,
+    pub data: Option<serde_json::Value>, // Usually null for void responses
 }
 
-impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
+impl
+    TryFrom<
+        ResponseRouterData<
+            hyperswitch_domain_models::router_flow_types::payments::Void,
+            CeleroVoidResponse,
+            hyperswitch_domain_models::router_request_types::PaymentsCancelData,
+            PaymentsResponseData,
+        >,
+    >
+    for RouterData<
+        hyperswitch_domain_models::router_flow_types::payments::Void,
+        hyperswitch_domain_models::router_request_types::PaymentsCancelData,
+        PaymentsResponseData,
+    >
+{
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: RefundsResponseRouterData<Execute, RefundResponse>,
+        item: ResponseRouterData<
+            hyperswitch_domain_models::router_flow_types::payments::Void,
+            CeleroVoidResponse,
+            hyperswitch_domain_models::router_request_types::PaymentsCancelData,
+            PaymentsResponseData,
+        >,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            response: Ok(RefundsResponseData {
-                connector_refund_id: item.response.id.to_string(),
-                refund_status: enums::RefundStatus::from(item.response.status),
+        match item.response.status {
+            CeleroResponseStatus::Success => Ok(Self {
+                status: common_enums::AttemptStatus::Voided,
+                response: Ok(PaymentsResponseData::TransactionResponse {
+                    resource_id: ResponseId::ConnectorTransactionId(
+                        item.data.request.connector_transaction_id.clone(),
+                    ),
+                    redirection_data: Box::new(None),
+                    mandate_reference: Box::new(None),
+                    connector_metadata: None,
+                    network_txn_id: None,
+                    connector_response_reference_id: None,
+                    incremental_authorization_allowed: None,
+                    charges: None,
+                }),
+                ..item.data
+            }),
+            CeleroResponseStatus::Error => Ok(Self {
+                status: common_enums::AttemptStatus::Failure,
+                response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
+                    code: "VOID_FAILED".to_string(),
+                    message: item.response.msg.clone(),
+                    reason: Some(item.response.msg),
+                    status_code: item.http_code,
+                    attempt_status: None,
+                    connector_transaction_id: Some(
+                        item.data.request.connector_transaction_id.clone(),
+                    ),
+                    network_decline_code: None,
+                    network_advice_code: None,
+                    network_error_message: None,
+                    connector_metadata: None,
+                }),
+                ..item.data
             }),
-            ..item.data
+        }
+    }
+}
+#[derive(Default, Debug, Serialize)]
+pub struct CeleroRefundRequest {
+    pub amount: MinorUnit,
+    pub surcharge: MinorUnit, // Required field as per API specification
+}
+
+impl<F> TryFrom<&CeleroRouterData<&RefundsRouterData<F>>> for CeleroRefundRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(item: &CeleroRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
+        Ok(Self {
+            amount: item.amount,
+            surcharge: MinorUnit::zero(), // Default to 0 as per API specification
         })
     }
 }
 
-impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
+// CeleroCommerce Refund Response - matches API spec format
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct CeleroRefundResponse {
+    pub status: CeleroResponseStatus,
+    pub msg: String,
+    pub data: Option<serde_json::Value>, // Usually null for refund responses
+}
+
+impl TryFrom<RefundsResponseRouterData<Execute, CeleroRefundResponse>>
+    for RefundsRouterData<Execute>
+{
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: RefundsResponseRouterData<RSync, RefundResponse>,
+        item: RefundsResponseRouterData<Execute, CeleroRefundResponse>,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            response: Ok(RefundsResponseData {
-                connector_refund_id: item.response.id.to_string(),
-                refund_status: enums::RefundStatus::from(item.response.status),
+        match item.response.status {
+            CeleroResponseStatus::Success => Ok(Self {
+                response: Ok(RefundsResponseData {
+                    connector_refund_id: item.data.request.refund_id.clone(),
+                    refund_status: enums::RefundStatus::Success,
+                }),
+                ..item.data
             }),
-            ..item.data
-        })
+            CeleroResponseStatus::Error => Ok(Self {
+                response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
+                    code: "REFUND_FAILED".to_string(),
+                    message: item.response.msg.clone(),
+                    reason: Some(item.response.msg),
+                    status_code: item.http_code,
+                    attempt_status: None,
+                    connector_transaction_id: Some(
+                        item.data.request.connector_transaction_id.clone(),
+                    ),
+                    network_decline_code: None,
+                    network_advice_code: None,
+                    network_error_message: None,
+                    connector_metadata: None,
+                }),
+                ..item.data
+            }),
+        }
     }
 }
 
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
+impl TryFrom<RefundsResponseRouterData<RSync, CeleroRefundResponse>> for RefundsRouterData<RSync> {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: RefundsResponseRouterData<RSync, CeleroRefundResponse>,
+    ) -> Result<Self, Self::Error> {
+        match item.response.status {
+            CeleroResponseStatus::Success => Ok(Self {
+                response: Ok(RefundsResponseData {
+                    connector_refund_id: item.data.request.refund_id.clone(),
+                    refund_status: enums::RefundStatus::Success,
+                }),
+                ..item.data
+            }),
+            CeleroResponseStatus::Error => Ok(Self {
+                response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
+                    code: "REFUND_SYNC_FAILED".to_string(),
+                    message: item.response.msg.clone(),
+                    reason: Some(item.response.msg),
+                    status_code: item.http_code,
+                    attempt_status: None,
+                    connector_transaction_id: Some(
+                        item.data.request.connector_transaction_id.clone(),
+                    ),
+                    network_decline_code: None,
+                    network_advice_code: None,
+                    network_error_message: None,
+                    connector_metadata: None,
+                }),
+                ..item.data
+            }),
+        }
+    }
+}
+
+// CeleroCommerce Error Response Structures
+
+// Main error response structure - matches API spec format
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct CeleroErrorResponse {
-    pub status_code: u16,
-    pub code: String,
-    pub message: String,
-    pub reason: Option<String>,
+    pub status: CeleroResponseStatus,
+    pub msg: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<serde_json::Value>,
+}
+
+// Error details that can be extracted from various response fields
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct CeleroErrorDetails {
+    pub error_code: Option<String>,
+    pub error_message: String,
+    pub processor_response_code: Option<String>,
+    pub decline_reason: Option<String>,
+}
+
+impl From<CeleroErrorResponse> for CeleroErrorDetails {
+    fn from(error_response: CeleroErrorResponse) -> Self {
+        Self {
+            error_code: Some("API_ERROR".to_string()),
+            error_message: error_response.msg,
+            processor_response_code: None,
+            decline_reason: None,
+        }
+    }
+}
+
+// Function to extract error details from transaction response data
+impl CeleroErrorDetails {
+    pub fn from_transaction_response(response: &CeleroCardResponse, msg: String) -> Self {
+        // Map specific error codes based on common response patterns
+        let decline_reason = Self::map_processor_error(&response.processor_response_code, &msg);
+
+        Self {
+            error_code: None,
+            error_message: msg,
+            processor_response_code: response.processor_response_code.clone(),
+            decline_reason,
+        }
+    }
+
+    pub fn from_top_level_error(msg: String) -> Self {
+        // Map specific error codes from top-level API errors
+
+        Self {
+            error_code: None,
+            error_message: msg,
+            processor_response_code: None,
+            decline_reason: None,
+        }
+    }
+
+    /// Map processor response codes and messages to specific Hyperswitch error codes
+    fn map_processor_error(processor_code: &Option<String>, message: &str) -> Option<String> {
+        let message_lower = message.to_lowercase();
+        // Check processor response codes if available
+        if let Some(code) = processor_code {
+            match code.as_str() {
+                "05" => Some("TRANSACTION_DECLINED".to_string()),
+                "14" => Some("INVALID_CARD_DATA".to_string()),
+                "51" => Some("INSUFFICIENT_FUNDS".to_string()),
+                "54" => Some("EXPIRED_CARD".to_string()),
+                "55" => Some("INCORRECT_CVC".to_string()),
+                "61" => Some("Exceeds withdrawal amount limit".to_string()),
+                "62" => Some("TRANSACTION_DECLINED".to_string()),
+                "65" => Some("Exceeds withdrawal frequency limit".to_string()),
+                "78" => Some("INVALID_CARD_DATA".to_string()),
+                "91" => Some("PROCESSING_ERROR".to_string()),
+                "96" => Some("PROCESSING_ERROR".to_string()),
+                _ => {
+                    router_env::logger::info!(
+                        "Celero response error code ({:?}) is not mapped to any error state ",
+                        code
+                    );
+                    Some("Transaction failed".to_string())
+                }
+            }
+        } else {
+            Some(message_lower)
+        }
+    }
+}
+
+pub fn get_avs_definition(code: &str) -> Option<&'static str> {
+    match code {
+        "0" => Some("AVS Not Available"),
+        "A" => Some("Address match only"),
+        "B" => Some("Address matches, ZIP not verified"),
+        "C" => Some("Incompatible format"),
+        "D" => Some("Exact match"),
+        "F" => Some("Exact match, UK-issued cards"),
+        "G" => Some("Non-U.S. Issuer does not participate"),
+        "I" => Some("Not verified"),
+        "M" => Some("Exact match"),
+        "N" => Some("No address or ZIP match"),
+        "P" => Some("Postal Code match"),
+        "R" => Some("Issuer system unavailable"),
+        "S" => Some("Service not supported"),
+        "U" => Some("Address unavailable"),
+        "W" => Some("9-character numeric ZIP match only"),
+        "X" => Some("Exact match, 9-character numeric ZIP"),
+        "Y" => Some("Exact match, 5-character numeric ZIP"),
+        "Z" => Some("5-character ZIP match only"),
+        "L" => Some("Partial match, Name and billing postal code match"),
+        "1" => Some("Cardholder name and ZIP match"),
+        "2" => Some("Cardholder name, address and ZIP match"),
+        "3" => Some("Cardholder name and address match"),
+        "4" => Some("Cardholder name matches"),
+        "5" => Some("Cardholder name incorrect, ZIP matches"),
+        "6" => Some("Cardholder name incorrect, address and zip match"),
+        "7" => Some("Cardholder name incorrect, address matches"),
+        "8" => Some("Cardholder name, address, and ZIP do not match"),
+        _ => {
+            router_env::logger::info!(
+                "Celero avs response code ({:?}) is not mapped to any defination.",
+                code
+            );
+
+            None
+        } // No definition found for the given code
+    }
+}
+fn convert_to_additional_payment_method_connector_response(
+    response_code: Option<String>,
+) -> Option<AdditionalPaymentMethodConnectorResponse> {
+    match response_code {
+        None => None,
+        Some(code) => {
+            let description = get_avs_definition(&code);
+            let payment_checks = serde_json::json!({
+                "avs_result_code": code,
+                "description": description
+            });
+            Some(AdditionalPaymentMethodConnectorResponse::Card {
+                authentication_data: None,
+                payment_checks: Some(payment_checks),
+                card_network: None,
+                domestic_network: None,
+            })
+        }
+    }
 }
diff --git a/crates/payment_methods/src/configs/payment_connector_required_fields.rs b/crates/payment_methods/src/configs/payment_connector_required_fields.rs
index 5ce306c5976..15a4ef90a95 100644
--- a/crates/payment_methods/src/configs/payment_connector_required_fields.rs
+++ b/crates/payment_methods/src/configs/payment_connector_required_fields.rs
@@ -1305,6 +1305,7 @@ fn get_cards_required_fields() -> HashMap<Connector, RequiredFieldFinal> {
         ),
         (Connector::Boku, fields(vec![], vec![], card_basic())),
         (Connector::Braintree, fields(vec![], vec![], card_basic())),
+        (Connector::Celero, fields(vec![], vec![], card_basic())),
         (Connector::Checkout, fields(vec![], card_basic(), vec![])),
         (
             Connector::Coinbase,