"use strict";
// AUTO-GENERATED — do not edit by hand.
// Source: services.proto ∩ bindings/uniffi.rs  |  Regenerate: make generate
Object.defineProperty(exports, "__esModule", { value: true });
exports.RefundClient = exports.RecurringPaymentClient = exports.PayoutClient = exports.PaymentClient = exports.PaymentMethodClient = exports.PaymentMethodAuthenticationClient = exports.MerchantAuthenticationClient = exports.EventClient = exports.DisputeClient = exports.CustomerClient = void 0;
const connector_client_1 = require("./connector_client");
class CustomerClient extends connector_client_1.ConnectorClient {
    /** CustomerService.Create — Create customer record in the payment processor system. Stores customer details for future payment operations without re-sending personal information. */
    async create(requestMsg, options) {
        return this._executeFlow('create', requestMsg, options, 'CustomerServiceCreateRequest', 'CustomerServiceCreateResponse');
    }
}
exports.CustomerClient = CustomerClient;
class DisputeClient extends connector_client_1.ConnectorClient {
    /** DisputeService.Accept — Concede dispute and accepts chargeback loss. Acknowledges liability and stops dispute defense process when evidence is insufficient. */
    async accept(requestMsg, options) {
        return this._executeFlow('accept', requestMsg, options, 'DisputeServiceAcceptRequest', 'DisputeServiceAcceptResponse');
    }
    /** DisputeService.Defend — Submit defense with reason code for dispute. Presents formal argument against customer's chargeback claim with supporting documentation. */
    async defend(requestMsg, options) {
        return this._executeFlow('defend', requestMsg, options, 'DisputeServiceDefendRequest', 'DisputeServiceDefendResponse');
    }
    /** DisputeService.SubmitEvidence — Upload evidence to dispute customer chargeback. Provides documentation like receipts and delivery proof to contest fraudulent transaction claims. */
    async submitEvidence(requestMsg, options) {
        return this._executeFlow('submit_evidence', requestMsg, options, 'DisputeServiceSubmitEvidenceRequest', 'DisputeServiceSubmitEvidenceResponse');
    }
}
exports.DisputeClient = DisputeClient;
class EventClient extends connector_client_1.ConnectorClient {
    /** EventService.HandleEvent — Process webhook notifications from connectors. Translates connector events into standardized responses for asynchronous payment state updates. */
    async handleEvent(requestMsg, options) {
        return this._executeDirect('handle_event', requestMsg, options, 'EventServiceHandleRequest', 'EventServiceHandleResponse');
    }
}
exports.EventClient = EventClient;
class MerchantAuthenticationClient extends connector_client_1.ConnectorClient {
    /** 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, options) {
        return this._executeFlow('create_client_authentication_token', requestMsg, options, 'MerchantAuthenticationServiceCreateClientAuthenticationTokenRequest', 'MerchantAuthenticationServiceCreateClientAuthenticationTokenResponse');
    }
    /** MerchantAuthenticationService.CreateServerAuthenticationToken — Generate short-lived connector authentication token. Provides secure credentials for connector API access without storing secrets client-side. */
    async createServerAuthenticationToken(requestMsg, options) {
        return this._executeFlow('create_server_authentication_token', requestMsg, options, 'MerchantAuthenticationServiceCreateServerAuthenticationTokenRequest', '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, options) {
        return this._executeFlow('create_server_session_authentication_token', requestMsg, options, 'MerchantAuthenticationServiceCreateServerSessionAuthenticationTokenRequest', 'MerchantAuthenticationServiceCreateServerSessionAuthenticationTokenResponse');
    }
}
exports.MerchantAuthenticationClient = MerchantAuthenticationClient;
class PaymentMethodAuthenticationClient extends connector_client_1.ConnectorClient {
    /** PaymentMethodAuthenticationService.Authenticate — Execute 3DS challenge or frictionless verification. Authenticates customer via bank challenge or behind-the-scenes verification for fraud prevention. */
    async authenticate(requestMsg, options) {
        return this._executeFlow('authenticate', requestMsg, options, 'PaymentMethodAuthenticationServiceAuthenticateRequest', 'PaymentMethodAuthenticationServiceAuthenticateResponse');
    }
    /** PaymentMethodAuthenticationService.PostAuthenticate — Validate authentication results with the issuing bank. Processes bank's authentication decision to determine if payment can proceed. */
    async postAuthenticate(requestMsg, options) {
        return this._executeFlow('post_authenticate', requestMsg, options, 'PaymentMethodAuthenticationServicePostAuthenticateRequest', '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, options) {
        return this._executeFlow('pre_authenticate', requestMsg, options, 'PaymentMethodAuthenticationServicePreAuthenticateRequest', 'PaymentMethodAuthenticationServicePreAuthenticateResponse');
    }
}
exports.PaymentMethodAuthenticationClient = PaymentMethodAuthenticationClient;
class PaymentMethodClient extends connector_client_1.ConnectorClient {
    /** 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, options) {
        return this._executeFlow('tokenize', requestMsg, options, 'PaymentMethodServiceTokenizeRequest', 'PaymentMethodServiceTokenizeResponse');
    }
}
exports.PaymentMethodClient = PaymentMethodClient;
class PaymentClient extends connector_client_1.ConnectorClient {
    /** 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, options) {
        return this._executeFlow('authorize', requestMsg, options, 'PaymentServiceAuthorizeRequest', '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, options) {
        return this._executeFlow('capture', requestMsg, options, 'PaymentServiceCaptureRequest', '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, options) {
        return this._executeFlow('create_order', requestMsg, options, 'PaymentServiceCreateOrderRequest', '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, options) {
        return this._executeFlow('get', requestMsg, options, 'PaymentServiceGetRequest', '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, options) {
        return this._executeFlow('incremental_authorization', requestMsg, options, 'PaymentServiceIncrementalAuthorizationRequest', 'PaymentServiceIncrementalAuthorizationResponse');
    }
    /** PaymentService.ProxyAuthorize — Authorize using vault-aliased card data. Proxy substitutes before connector. */
    async proxyAuthorize(requestMsg, options) {
        return this._executeFlow('proxy_authorize', requestMsg, options, 'PaymentServiceProxyAuthorizeRequest', 'PaymentServiceAuthorizeResponse');
    }
    /** PaymentService.ProxySetupRecurring — Setup recurring mandate using vault-aliased card data. */
    async proxySetupRecurring(requestMsg, options) {
        return this._executeFlow('proxy_setup_recurring', requestMsg, options, 'PaymentServiceProxySetupRecurringRequest', '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, options) {
        return this._executeFlow('refund', requestMsg, options, 'PaymentServiceRefundRequest', '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, options) {
        return this._executeFlow('reverse', requestMsg, options, 'PaymentServiceReverseRequest', '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, options) {
        return this._executeFlow('setup_recurring', requestMsg, options, 'PaymentServiceSetupRecurringRequest', 'PaymentServiceSetupRecurringResponse');
    }
    /** PaymentService.TokenAuthorize — Authorize using a connector-issued payment method token. */
    async tokenAuthorize(requestMsg, options) {
        return this._executeFlow('token_authorize', requestMsg, options, 'PaymentServiceTokenAuthorizeRequest', 'PaymentServiceAuthorizeResponse');
    }
    /** PaymentService.TokenSetupRecurring — Setup a recurring mandate using a connector token. */
    async tokenSetupRecurring(requestMsg, options) {
        return this._executeFlow('token_setup_recurring', requestMsg, options, 'PaymentServiceTokenSetupRecurringRequest', '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, options) {
        return this._executeFlow('void', requestMsg, options, 'PaymentServiceVoidRequest', '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, options) {
        return this._executeDirect('verify_redirect_response', requestMsg, options, 'PaymentServiceVerifyRedirectResponseRequest', 'PaymentServiceVerifyRedirectResponseResponse');
    }
}
exports.PaymentClient = PaymentClient;
class PayoutClient extends connector_client_1.ConnectorClient {
    /** PayoutService.Create — Creates a payout. */
    async payoutCreate(requestMsg, options) {
        return this._executeFlow('payout_create', requestMsg, options, 'PayoutServiceCreateRequest', 'PayoutServiceCreateResponse');
    }
    /** PayoutService.CreateLink — Creates a link between the recipient and the payout. */
    async payoutCreateLink(requestMsg, options) {
        return this._executeFlow('payout_create_link', requestMsg, options, 'PayoutServiceCreateLinkRequest', 'PayoutServiceCreateLinkResponse');
    }
    /** PayoutService.CreateRecipient — Create payout recipient. */
    async payoutCreateRecipient(requestMsg, options) {
        return this._executeFlow('payout_create_recipient', requestMsg, options, 'PayoutServiceCreateRecipientRequest', 'PayoutServiceCreateRecipientResponse');
    }
    /** PayoutService.EnrollDisburseAccount — Enroll disburse account. */
    async payoutEnrollDisburseAccount(requestMsg, options) {
        return this._executeFlow('payout_enroll_disburse_account', requestMsg, options, 'PayoutServiceEnrollDisburseAccountRequest', 'PayoutServiceEnrollDisburseAccountResponse');
    }
    /** PayoutService.Get — Retrieve payout details. */
    async payoutGet(requestMsg, options) {
        return this._executeFlow('payout_get', requestMsg, options, 'PayoutServiceGetRequest', 'PayoutServiceGetResponse');
    }
    /** PayoutService.Stage — Stage the payout. */
    async payoutStage(requestMsg, options) {
        return this._executeFlow('payout_stage', requestMsg, options, 'PayoutServiceStageRequest', 'PayoutServiceStageResponse');
    }
    /** PayoutService.Transfer — Creates a payout fund transfer. */
    async payoutTransfer(requestMsg, options) {
        return this._executeFlow('payout_transfer', requestMsg, options, 'PayoutServiceTransferRequest', 'PayoutServiceTransferResponse');
    }
    /** PayoutService.Void — Void a payout. */
    async payoutVoid(requestMsg, options) {
        return this._executeFlow('payout_void', requestMsg, options, 'PayoutServiceVoidRequest', 'PayoutServiceVoidResponse');
    }
}
exports.PayoutClient = PayoutClient;
class RecurringPaymentClient extends connector_client_1.ConnectorClient {
    /** 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, options) {
        return this._executeFlow('charge', requestMsg, options, 'RecurringPaymentServiceChargeRequest', 'RecurringPaymentServiceChargeResponse');
    }
    /** RecurringPaymentService.Revoke — Cancel an existing recurring payment mandate. Stops future automatic charges on customer's stored consent for subscription cancellations. */
    async recurringRevoke(requestMsg, options) {
        return this._executeFlow('recurring_revoke', requestMsg, options, 'RecurringPaymentServiceRevokeRequest', 'RecurringPaymentServiceRevokeResponse');
    }
}
exports.RecurringPaymentClient = RecurringPaymentClient;
class RefundClient extends connector_client_1.ConnectorClient {
    /** RefundService.Get — Retrieve refund status from the payment processor. Tracks refund progress through processor settlement for accurate customer communication. */
    async refundGet(requestMsg, options) {
        return this._executeFlow('refund_get', requestMsg, options, 'RefundServiceGetRequest', 'RefundResponse');
    }
}
exports.RefundClient = RefundClient;
//# sourceMappingURL=_generated_connector_client_flows.js.map