@alphawebai/hs-prism 0.1.0-rc.27

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

@@ -0,0 +1,194 @@
+/**
+ * Connection configuration for the gRPC client.
+ * Field names must be snake_case — they are serialised to JSON and sent to the
+ * Rust FFI layer which deserialises them into GrpcConfigInput.
+ *
+ * The connector_config field should contain the connector-specific authentication
+ * and configuration in the format expected by the server:
+ * {"config": {"ConnectorName": {"api_key": "...", ...}}}
+ */
+export interface GrpcConfig {
+    endpoint: string;
+    connector: string;
+    connector_config: Record<string, unknown>;
+}
+interface GrpcFfi {
+    call: (method: string, configPtr: Buffer, configLen: number, reqPtr: Buffer, reqLen: number, outLen: number[]) => unknown;
+    free: (ptr: unknown, len: number) => void;
+}
+export declare class GrpcCustomerClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** CustomerService.Create — Create customer record in the payment processor system. Stores customer details for future payment operations without re-sending personal information. */
+    customerCreate(req: unknown): Promise<unknown>;
+    /** 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(req: unknown): Promise<unknown>;
+}
+export declare class GrpcDisputeClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** DisputeService.SubmitEvidence — Upload evidence to dispute customer chargeback. Provides documentation like receipts and delivery proof to contest fraudulent transaction claims. */
+    submitEvidence(req: unknown): Promise<unknown>;
+    /** DisputeService.Get — Retrieve dispute status and evidence submission state. Tracks dispute progress through bank review process for informed decision-making. */
+    disputeGet(req: unknown): Promise<unknown>;
+    /** DisputeService.Defend — Submit defense with reason code for dispute. Presents formal argument against customer's chargeback claim with supporting documentation. */
+    defend(req: unknown): Promise<unknown>;
+    /** DisputeService.Accept — Concede dispute and accepts chargeback loss. Acknowledges liability and stops dispute defense process when evidence is insufficient. */
+    accept(req: unknown): Promise<unknown>;
+}
+export declare class GrpcEventClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** EventService.ParseEvent — Parse a raw webhook payload without credentials. Returns resource reference and event type — sufficient to resolve secrets or early-exit. */
+    parseEvent(req: unknown): Promise<unknown>;
+    /** EventService.HandleEvent — Verify webhook source and return a unified typed response. Response mirrors PaymentService.Get / RefundService.Get / DisputeService.Get. */
+    handleEvent(req: unknown): Promise<unknown>;
+    /** EventService.NotifyConnector — Notify connectors about events (payment succeeded, refund succeeded, refund failed). */
+    notifyConnector(req: unknown): Promise<unknown>;
+}
+export declare class GrpcFraudAndRiskManagementClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** 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(req: unknown): Promise<unknown>;
+    /** FraudAndRiskManagementService.PostRiskCheck — Evaluate fraud risk after payment processing. Analyzes payment outcomes and post-transaction signals to refine risk models and detect chargeback fraud. */
+    postRiskCheck(req: unknown): Promise<unknown>;
+}
+export declare class GrpcMerchantAuthenticationClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** MerchantAuthenticationService.CreateServerAuthenticationToken — Generate short-lived connector authentication token. Provides secure credentials for connector API access without storing secrets client-side. */
+    createServerAuthenticationToken(req: unknown): Promise<unknown>;
+    /** MerchantAuthenticationService.CreateServerSessionAuthenticationToken — Create a server-side session with the connector. Establishes session state for multi-step operations like 3DS verification or wallet authorization. */
+    createServerSessionAuthenticationToken(req: unknown): Promise<unknown>;
+    /** 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(req: unknown): Promise<unknown>;
+}
+export declare class GrpcPaymentMethodAuthenticationClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** PaymentMethodAuthenticationService.PreAuthenticate — Initiate 3DS flow before payment authorization. Collects device data and prepares authentication context for frictionless or challenge-based verification. */
+    preAuthenticate(req: unknown): Promise<unknown>;
+    /** PaymentMethodAuthenticationService.Authenticate — Execute 3DS challenge or frictionless verification. Authenticates customer via bank challenge or behind-the-scenes verification for fraud prevention. */
+    authenticate(req: unknown): Promise<unknown>;
+    /** PaymentMethodAuthenticationService.PostAuthenticate — Validate authentication results with the issuing bank. Processes bank's authentication decision to determine if payment can proceed. */
+    postAuthenticate(req: unknown): Promise<unknown>;
+}
+export declare class GrpcPaymentMethodClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** PaymentMethodService.Tokenize — Tokenize payment method for secure storage. Replaces raw card details with secure token for one-click payments and recurring billing. */
+    tokenize(req: unknown): Promise<unknown>;
+    /** PaymentMethodService.Create — Create payment method at connector. Establishes a new payment method and returns connector-specific details. */
+    create(req: unknown): Promise<unknown>;
+    /** PaymentMethodService.Get — Retrieve payment method details from the payment processor. */
+    paymentMethodGet(req: unknown): Promise<unknown>;
+    /** PaymentMethodService.Recharge — Recharge a payment method (wallet, gift card, prepaid card) with funds. */
+    recharge(req: unknown): Promise<unknown>;
+    /** PaymentMethodService.Eligibility — Check if the payment method is eligible for the transaction (e.g. BNPL pre-checkout check) */
+    eligibility(req: unknown): Promise<unknown>;
+}
+export declare class GrpcPaymentClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** PaymentService.Authorize — Authorize a payment amount on a payment method. This reserves funds without capturing them, essential for verifying availability before finalizing. */
+    authorize(req: unknown): Promise<unknown>;
+    /** PaymentService.Get — Retrieve current payment status from the payment processor. Enables synchronization between your system and payment processors for accurate state tracking. */
+    get(req: unknown): Promise<unknown>;
+    /** 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(req: unknown): Promise<unknown>;
+    /** 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(req: unknown): Promise<unknown>;
+    /** 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(req: unknown): Promise<unknown>;
+    /** PaymentService.CreateOrder — Create a payment order for later processing. Establishes a transaction context that can be authorized or captured in subsequent API calls. */
+    createOrder(req: unknown): Promise<unknown>;
+    /** 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(req: unknown): Promise<unknown>;
+    /** 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(req: unknown): Promise<unknown>;
+    /** PaymentService.VerifyRedirectResponse — Verify and process redirect responses from 3D Secure or other external flows. Validates authentication results and updates payment state accordingly. */
+    verifyRedirectResponse(req: unknown): Promise<unknown>;
+    /** PaymentService.SetupRecurring — Configure a payment method for recurring billing. Sets up the mandate and payment details needed for future automated charges. */
+    setupRecurring(req: unknown): Promise<unknown>;
+    /** PaymentService.TokenAuthorize — Authorize using a connector-issued payment method token. */
+    tokenAuthorize(req: unknown): Promise<unknown>;
+    /** PaymentService.TokenSetupRecurring — Setup a recurring mandate using a connector token. */
+    tokenSetupRecurring(req: unknown): Promise<unknown>;
+    /** PaymentService.ProxyAuthorize — Authorize using vault-aliased card data. Proxy substitutes before connector. */
+    proxyAuthorize(req: unknown): Promise<unknown>;
+    /** PaymentService.ProxySetupRecurring — Setup recurring mandate using vault-aliased card data. */
+    proxySetupRecurring(req: unknown): Promise<unknown>;
+}
+export declare class GrpcPayoutClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** PayoutService.Create — Creates a payout. */
+    payoutCreate(req: unknown): Promise<unknown>;
+    /** PayoutService.Transfer — Creates a payout fund transfer. */
+    transfer(req: unknown): Promise<unknown>;
+    /** PayoutService.Get — Retrieve payout details. */
+    payoutGet(req: unknown): Promise<unknown>;
+    /** PayoutService.Void — Void a payout. */
+    payoutVoid(req: unknown): Promise<unknown>;
+    /** PayoutService.Stage — Stage the payout. */
+    stage(req: unknown): Promise<unknown>;
+    /** PayoutService.CreateLink — Creates a link between the recipient and the payout. */
+    createLink(req: unknown): Promise<unknown>;
+    /** PayoutService.CreateRecipient — Create payout recipient. */
+    createRecipient(req: unknown): Promise<unknown>;
+    /** PayoutService.EnrollDisburseAccount — Enroll disburse account. */
+    enrollDisburseAccount(req: unknown): Promise<unknown>;
+    /** PayoutService.Eligibility — Check if the payout method is eligible for the transaction */
+    payoutEligibility(req: unknown): Promise<unknown>;
+}
+export declare class GrpcRecurringPaymentClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** RecurringPaymentService.Charge — Charge using an existing stored recurring payment instruction. Processes repeat payments for subscriptions or recurring billing without collecting payment details. */
+    charge(req: unknown): Promise<unknown>;
+    /** RecurringPaymentService.Revoke — Cancel an existing recurring payment mandate. Stops future automatic charges on customer's stored consent for subscription cancellations. */
+    revoke(req: unknown): Promise<unknown>;
+}
+export declare class GrpcRefundClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** RefundService.Get — Retrieve refund status from the payment processor. Tracks refund progress through processor settlement for accurate customer communication. */
+    refundGet(req: unknown): Promise<unknown>;
+    /** RefundService.VoidPostRefund — Void/reverse a refund before processor settlement. */
+    voidPostRefund(req: unknown): Promise<unknown>;
+}
+export declare class GrpcSurchargeClient {
+    private ffi;
+    private config;
+    constructor(ffi: GrpcFfi, config: GrpcConfig);
+    /** SurchargeService.Calculate — Calculate surcharge fees for a payment amount before processing. */
+    calculate(req: unknown): Promise<unknown>;
+}
+export declare class GrpcClient {
+    customer: GrpcCustomerClient;
+    dispute: GrpcDisputeClient;
+    event: GrpcEventClient;
+    fraudAndRiskManagement: GrpcFraudAndRiskManagementClient;
+    merchantAuthentication: GrpcMerchantAuthenticationClient;
+    paymentMethodAuthentication: GrpcPaymentMethodAuthenticationClient;
+    paymentMethod: GrpcPaymentMethodClient;
+    payment: GrpcPaymentClient;
+    payout: GrpcPayoutClient;
+    recurringPayment: GrpcRecurringPaymentClient;
+    refund: GrpcRefundClient;
+    surcharge: GrpcSurchargeClient;
+    constructor(config: GrpcConfig, libPath?: string);
+}
+export {};