@alphawebai/hs-prism 0.1.0-rc.27

package/dist/src/payments/_generated_connector_client_flows.d.ts

@@ -0,0 +1,112 @@
+import { ConnectorClient as _ConnectorClientBase } from "./connector_client";
+import { types } from "./generated/proto";
+export declare 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. */
+    customerCreate(requestMsg: types.ICustomerServiceCreateRequest, options?: types.IRequestConfig | null): 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). */
+    customerGet(requestMsg: types.ICustomerServiceGetRequest, options?: types.IRequestConfig | null): Promise<types.CustomerServiceGetResponse>;
+}
+export declare class DisputeClient extends _ConnectorClientBase {
+    /** DisputeService.Accept — Concede dispute and accepts chargeback loss. Acknowledges liability and stops dispute defense process when evidence is insufficient. */
+    accept(requestMsg: types.IDisputeServiceAcceptRequest, options?: types.IRequestConfig | null): Promise<types.DisputeServiceAcceptResponse>;
+    /** DisputeService.Defend — Submit defense with reason code for dispute. Presents formal argument against customer's chargeback claim with supporting documentation. */
+    defend(requestMsg: types.IDisputeServiceDefendRequest, options?: types.IRequestConfig | null): Promise<types.DisputeServiceDefendResponse>;
+    /** DisputeService.SubmitEvidence — Upload evidence to dispute customer chargeback. Provides documentation like receipts and delivery proof to contest fraudulent transaction claims. */
+    submitEvidence(requestMsg: types.IDisputeServiceSubmitEvidenceRequest, options?: types.IRequestConfig | null): Promise<types.DisputeServiceSubmitEvidenceResponse>;
+}
+export declare class EventClient extends _ConnectorClientBase {
+    /** EventService.HandleEvent — Verify webhook source and return a unified typed response. Response mirrors PaymentService.Get / RefundService.Get / DisputeService.Get. */
+    handleEvent(requestMsg: types.IEventServiceHandleRequest, options?: types.IRequestConfig | null): 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. */
+    parseEvent(requestMsg: types.IEventServiceParseRequest, options?: types.IRequestConfig | null): Promise<types.EventServiceParseResponse>;
+}
+export declare 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. */
+    postRiskCheck(requestMsg: types.IFrmServicePostRiskCheckRequest, options?: types.IRequestConfig | null): 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. */
+    preRiskCheck(requestMsg: types.IFrmServicePreRiskCheckRequest, options?: types.IRequestConfig | null): Promise<types.FrmServicePreRiskCheckResponse>;
+}
+export declare 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. */
+    createClientAuthenticationToken(requestMsg: types.IMerchantAuthenticationServiceCreateClientAuthenticationTokenRequest, options?: types.IRequestConfig | null): Promise<types.MerchantAuthenticationServiceCreateClientAuthenticationTokenResponse>;
+    /** MerchantAuthenticationService.CreateServerAuthenticationToken — Generate short-lived connector authentication token. Provides secure credentials for connector API access without storing secrets client-side. */
+    createServerAuthenticationToken(requestMsg: types.IMerchantAuthenticationServiceCreateServerAuthenticationTokenRequest, options?: types.IRequestConfig | null): 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. */
+    createServerSessionAuthenticationToken(requestMsg: types.IMerchantAuthenticationServiceCreateServerSessionAuthenticationTokenRequest, options?: types.IRequestConfig | null): Promise<types.MerchantAuthenticationServiceCreateServerSessionAuthenticationTokenResponse>;
+}
+export declare 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. */
+    authenticate(requestMsg: types.IPaymentMethodAuthenticationServiceAuthenticateRequest, options?: types.IRequestConfig | null): Promise<types.PaymentMethodAuthenticationServiceAuthenticateResponse>;
+    /** PaymentMethodAuthenticationService.PostAuthenticate — Validate authentication results with the issuing bank. Processes bank's authentication decision to determine if payment can proceed. */
+    postAuthenticate(requestMsg: types.IPaymentMethodAuthenticationServicePostAuthenticateRequest, options?: types.IRequestConfig | null): Promise<types.PaymentMethodAuthenticationServicePostAuthenticateResponse>;
+    /** PaymentMethodAuthenticationService.PreAuthenticate — Initiate 3DS flow before payment authorization. Collects device data and prepares authentication context for frictionless or challenge-based verification. */
+    preAuthenticate(requestMsg: types.IPaymentMethodAuthenticationServicePreAuthenticateRequest, options?: types.IRequestConfig | null): Promise<types.PaymentMethodAuthenticationServicePreAuthenticateResponse>;
+}
+export declare class PaymentMethodClient extends _ConnectorClientBase {
+    /** PaymentMethodService.Eligibility — Check if the payment method is eligible for the transaction (e.g. BNPL pre-checkout check) */
+    eligibility(requestMsg: types.IPaymentMethodServiceEligibilityRequest, options?: types.IRequestConfig | null): Promise<types.PaymentMethodServiceEligibilityResponse>;
+    /** PaymentMethodService.Tokenize — Tokenize payment method for secure storage. Replaces raw card details with secure token for one-click payments and recurring billing. */
+    tokenize(requestMsg: types.IPaymentMethodServiceTokenizeRequest, options?: types.IRequestConfig | null): Promise<types.PaymentMethodServiceTokenizeResponse>;
+}
+export declare 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. */
+    authorize(requestMsg: types.IPaymentServiceAuthorizeRequest, options?: types.IRequestConfig | null): 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. */
+    capture(requestMsg: types.IPaymentServiceCaptureRequest, options?: types.IRequestConfig | null): 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. */
+    createOrder(requestMsg: types.IPaymentServiceCreateOrderRequest, options?: types.IRequestConfig | null): 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. */
+    get(requestMsg: types.IPaymentServiceGetRequest, options?: types.IRequestConfig | null): 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. */
+    incrementalAuthorization(requestMsg: types.IPaymentServiceIncrementalAuthorizationRequest, options?: types.IRequestConfig | null): Promise<types.PaymentServiceIncrementalAuthorizationResponse>;
+    /** PaymentService.ProxyAuthorize — Authorize using vault-aliased card data. Proxy substitutes before connector. */
+    proxyAuthorize(requestMsg: types.IPaymentServiceProxyAuthorizeRequest, options?: types.IRequestConfig | null): Promise<types.PaymentServiceAuthorizeResponse>;
+    /** PaymentService.ProxySetupRecurring — Setup recurring mandate using vault-aliased card data. */
+    proxySetupRecurring(requestMsg: types.IPaymentServiceProxySetupRecurringRequest, options?: types.IRequestConfig | null): 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. */
+    refund(requestMsg: types.IPaymentServiceRefundRequest, options?: types.IRequestConfig | null): 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. */
+    reverse(requestMsg: types.IPaymentServiceReverseRequest, options?: types.IRequestConfig | null): Promise<types.PaymentServiceReverseResponse>;
+    /** PaymentService.SetupRecurring — Configure a payment method for recurring billing. Sets up the mandate and payment details needed for future automated charges. */
+    setupRecurring(requestMsg: types.IPaymentServiceSetupRecurringRequest, options?: types.IRequestConfig | null): Promise<types.PaymentServiceSetupRecurringResponse>;
+    /** PaymentService.TokenAuthorize — Authorize using a connector-issued payment method token. */
+    tokenAuthorize(requestMsg: types.IPaymentServiceTokenAuthorizeRequest, options?: types.IRequestConfig | null): Promise<types.PaymentServiceAuthorizeResponse>;
+    /** PaymentService.TokenSetupRecurring — Setup a recurring mandate using a connector token. */
+    tokenSetupRecurring(requestMsg: types.IPaymentServiceTokenSetupRecurringRequest, options?: types.IRequestConfig | null): 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. */
+    void(requestMsg: types.IPaymentServiceVoidRequest, options?: types.IRequestConfig | null): 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. */
+    verifyRedirectResponse(requestMsg: types.IPaymentServiceVerifyRedirectResponseRequest, options?: types.IRequestConfig | null): Promise<types.PaymentServiceVerifyRedirectResponseResponse>;
+}
+export declare class PayoutClient extends _ConnectorClientBase {
+    /** PayoutService.Create — Creates a payout. */
+    payoutCreate(requestMsg: types.IPayoutServiceCreateRequest, options?: types.IRequestConfig | null): Promise<types.PayoutServiceCreateResponse>;
+    /** PayoutService.CreateLink — Creates a link between the recipient and the payout. */
+    payoutCreateLink(requestMsg: types.IPayoutServiceCreateLinkRequest, options?: types.IRequestConfig | null): Promise<types.PayoutServiceCreateLinkResponse>;
+    /** PayoutService.CreateRecipient — Create payout recipient. */
+    payoutCreateRecipient(requestMsg: types.IPayoutServiceCreateRecipientRequest, options?: types.IRequestConfig | null): Promise<types.PayoutServiceCreateRecipientResponse>;
+    /** PayoutService.EnrollDisburseAccount — Enroll disburse account. */
+    payoutEnrollDisburseAccount(requestMsg: types.IPayoutServiceEnrollDisburseAccountRequest, options?: types.IRequestConfig | null): Promise<types.PayoutServiceEnrollDisburseAccountResponse>;
+    /** PayoutService.Get — Retrieve payout details. */
+    payoutGet(requestMsg: types.IPayoutServiceGetRequest, options?: types.IRequestConfig | null): Promise<types.PayoutServiceGetResponse>;
+    /** PayoutService.Stage — Stage the payout. */
+    payoutStage(requestMsg: types.IPayoutServiceStageRequest, options?: types.IRequestConfig | null): Promise<types.PayoutServiceStageResponse>;
+    /** PayoutService.Transfer — Creates a payout fund transfer. */
+    payoutTransfer(requestMsg: types.IPayoutServiceTransferRequest, options?: types.IRequestConfig | null): Promise<types.PayoutServiceTransferResponse>;
+    /** PayoutService.Void — Void a payout. */
+    payoutVoid(requestMsg: types.IPayoutServiceVoidRequest, options?: types.IRequestConfig | null): Promise<types.PayoutServiceVoidResponse>;
+}
+export declare 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. */
+    charge(requestMsg: types.IRecurringPaymentServiceChargeRequest, options?: types.IRequestConfig | null): Promise<types.RecurringPaymentServiceChargeResponse>;
+    /** RecurringPaymentService.Revoke — Cancel an existing recurring payment mandate. Stops future automatic charges on customer's stored consent for subscription cancellations. */
+    recurringRevoke(requestMsg: types.IRecurringPaymentServiceRevokeRequest, options?: types.IRequestConfig | null): Promise<types.RecurringPaymentServiceRevokeResponse>;
+}
+export declare class RefundClient extends _ConnectorClientBase {
+    /** RefundService.Get — Retrieve refund status from the payment processor. Tracks refund progress through processor settlement for accurate customer communication. */
+    refundGet(requestMsg: types.IRefundServiceGetRequest, options?: types.IRequestConfig | null): Promise<types.RefundResponse>;
+}
+export declare class SurchargeClient extends _ConnectorClientBase {
+    /** SurchargeService.Calculate — Calculate surcharge fees for a payment amount before processing. */
+    surchargeCalculate(requestMsg: types.ISurchargeServiceCalculateRequest, options?: types.IRequestConfig | null): Promise<types.SurchargeServiceCalculateResponse>;
+}

package/dist/src/payments/_generated_connector_client_flows.js

@@ -0,0 +1,215 @@
+"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.SurchargeClient = exports.RefundClient = exports.RecurringPaymentClient = exports.PayoutClient = exports.PaymentClient = exports.PaymentMethodClient = exports.PaymentMethodAuthenticationClient = exports.MerchantAuthenticationClient = exports.FraudAndRiskManagementClient = 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 customerCreate(requestMsg, options) {
+        return this._executeFlow('customer_create', requestMsg, options, 'CustomerServiceCreateRequest', '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, options) {
+        return this._executeFlow('customer_get', requestMsg, options, 'CustomerServiceGetRequest', 'CustomerServiceGetResponse');
+    }
+}
+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 — Verify webhook source and return a unified typed response. Response mirrors PaymentService.Get / RefundService.Get / DisputeService.Get. */
+    async handleEvent(requestMsg, options) {
+        return this._executeDirect('handle_event', requestMsg, options, 'EventServiceHandleRequest', '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, options) {
+        return this._executeDirect('parse_event', requestMsg, options, 'EventServiceParseRequest', 'EventServiceParseResponse');
+    }
+}
+exports.EventClient = EventClient;
+class FraudAndRiskManagementClient extends connector_client_1.ConnectorClient {
+    /** 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, options) {
+        return this._executeFlow('post_risk_check', requestMsg, options, 'FrmServicePostRiskCheckRequest', '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, options) {
+        return this._executeFlow('pre_risk_check', requestMsg, options, 'FrmServicePreRiskCheckRequest', 'FrmServicePreRiskCheckResponse');
+    }
+}
+exports.FraudAndRiskManagementClient = FraudAndRiskManagementClient;
+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.Eligibility — Check if the payment method is eligible for the transaction (e.g. BNPL pre-checkout check) */
+    async eligibility(requestMsg, options) {
+        return this._executeFlow('eligibility', requestMsg, options, 'PaymentMethodServiceEligibilityRequest', 'PaymentMethodServiceEligibilityResponse');
+    }
+    /** 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;
+class SurchargeClient extends connector_client_1.ConnectorClient {
+    /** SurchargeService.Calculate — Calculate surcharge fees for a payment amount before processing. */
+    async surchargeCalculate(requestMsg, options) {
+        return this._executeFlow('surcharge_calculate', requestMsg, options, 'SurchargeServiceCalculateRequest', 'SurchargeServiceCalculateResponse');
+    }
+}
+exports.SurchargeClient = SurchargeClient;
+//# sourceMappingURL=_generated_connector_client_flows.js.map

package/dist/src/payments/_generated_flows.js

@@ -0,0 +1,141 @@
+// AUTO-GENERATED — do not edit by hand.
+// Source: services.proto ∩ bindings/uniffi.rs  |  Regenerate: make generate
+"use strict";
+
+const FLOWS = {
+  // accept: DisputeService.Accept — Concede dispute and accepts chargeback loss. Acknowledges liability and stops dispute defense process when evidence is insufficient.
+  accept                                     : { request: "DisputeServiceAcceptRequest", response: "DisputeServiceAcceptResponse" },
+
+  // authenticate: PaymentMethodAuthenticationService.Authenticate — Execute 3DS challenge or frictionless verification. Authenticates customer via bank challenge or behind-the-scenes verification for fraud prevention.
+  authenticate                               : { request: "PaymentMethodAuthenticationServiceAuthenticateRequest", response: "PaymentMethodAuthenticationServiceAuthenticateResponse" },
+
+  // authorize: PaymentService.Authorize — Authorize a payment amount on a payment method. This reserves funds without capturing them, essential for verifying availability before finalizing.
+  authorize                                  : { request: "PaymentServiceAuthorizeRequest", response: "PaymentServiceAuthorizeResponse" },
+
+  // capture: PaymentService.Capture — Finalize an authorized payment by transferring funds. Captures the authorized amount to complete the transaction and move funds to your merchant account.
+  capture                                    : { request: "PaymentServiceCaptureRequest", response: "PaymentServiceCaptureResponse" },
+
+  // charge: RecurringPaymentService.Charge — Charge using an existing stored recurring payment instruction. Processes repeat payments for subscriptions or recurring billing without collecting payment details.
+  charge                                     : { request: "RecurringPaymentServiceChargeRequest", response: "RecurringPaymentServiceChargeResponse" },
+
+  // create_client_authentication_token: MerchantAuthenticationService.CreateClientAuthenticationToken — Initialize client-facing SDK sessions for wallets, device fingerprinting, etc. Returns structured data the client SDK needs to render payment/verification UI.
+  create_client_authentication_token         : { request: "MerchantAuthenticationServiceCreateClientAuthenticationTokenRequest", response: "MerchantAuthenticationServiceCreateClientAuthenticationTokenResponse" },
+
+  // create_order: PaymentService.CreateOrder — Create a payment order for later processing. Establishes a transaction context that can be authorized or captured in subsequent API calls.
+  create_order                               : { request: "PaymentServiceCreateOrderRequest", response: "PaymentServiceCreateOrderResponse" },
+
+  // create_server_authentication_token: MerchantAuthenticationService.CreateServerAuthenticationToken — Generate short-lived connector authentication token. Provides secure credentials for connector API access without storing secrets client-side.
+  create_server_authentication_token         : { request: "MerchantAuthenticationServiceCreateServerAuthenticationTokenRequest", response: "MerchantAuthenticationServiceCreateServerAuthenticationTokenResponse" },
+
+  // create_server_session_authentication_token: MerchantAuthenticationService.CreateServerSessionAuthenticationToken — Create a server-side session with the connector. Establishes session state for multi-step operations like 3DS verification or wallet authorization.
+  create_server_session_authentication_token : { request: "MerchantAuthenticationServiceCreateServerSessionAuthenticationTokenRequest", response: "MerchantAuthenticationServiceCreateServerSessionAuthenticationTokenResponse" },
+
+  // customer_create: CustomerService.Create — Create customer record in the payment processor system. Stores customer details for future payment operations without re-sending personal information.
+  customer_create                            : { request: "CustomerServiceCreateRequest", response: "CustomerServiceCreateResponse" },
+
+  // customer_get: 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).
+  customer_get                               : { request: "CustomerServiceGetRequest", response: "CustomerServiceGetResponse" },
+
+  // defend: DisputeService.Defend — Submit defense with reason code for dispute. Presents formal argument against customer's chargeback claim with supporting documentation.
+  defend                                     : { request: "DisputeServiceDefendRequest", response: "DisputeServiceDefendResponse" },
+
+  // eligibility: PaymentMethodService.Eligibility — Check if the payment method is eligible for the transaction (e.g. BNPL pre-checkout check)
+  eligibility                                : { request: "PaymentMethodServiceEligibilityRequest", response: "PaymentMethodServiceEligibilityResponse" },
+
+  // get: PaymentService.Get — Retrieve current payment status from the payment processor. Enables synchronization between your system and payment processors for accurate state tracking.
+  get                                        : { request: "PaymentServiceGetRequest", response: "PaymentServiceGetResponse" },
+
+  // incremental_authorization: PaymentService.IncrementalAuthorization — Increase the authorized amount for an existing payment. Enables you to capture additional funds when the transaction amount changes after initial authorization.
+  incremental_authorization                  : { request: "PaymentServiceIncrementalAuthorizationRequest", response: "PaymentServiceIncrementalAuthorizationResponse" },
+
+  // payout_create: PayoutService.Create — Creates a payout.
+  payout_create                              : { request: "PayoutServiceCreateRequest", response: "PayoutServiceCreateResponse" },
+
+  // payout_create_link: PayoutService.CreateLink — Creates a link between the recipient and the payout.
+  payout_create_link                         : { request: "PayoutServiceCreateLinkRequest", response: "PayoutServiceCreateLinkResponse" },
+
+  // payout_create_recipient: PayoutService.CreateRecipient — Create payout recipient.
+  payout_create_recipient                    : { request: "PayoutServiceCreateRecipientRequest", response: "PayoutServiceCreateRecipientResponse" },
+
+  // payout_enroll_disburse_account: PayoutService.EnrollDisburseAccount — Enroll disburse account.
+  payout_enroll_disburse_account             : { request: "PayoutServiceEnrollDisburseAccountRequest", response: "PayoutServiceEnrollDisburseAccountResponse" },
+
+  // payout_get: PayoutService.Get — Retrieve payout details.
+  payout_get                                 : { request: "PayoutServiceGetRequest", response: "PayoutServiceGetResponse" },
+
+  // payout_stage: PayoutService.Stage — Stage the payout.
+  payout_stage                               : { request: "PayoutServiceStageRequest", response: "PayoutServiceStageResponse" },
+
+  // payout_transfer: PayoutService.Transfer — Creates a payout fund transfer.
+  payout_transfer                            : { request: "PayoutServiceTransferRequest", response: "PayoutServiceTransferResponse" },
+
+  // payout_void: PayoutService.Void — Void a payout.
+  payout_void                                : { request: "PayoutServiceVoidRequest", response: "PayoutServiceVoidResponse" },
+
+  // post_authenticate: PaymentMethodAuthenticationService.PostAuthenticate — Validate authentication results with the issuing bank. Processes bank's authentication decision to determine if payment can proceed.
+  post_authenticate                          : { request: "PaymentMethodAuthenticationServicePostAuthenticateRequest", response: "PaymentMethodAuthenticationServicePostAuthenticateResponse" },
+
+  // post_risk_check: FraudAndRiskManagementService.PostRiskCheck — Evaluate fraud risk after payment processing. Analyzes payment outcomes and post-transaction signals to refine risk models and detect chargeback fraud.
+  post_risk_check                            : { request: "FrmServicePostRiskCheckRequest", response: "FrmServicePostRiskCheckResponse" },
+
+  // pre_authenticate: PaymentMethodAuthenticationService.PreAuthenticate — Initiate 3DS flow before payment authorization. Collects device data and prepares authentication context for frictionless or challenge-based verification.
+  pre_authenticate                           : { request: "PaymentMethodAuthenticationServicePreAuthenticateRequest", response: "PaymentMethodAuthenticationServicePreAuthenticateResponse" },
+
+  // pre_risk_check: 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.
+  pre_risk_check                             : { request: "FrmServicePreRiskCheckRequest", response: "FrmServicePreRiskCheckResponse" },
+
+  // proxy_authorize: PaymentService.ProxyAuthorize — Authorize using vault-aliased card data. Proxy substitutes before connector.
+  proxy_authorize                            : { request: "PaymentServiceProxyAuthorizeRequest", response: "PaymentServiceAuthorizeResponse" },
+
+  // proxy_setup_recurring: PaymentService.ProxySetupRecurring — Setup recurring mandate using vault-aliased card data.
+  proxy_setup_recurring                      : { request: "PaymentServiceProxySetupRecurringRequest", response: "PaymentServiceSetupRecurringResponse" },
+
+  // recurring_revoke: RecurringPaymentService.Revoke — Cancel an existing recurring payment mandate. Stops future automatic charges on customer's stored consent for subscription cancellations.
+  recurring_revoke                           : { request: "RecurringPaymentServiceRevokeRequest", response: "RecurringPaymentServiceRevokeResponse" },
+
+  // refund: 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.
+  refund                                     : { request: "PaymentServiceRefundRequest", response: "RefundResponse" },
+
+  // refund_get: RefundService.Get — Retrieve refund status from the payment processor. Tracks refund progress through processor settlement for accurate customer communication.
+  refund_get                                 : { request: "RefundServiceGetRequest", response: "RefundResponse" },
+
+  // reverse: 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.
+  reverse                                    : { request: "PaymentServiceReverseRequest", response: "PaymentServiceReverseResponse" },
+
+  // setup_recurring: PaymentService.SetupRecurring — Configure a payment method for recurring billing. Sets up the mandate and payment details needed for future automated charges.
+  setup_recurring                            : { request: "PaymentServiceSetupRecurringRequest", response: "PaymentServiceSetupRecurringResponse" },
+
+  // submit_evidence: DisputeService.SubmitEvidence — Upload evidence to dispute customer chargeback. Provides documentation like receipts and delivery proof to contest fraudulent transaction claims.
+  submit_evidence                            : { request: "DisputeServiceSubmitEvidenceRequest", response: "DisputeServiceSubmitEvidenceResponse" },
+
+  // surcharge_calculate: SurchargeService.Calculate — Calculate surcharge fees for a payment amount before processing.
+  surcharge_calculate                        : { request: "SurchargeServiceCalculateRequest", response: "SurchargeServiceCalculateResponse" },
+
+  // token_authorize: PaymentService.TokenAuthorize — Authorize using a connector-issued payment method token.
+  token_authorize                            : { request: "PaymentServiceTokenAuthorizeRequest", response: "PaymentServiceAuthorizeResponse" },
+
+  // token_setup_recurring: PaymentService.TokenSetupRecurring — Setup a recurring mandate using a connector token.
+  token_setup_recurring                      : { request: "PaymentServiceTokenSetupRecurringRequest", response: "PaymentServiceSetupRecurringResponse" },
+
+  // tokenize: PaymentMethodService.Tokenize — Tokenize payment method for secure storage. Replaces raw card details with secure token for one-click payments and recurring billing.
+  tokenize                                   : { request: "PaymentMethodServiceTokenizeRequest", response: "PaymentMethodServiceTokenizeResponse" },
+
+  // void: 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.
+  void                                       : { request: "PaymentServiceVoidRequest", response: "PaymentServiceVoidResponse" },
+
+};
+
+// Single-step flows: no HTTP round-trip.
+const SINGLE_FLOWS = {
+  // handle_event: EventService.HandleEvent — Verify webhook source and return a unified typed response. Response mirrors PaymentService.Get / RefundService.Get / DisputeService.Get.
+  handle_event             : { request: "EventServiceHandleRequest", response: "EventServiceHandleResponse" },
+
+  // parse_event: EventService.ParseEvent — Parse a raw webhook payload without credentials. Returns resource reference and event type — sufficient to resolve secrets or early-exit.
+  parse_event              : { request: "EventServiceParseRequest", response: "EventServiceParseResponse" },
+
+  // verify_redirect_response: PaymentService.VerifyRedirectResponse — Verify and process redirect responses from 3D Secure or other external flows. Validates authentication results and updates payment state accordingly.
+  verify_redirect_response : { request: "PaymentServiceVerifyRedirectResponseRequest", response: "PaymentServiceVerifyRedirectResponseResponse" },
+
+};
+
+module.exports = { FLOWS, SINGLE_FLOWS };