/**
 * 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. */
    create(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>;
}
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.Eligibility — Check if the payout method is eligible for the transaction */
    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>;
}
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>;
}
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;
    merchantAuthentication: GrpcMerchantAuthenticationClient;
    paymentMethodAuthentication: GrpcPaymentMethodAuthenticationClient;
    paymentMethod: GrpcPaymentMethodClient;
    payment: GrpcPaymentClient;
    payout: GrpcPayoutClient;
    recurringPayment: GrpcRecurringPaymentClient;
    refund: GrpcRefundClient;
    surcharge: GrpcSurchargeClient;
    constructor(config: GrpcConfig, libPath?: string);
}
export {};
