// AUTO-GENERATED — do not edit by hand.
// Source: services.proto ∩ bindings/uniffi.rs  |  Regenerate: make generate

import { ConnectorClient as _ConnectorClientBase } from "./connector_client";
// @ts-ignore - protobuf generated files might not have types yet
import { types } from "./generated/proto";

export class CustomerClient extends _ConnectorClientBase {
  /** CustomerService.Create — Create customer record in the payment processor system. Stores customer details for future payment operations without re-sending personal information. */
  async customerCreate(
    requestMsg: types.ICustomerServiceCreateRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.CustomerServiceCreateResponse> {
    return this._executeFlow('customer_create', requestMsg, options, 'CustomerServiceCreateRequest', 'CustomerServiceCreateResponse') as Promise<types.CustomerServiceCreateResponse>;
  }

  /** CustomerService.Get — Retrieves customer details from the payment processor. Callers typically use this before Create to implement get-or-create semantics for connectors that reject duplicates (e.g. Glomopay). */
  async customerGet(
    requestMsg: types.ICustomerServiceGetRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.CustomerServiceGetResponse> {
    return this._executeFlow('customer_get', requestMsg, options, 'CustomerServiceGetRequest', 'CustomerServiceGetResponse') as Promise<types.CustomerServiceGetResponse>;
  }

}

export class DisputeClient extends _ConnectorClientBase {
  /** DisputeService.Accept — Concede dispute and accepts chargeback loss. Acknowledges liability and stops dispute defense process when evidence is insufficient. */
  async accept(
    requestMsg: types.IDisputeServiceAcceptRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.DisputeServiceAcceptResponse> {
    return this._executeFlow('accept', requestMsg, options, 'DisputeServiceAcceptRequest', 'DisputeServiceAcceptResponse') as Promise<types.DisputeServiceAcceptResponse>;
  }

  /** DisputeService.Defend — Submit defense with reason code for dispute. Presents formal argument against customer's chargeback claim with supporting documentation. */
  async defend(
    requestMsg: types.IDisputeServiceDefendRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.DisputeServiceDefendResponse> {
    return this._executeFlow('defend', requestMsg, options, 'DisputeServiceDefendRequest', 'DisputeServiceDefendResponse') as Promise<types.DisputeServiceDefendResponse>;
  }

  /** DisputeService.SubmitEvidence — Upload evidence to dispute customer chargeback. Provides documentation like receipts and delivery proof to contest fraudulent transaction claims. */
  async submitEvidence(
    requestMsg: types.IDisputeServiceSubmitEvidenceRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.DisputeServiceSubmitEvidenceResponse> {
    return this._executeFlow('submit_evidence', requestMsg, options, 'DisputeServiceSubmitEvidenceRequest', 'DisputeServiceSubmitEvidenceResponse') as Promise<types.DisputeServiceSubmitEvidenceResponse>;
  }

}

export class EventClient extends _ConnectorClientBase {
  /** EventService.HandleEvent — Verify webhook source and return a unified typed response. Response mirrors PaymentService.Get / RefundService.Get / DisputeService.Get. */
  async handleEvent(
    requestMsg: types.IEventServiceHandleRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.EventServiceHandleResponse> {
    return this._executeDirect('handle_event', requestMsg, options, 'EventServiceHandleRequest', 'EventServiceHandleResponse') as Promise<types.EventServiceHandleResponse>;
  }

  /** EventService.ParseEvent — Parse a raw webhook payload without credentials. Returns resource reference and event type — sufficient to resolve secrets or early-exit. */
  async parseEvent(
    requestMsg: types.IEventServiceParseRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.EventServiceParseResponse> {
    return this._executeDirect('parse_event', requestMsg, options, 'EventServiceParseRequest', 'EventServiceParseResponse') as Promise<types.EventServiceParseResponse>;
  }

}

export class FraudAndRiskManagementClient extends _ConnectorClientBase {
  /** FraudAndRiskManagementService.PostRiskCheck — Evaluate fraud risk after payment processing. Analyzes payment outcomes and post-transaction signals to refine risk models and detect chargeback fraud. */
  async postRiskCheck(
    requestMsg: types.IFrmServicePostRiskCheckRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.FrmServicePostRiskCheckResponse> {
    return this._executeFlow('post_risk_check', requestMsg, options, 'FrmServicePostRiskCheckRequest', 'FrmServicePostRiskCheckResponse') as Promise<types.FrmServicePostRiskCheckResponse>;
  }

  /** FraudAndRiskManagementService.PreRiskCheck — Evaluate fraud risk before payment processing. Analyzes transaction details, customer behavior, and device fingerprints to determine if the payment should proceed, be rejected, or flagged for manual review. */
  async preRiskCheck(
    requestMsg: types.IFrmServicePreRiskCheckRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.FrmServicePreRiskCheckResponse> {
    return this._executeFlow('pre_risk_check', requestMsg, options, 'FrmServicePreRiskCheckRequest', 'FrmServicePreRiskCheckResponse') as Promise<types.FrmServicePreRiskCheckResponse>;
  }

}

export class MerchantAuthenticationClient extends _ConnectorClientBase {
  /** MerchantAuthenticationService.CreateClientAuthenticationToken — Initialize client-facing SDK sessions for wallets, device fingerprinting, etc. Returns structured data the client SDK needs to render payment/verification UI. */
  async createClientAuthenticationToken(
    requestMsg: types.IMerchantAuthenticationServiceCreateClientAuthenticationTokenRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.MerchantAuthenticationServiceCreateClientAuthenticationTokenResponse> {
    return this._executeFlow('create_client_authentication_token', requestMsg, options, 'MerchantAuthenticationServiceCreateClientAuthenticationTokenRequest', 'MerchantAuthenticationServiceCreateClientAuthenticationTokenResponse') as Promise<types.MerchantAuthenticationServiceCreateClientAuthenticationTokenResponse>;
  }

  /** MerchantAuthenticationService.CreateServerAuthenticationToken — Generate short-lived connector authentication token. Provides secure credentials for connector API access without storing secrets client-side. */
  async createServerAuthenticationToken(
    requestMsg: types.IMerchantAuthenticationServiceCreateServerAuthenticationTokenRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.MerchantAuthenticationServiceCreateServerAuthenticationTokenResponse> {
    return this._executeFlow('create_server_authentication_token', requestMsg, options, 'MerchantAuthenticationServiceCreateServerAuthenticationTokenRequest', 'MerchantAuthenticationServiceCreateServerAuthenticationTokenResponse') as Promise<types.MerchantAuthenticationServiceCreateServerAuthenticationTokenResponse>;
  }

  /** MerchantAuthenticationService.CreateServerSessionAuthenticationToken — Create a server-side session with the connector. Establishes session state for multi-step operations like 3DS verification or wallet authorization. */
  async createServerSessionAuthenticationToken(
    requestMsg: types.IMerchantAuthenticationServiceCreateServerSessionAuthenticationTokenRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.MerchantAuthenticationServiceCreateServerSessionAuthenticationTokenResponse> {
    return this._executeFlow('create_server_session_authentication_token', requestMsg, options, 'MerchantAuthenticationServiceCreateServerSessionAuthenticationTokenRequest', 'MerchantAuthenticationServiceCreateServerSessionAuthenticationTokenResponse') as Promise<types.MerchantAuthenticationServiceCreateServerSessionAuthenticationTokenResponse>;
  }

}

export class PaymentMethodAuthenticationClient extends _ConnectorClientBase {
  /** PaymentMethodAuthenticationService.Authenticate — Execute 3DS challenge or frictionless verification. Authenticates customer via bank challenge or behind-the-scenes verification for fraud prevention. */
  async authenticate(
    requestMsg: types.IPaymentMethodAuthenticationServiceAuthenticateRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentMethodAuthenticationServiceAuthenticateResponse> {
    return this._executeFlow('authenticate', requestMsg, options, 'PaymentMethodAuthenticationServiceAuthenticateRequest', 'PaymentMethodAuthenticationServiceAuthenticateResponse') as Promise<types.PaymentMethodAuthenticationServiceAuthenticateResponse>;
  }

  /** PaymentMethodAuthenticationService.PostAuthenticate — Validate authentication results with the issuing bank. Processes bank's authentication decision to determine if payment can proceed. */
  async postAuthenticate(
    requestMsg: types.IPaymentMethodAuthenticationServicePostAuthenticateRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentMethodAuthenticationServicePostAuthenticateResponse> {
    return this._executeFlow('post_authenticate', requestMsg, options, 'PaymentMethodAuthenticationServicePostAuthenticateRequest', 'PaymentMethodAuthenticationServicePostAuthenticateResponse') as Promise<types.PaymentMethodAuthenticationServicePostAuthenticateResponse>;
  }

  /** PaymentMethodAuthenticationService.PreAuthenticate — Initiate 3DS flow before payment authorization. Collects device data and prepares authentication context for frictionless or challenge-based verification. */
  async preAuthenticate(
    requestMsg: types.IPaymentMethodAuthenticationServicePreAuthenticateRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentMethodAuthenticationServicePreAuthenticateResponse> {
    return this._executeFlow('pre_authenticate', requestMsg, options, 'PaymentMethodAuthenticationServicePreAuthenticateRequest', 'PaymentMethodAuthenticationServicePreAuthenticateResponse') as Promise<types.PaymentMethodAuthenticationServicePreAuthenticateResponse>;
  }

}

export class PaymentMethodClient extends _ConnectorClientBase {
  /** PaymentMethodService.Eligibility — Check if the payment method is eligible for the transaction (e.g. BNPL pre-checkout check) */
  async eligibility(
    requestMsg: types.IPaymentMethodServiceEligibilityRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentMethodServiceEligibilityResponse> {
    return this._executeFlow('eligibility', requestMsg, options, 'PaymentMethodServiceEligibilityRequest', 'PaymentMethodServiceEligibilityResponse') as Promise<types.PaymentMethodServiceEligibilityResponse>;
  }

  /** PaymentMethodService.Refresh — Refresh a payment method the caller already holds in full. The request carries the instrument itself, not a reference to it: use Refresh when you own the complete payment method details and the provider exposes an endpoint that evaluates them. */
  async refresh(
    requestMsg: types.IPaymentMethodServiceRefreshRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentMethodServiceRefreshResponse> {
    return this._executeFlow('refresh', requestMsg, options, 'PaymentMethodServiceRefreshRequest', 'PaymentMethodServiceRefreshResponse') as Promise<types.PaymentMethodServiceRefreshResponse>;
  }

  /** PaymentMethodService.Tokenize — Tokenize payment method for secure storage. Replaces raw card details with secure token for one-click payments and recurring billing. */
  async tokenize(
    requestMsg: types.IPaymentMethodServiceTokenizeRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentMethodServiceTokenizeResponse> {
    return this._executeFlow('tokenize', requestMsg, options, 'PaymentMethodServiceTokenizeRequest', 'PaymentMethodServiceTokenizeResponse') as Promise<types.PaymentMethodServiceTokenizeResponse>;
  }

}

export class PaymentClient extends _ConnectorClientBase {
  /** PaymentService.Authorize — Authorize a payment amount on a payment method. This reserves funds without capturing them, essential for verifying availability before finalizing. */
  async authorize(
    requestMsg: types.IPaymentServiceAuthorizeRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceAuthorizeResponse> {
    return this._executeFlow('authorize', requestMsg, options, 'PaymentServiceAuthorizeRequest', 'PaymentServiceAuthorizeResponse') as Promise<types.PaymentServiceAuthorizeResponse>;
  }

  /** PaymentService.Capture — Finalize an authorized payment by transferring funds. Captures the authorized amount to complete the transaction and move funds to your merchant account. */
  async capture(
    requestMsg: types.IPaymentServiceCaptureRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceCaptureResponse> {
    return this._executeFlow('capture', requestMsg, options, 'PaymentServiceCaptureRequest', 'PaymentServiceCaptureResponse') as Promise<types.PaymentServiceCaptureResponse>;
  }

  /** PaymentService.CreateOrder — Create a payment order for later processing. Establishes a transaction context that can be authorized or captured in subsequent API calls. */
  async createOrder(
    requestMsg: types.IPaymentServiceCreateOrderRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceCreateOrderResponse> {
    return this._executeFlow('create_order', requestMsg, options, 'PaymentServiceCreateOrderRequest', 'PaymentServiceCreateOrderResponse') as Promise<types.PaymentServiceCreateOrderResponse>;
  }

  /** PaymentService.Get — Retrieve current payment status from the payment processor. Enables synchronization between your system and payment processors for accurate state tracking. */
  async get(
    requestMsg: types.IPaymentServiceGetRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceGetResponse> {
    return this._executeFlow('get', requestMsg, options, 'PaymentServiceGetRequest', 'PaymentServiceGetResponse') as Promise<types.PaymentServiceGetResponse>;
  }

  /** PaymentService.IncrementalAuthorization — Increase the authorized amount for an existing payment. Enables you to capture additional funds when the transaction amount changes after initial authorization. */
  async incrementalAuthorization(
    requestMsg: types.IPaymentServiceIncrementalAuthorizationRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceIncrementalAuthorizationResponse> {
    return this._executeFlow('incremental_authorization', requestMsg, options, 'PaymentServiceIncrementalAuthorizationRequest', 'PaymentServiceIncrementalAuthorizationResponse') as Promise<types.PaymentServiceIncrementalAuthorizationResponse>;
  }

  /** PaymentService.ProxyAuthorize — Authorize using vault-aliased card data. Proxy substitutes before connector. */
  async proxyAuthorize(
    requestMsg: types.IPaymentServiceProxyAuthorizeRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceAuthorizeResponse> {
    return this._executeFlow('proxy_authorize', requestMsg, options, 'PaymentServiceProxyAuthorizeRequest', 'PaymentServiceAuthorizeResponse') as Promise<types.PaymentServiceAuthorizeResponse>;
  }

  /** PaymentService.ProxySetupRecurring — Setup recurring mandate using vault-aliased card data. */
  async proxySetupRecurring(
    requestMsg: types.IPaymentServiceProxySetupRecurringRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceSetupRecurringResponse> {
    return this._executeFlow('proxy_setup_recurring', requestMsg, options, 'PaymentServiceProxySetupRecurringRequest', 'PaymentServiceSetupRecurringResponse') as Promise<types.PaymentServiceSetupRecurringResponse>;
  }

  /** PaymentService.Refund — Process a partial or full refund for a captured payment. Returns funds to the customer when goods are returned or services are cancelled. */
  async refund(
    requestMsg: types.IPaymentServiceRefundRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.RefundResponse> {
    return this._executeFlow('refund', requestMsg, options, 'PaymentServiceRefundRequest', 'RefundResponse') as Promise<types.RefundResponse>;
  }

  /** PaymentService.Reverse — Reverse a captured payment in full. Initiates a complete refund when you need to cancel a settled transaction rather than just an authorization. */
  async reverse(
    requestMsg: types.IPaymentServiceReverseRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceReverseResponse> {
    return this._executeFlow('reverse', requestMsg, options, 'PaymentServiceReverseRequest', 'PaymentServiceReverseResponse') as Promise<types.PaymentServiceReverseResponse>;
  }

  /** PaymentService.SetupRecurring — Configure a payment method for recurring billing. Sets up the mandate and payment details needed for future automated charges. */
  async setupRecurring(
    requestMsg: types.IPaymentServiceSetupRecurringRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceSetupRecurringResponse> {
    return this._executeFlow('setup_recurring', requestMsg, options, 'PaymentServiceSetupRecurringRequest', 'PaymentServiceSetupRecurringResponse') as Promise<types.PaymentServiceSetupRecurringResponse>;
  }

  /** PaymentService.TokenAuthorize — Authorize using a connector-issued payment method token. */
  async tokenAuthorize(
    requestMsg: types.IPaymentServiceTokenAuthorizeRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceAuthorizeResponse> {
    return this._executeFlow('token_authorize', requestMsg, options, 'PaymentServiceTokenAuthorizeRequest', 'PaymentServiceAuthorizeResponse') as Promise<types.PaymentServiceAuthorizeResponse>;
  }

  /** PaymentService.TokenSetupRecurring — Setup a recurring mandate using a connector token. */
  async tokenSetupRecurring(
    requestMsg: types.IPaymentServiceTokenSetupRecurringRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceSetupRecurringResponse> {
    return this._executeFlow('token_setup_recurring', requestMsg, options, 'PaymentServiceTokenSetupRecurringRequest', 'PaymentServiceSetupRecurringResponse') as Promise<types.PaymentServiceSetupRecurringResponse>;
  }

  /** PaymentService.Void — Cancel an authorized payment that has not been captured. Releases held funds back to the customer's payment method when a transaction cannot be completed. */
  async void(
    requestMsg: types.IPaymentServiceVoidRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceVoidResponse> {
    return this._executeFlow('void', requestMsg, options, 'PaymentServiceVoidRequest', 'PaymentServiceVoidResponse') as Promise<types.PaymentServiceVoidResponse>;
  }

  /** PaymentService.VerifyRedirectResponse — Verify and process redirect responses from 3D Secure or other external flows. Validates authentication results and updates payment state accordingly. */
  async verifyRedirectResponse(
    requestMsg: types.IPaymentServiceVerifyRedirectResponseRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PaymentServiceVerifyRedirectResponseResponse> {
    return this._executeDirect('verify_redirect_response', requestMsg, options, 'PaymentServiceVerifyRedirectResponseRequest', 'PaymentServiceVerifyRedirectResponseResponse') as Promise<types.PaymentServiceVerifyRedirectResponseResponse>;
  }

}

export class PayoutClient extends _ConnectorClientBase {
  /** PayoutService.Create — Creates a payout. */
  async payoutCreate(
    requestMsg: types.IPayoutServiceCreateRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PayoutServiceCreateResponse> {
    return this._executeFlow('payout_create', requestMsg, options, 'PayoutServiceCreateRequest', 'PayoutServiceCreateResponse') as Promise<types.PayoutServiceCreateResponse>;
  }

  /** PayoutService.CreateLink — Creates a link between the recipient and the payout. */
  async payoutCreateLink(
    requestMsg: types.IPayoutServiceCreateLinkRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PayoutServiceCreateLinkResponse> {
    return this._executeFlow('payout_create_link', requestMsg, options, 'PayoutServiceCreateLinkRequest', 'PayoutServiceCreateLinkResponse') as Promise<types.PayoutServiceCreateLinkResponse>;
  }

  /** PayoutService.CreateRecipient — Create payout recipient. */
  async payoutCreateRecipient(
    requestMsg: types.IPayoutServiceCreateRecipientRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PayoutServiceCreateRecipientResponse> {
    return this._executeFlow('payout_create_recipient', requestMsg, options, 'PayoutServiceCreateRecipientRequest', 'PayoutServiceCreateRecipientResponse') as Promise<types.PayoutServiceCreateRecipientResponse>;
  }

  /** PayoutService.Eligibility — Check eligibility of a payout before initiating it (e.g. SEPA VoP / payee verification). */
  async payoutEligibility(
    requestMsg: types.IPayoutMethodEligibilityRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PayoutMethodEligibilityResponse> {
    return this._executeFlow('payout_eligibility', requestMsg, options, 'PayoutMethodEligibilityRequest', 'PayoutMethodEligibilityResponse') as Promise<types.PayoutMethodEligibilityResponse>;
  }

  /** PayoutService.EnrollDisburseAccount — Enroll disburse account. */
  async payoutEnrollDisburseAccount(
    requestMsg: types.IPayoutServiceEnrollDisburseAccountRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PayoutServiceEnrollDisburseAccountResponse> {
    return this._executeFlow('payout_enroll_disburse_account', requestMsg, options, 'PayoutServiceEnrollDisburseAccountRequest', 'PayoutServiceEnrollDisburseAccountResponse') as Promise<types.PayoutServiceEnrollDisburseAccountResponse>;
  }

  /** PayoutService.Get — Retrieve payout details. */
  async payoutGet(
    requestMsg: types.IPayoutServiceGetRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PayoutServiceGetResponse> {
    return this._executeFlow('payout_get', requestMsg, options, 'PayoutServiceGetRequest', 'PayoutServiceGetResponse') as Promise<types.PayoutServiceGetResponse>;
  }

  /** PayoutService.Stage — Stage the payout. */
  async payoutStage(
    requestMsg: types.IPayoutServiceStageRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PayoutServiceStageResponse> {
    return this._executeFlow('payout_stage', requestMsg, options, 'PayoutServiceStageRequest', 'PayoutServiceStageResponse') as Promise<types.PayoutServiceStageResponse>;
  }

  /** PayoutService.Transfer — Creates a payout fund transfer. */
  async payoutTransfer(
    requestMsg: types.IPayoutServiceTransferRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PayoutServiceTransferResponse> {
    return this._executeFlow('payout_transfer', requestMsg, options, 'PayoutServiceTransferRequest', 'PayoutServiceTransferResponse') as Promise<types.PayoutServiceTransferResponse>;
  }

  /** PayoutService.Void — Void a payout. */
  async payoutVoid(
    requestMsg: types.IPayoutServiceVoidRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.PayoutServiceVoidResponse> {
    return this._executeFlow('payout_void', requestMsg, options, 'PayoutServiceVoidRequest', 'PayoutServiceVoidResponse') as Promise<types.PayoutServiceVoidResponse>;
  }

}

export class RecurringPaymentClient extends _ConnectorClientBase {
  /** RecurringPaymentService.Charge — Charge using an existing stored recurring payment instruction. Processes repeat payments for subscriptions or recurring billing without collecting payment details. */
  async charge(
    requestMsg: types.IRecurringPaymentServiceChargeRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.RecurringPaymentServiceChargeResponse> {
    return this._executeFlow('charge', requestMsg, options, 'RecurringPaymentServiceChargeRequest', 'RecurringPaymentServiceChargeResponse') as Promise<types.RecurringPaymentServiceChargeResponse>;
  }

  /** RecurringPaymentService.Revoke — Cancel an existing recurring payment mandate. Stops future automatic charges on customer's stored consent for subscription cancellations. */
  async recurringRevoke(
    requestMsg: types.IRecurringPaymentServiceRevokeRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.RecurringPaymentServiceRevokeResponse> {
    return this._executeFlow('recurring_revoke', requestMsg, options, 'RecurringPaymentServiceRevokeRequest', 'RecurringPaymentServiceRevokeResponse') as Promise<types.RecurringPaymentServiceRevokeResponse>;
  }

}

export class RefundClient extends _ConnectorClientBase {
  /** RefundService.Get — Retrieve refund status from the payment processor. Tracks refund progress through processor settlement for accurate customer communication. */
  async refundGet(
    requestMsg: types.IRefundServiceGetRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.RefundResponse> {
    return this._executeFlow('refund_get', requestMsg, options, 'RefundServiceGetRequest', 'RefundResponse') as Promise<types.RefundResponse>;
  }

}

export class SurchargeClient extends _ConnectorClientBase {
  /** SurchargeService.Calculate — Calculate surcharge fees for a payment amount before processing. */
  async surchargeCalculate(
    requestMsg: types.ISurchargeServiceCalculateRequest,
    options?: types.IRequestConfig | null
  ): Promise<types.SurchargeServiceCalculateResponse> {
    return this._executeFlow('surcharge_calculate', requestMsg, options, 'SurchargeServiceCalculateRequest', 'SurchargeServiceCalculateResponse') as Promise<types.SurchargeServiceCalculateResponse>;
  }

}
