@vulog/aima-payment 1.1.88 → 1.1.91

package/README.md

@@ -1,20 +1,321 @@
-# @vulog/aima-booking
+# @vulog/aima-payment
+
+Payment management module for the AIMA platform. This module provides functionality to handle payments, setup intents, payment methods, and trip payments.
+
+## Installation
 
 ```bash
-npm i @vulog/aima-client @vulog/aima-core @vulog/aima-payment
+npm install @vulog/aima-client @vulog/aima-core @vulog/aima-payment
+```
+
+## Usage
+
+### Initialize Client
+
+```javascript
+import { getClient } from '@vulog/aima-client';
+import { 
+    getSetupIntent, 
+    getPaymentMethodDetailsForUser,
+    getSynchronize,
+    payATrip
+} from '@vulog/aima-payment';
+
+const client = getClient({
+    apiKey: 'your-api-key',
+    baseUrl: 'https://your-api-base-url',
+    clientId: 'your-client-id',
+    clientSecret: 'your-client-secret',
+    fleetId: 'your-fleet-id',
+});
+```
+
+## API Reference
+
+### Payment Setup
+
+#### getSetupIntent
+
+Create a setup intent for payment method configuration.
+
+```javascript
+const setupIntent = await getSetupIntent(client, 'user-uuid-here');
+```
+
+**Parameters:**
+- `client`: AIMA client instance
+- `entityId`: User UUID
+
+**Returns:** Setup intent object for payment method configuration
+
+#### getPaymentMethodDetailsForUser
+
+Retrieve payment method details for a specific user.
+
+```javascript
+const paymentMethods = await getPaymentMethodDetailsForUser(client, 'user-uuid-here');
+```
+
+**Parameters:**
+- `client`: AIMA client instance
+- `entityId`: User UUID
+
+**Returns:** Array of user's payment methods
+
+### Payment Processing
+
+#### payATrip
+
+Process payment for a trip.
+
+```javascript
+const paymentResult = await payATrip(client, {
+    tripId: 'trip-uuid-here',
+    paymentMethodId: 'payment-method-id-here',
+    amount: 25.50,
+    currency: 'EUR'
+});
+```
+
+**Parameters:**
+- `client`: AIMA client instance
+- `paymentData`: Payment configuration object
+  - `tripId`: Trip identifier
+  - `paymentMethodId`: Payment method identifier
+  - `amount`: Payment amount
+  - `currency`: Currency code
+
+**Returns:** Payment processing result
+
+#### getSynchronize
+
+Synchronize payment data.
+
+```javascript
+const syncResult = await getSynchronize(client, {
+    entityId: 'user-uuid-here',
+    lastSyncDate: '2024-01-01T00:00:00Z'
+});
+```
+
+**Parameters:**
+- `client`: AIMA client instance
+- `syncData`: Synchronization configuration
+  - `entityId`: User UUID
+  - `lastSyncDate`: Last synchronization date
+
+**Returns:** Synchronization result
+
+## Types
+
+### SetupIntent
+
+```typescript
+interface SetupIntent {
+    id: string;
+    clientSecret: string;
+    status: 'requires_payment_method' | 'requires_confirmation' | 'requires_action' | 'processing' | 'succeeded' | 'canceled';
+    paymentMethodTypes: string[];
+    createdAt: string;
+    updatedAt: string;
+}
 ```
 
+### PaymentMethod
+
+```typescript
+interface PaymentMethod {
+    id: string;
+    type: 'card' | 'bank_account' | 'sepa_debit';
+    card?: {
+        brand: string;
+        last4: string;
+        expMonth: number;
+        expYear: number;
+    };
+    bankAccount?: {
+        bankName: string;
+        last4: string;
+        routingNumber: string;
+    };
+    isDefault: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+```
+
+### PaymentResult
+
+```typescript
+interface PaymentResult {
+    id: string;
+    status: 'succeeded' | 'failed' | 'pending' | 'canceled';
+    amount: number;
+    currency: string;
+    paymentMethodId: string;
+    tripId: string;
+    errorMessage?: string;
+    createdAt: string;
+}
+```
+
+## Error Handling
+
+All functions include validation and will throw appropriate errors if:
+- Required parameters are missing
+- Invalid user or trip IDs are provided
+- Payment processing fails
+- Network errors occur
+
+## Examples
+
+### Complete Payment Workflow
+
 ```javascript
 import { getClient } from '@vulog/aima-client';
-import { getModelById } from '@vulog/aima-payment';
+import { 
+    getSetupIntent, 
+    getPaymentMethodDetailsForUser,
+    payATrip
+} from '@vulog/aima-payment';
 
 const client = getClient({
-    apiKey: '...',
-    baseUrl: '...',
-    clientId: '...',
-    clientSecret: '...',
-    fleetId: '...',
+    apiKey: 'your-api-key',
+    baseUrl: 'https://your-api-base-url',
+    clientId: 'your-client-id',
+    clientSecret: 'your-client-secret',
+    fleetId: 'your-fleet-id',
 });
 
-const response = await getSetupIntent(client, 'entityId');
+async function paymentWorkflow() {
+    try {
+        const userId = 'user-uuid-here';
+        
+        // Create setup intent for new payment method
+        const setupIntent = await getSetupIntent(client, userId);
+        console.log('Setup intent created:', setupIntent);
+        
+        // Get user's existing payment methods
+        const paymentMethods = await getPaymentMethodDetailsForUser(client, userId);
+        console.log(`User has ${paymentMethods.length} payment methods`);
+        
+        // Process trip payment
+        const paymentResult = await payATrip(client, {
+            tripId: 'trip-uuid-here',
+            paymentMethodId: paymentMethods[0].id,
+            amount: 25.50,
+            currency: 'EUR'
+        });
+        
+        console.log('Payment processed:', paymentResult);
+        
+        return { setupIntent, paymentMethods, paymentResult };
+    } catch (error) {
+        console.error('Payment workflow error:', error);
+        throw error;
+    }
+}
+```
+
+### Payment Method Management
+
+```javascript
+async function managePaymentMethods(client, userId) {
+    try {
+        const paymentMethods = await getPaymentMethodDetailsForUser(client, userId);
+        
+        const analysis = {
+            totalMethods: paymentMethods.length,
+            defaultMethod: paymentMethods.find(pm => pm.isDefault),
+            cardMethods: paymentMethods.filter(pm => pm.type === 'card'),
+            bankMethods: paymentMethods.filter(pm => pm.type === 'bank_account'),
+            sepaMethods: paymentMethods.filter(pm => pm.type === 'sepa_debit')
+        };
+        
+        console.log('Payment Method Analysis:');
+        console.log(`Total Methods: ${analysis.totalMethods}`);
+        console.log(`Default Method: ${analysis.defaultMethod?.id || 'None'}`);
+        console.log(`Card Methods: ${analysis.cardMethods.length}`);
+        console.log(`Bank Methods: ${analysis.bankMethods.length}`);
+        console.log(`SEPA Methods: ${analysis.sepaMethods.length}`);
+        
+        return analysis;
+    } catch (error) {
+        console.error('Payment method management error:', error);
+        throw error;
+    }
+}
+```
+
+### Trip Payment Processing
+
+```javascript
+async function processTripPayment(client, tripId, userId, amount, currency = 'EUR') {
+    try {
+        // Get user's payment methods
+        const paymentMethods = await getPaymentMethodDetailsForUser(client, userId);
+        
+        if (paymentMethods.length === 0) {
+            throw new Error('No payment methods found for user');
+        }
+        
+        // Use default payment method or first available
+        const paymentMethod = paymentMethods.find(pm => pm.isDefault) || paymentMethods[0];
+        
+        // Process payment
+        const paymentResult = await payATrip(client, {
+            tripId,
+            paymentMethodId: paymentMethod.id,
+            amount,
+            currency
+        });
+        
+        if (paymentResult.status === 'succeeded') {
+            console.log(`Payment successful: ${amount} ${currency} for trip ${tripId}`);
+        } else {
+            console.log(`Payment failed: ${paymentResult.errorMessage}`);
+        }
+        
+        return paymentResult;
+    } catch (error) {
+        console.error('Trip payment processing error:', error);
+        throw error;
+    }
+}
+```
+
+### Payment History and Analytics
+
+```javascript
+async function analyzePayments(client, userId) {
+    try {
+        // This would require additional API endpoints for payment history
+        // For now, we'll demonstrate with payment methods
+        const paymentMethods = await getPaymentMethodDetailsForUser(client, userId);
+        
+        const analysis = {
+            userPaymentMethods: paymentMethods.length,
+            hasDefaultMethod: paymentMethods.some(pm => pm.isDefault),
+            supportedTypes: [...new Set(paymentMethods.map(pm => pm.type))],
+            cardBrands: paymentMethods
+                .filter(pm => pm.card)
+                .map(pm => pm.card.brand),
+            recentMethods: paymentMethods
+                .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+                .slice(0, 3)
+        };
+        
+        console.log('Payment Analysis:');
+        console.log(`Payment Methods: ${analysis.userPaymentMethods}`);
+        console.log(`Has Default: ${analysis.hasDefaultMethod}`);
+        console.log(`Supported Types: ${analysis.supportedTypes.join(', ')}`);
+        console.log(`Card Brands: ${analysis.cardBrands.join(', ')}`);
+        console.log('Recent Methods:', analysis.recentMethods);
+        
+        return analysis;
+    } catch (error) {
+        console.error('Payment analysis error:', error);
+        throw error;
+    }
+}
 ```

package/dist/index.d.mts

@@ -33,9 +33,32 @@ type PaymentDetail = {
     paymentMethod: 'SEPA' | 'IDEAL' | 'PAYPAL' | 'CREDIT_CARD' | 'WIRE_TRANSFER' | 'EXTERNAL';
     mopStatus: 'MOP_VALID' | 'MOP_MISSING' | 'MOP_EXPIRED' | 'MOP_INVALID' | 'MOP_UPDATING' | 'MOP_UPDATE_FAILED' | 'MOP_UNKNOWN';
     paymentCurrency: string;
-    paymentType: 'CARD' | 'BANK' | 'PAYPAL' | 'SEPA' | 'EXTERNAL';
     cardFunding: 'credit' | 'debit' | 'prepaid' | 'unknown';
-};
+} & ({
+    paymentType: 'CARD';
+    cardSummary?: string;
+    cardType?: string;
+    expiryDate?: number;
+    expiryMonth?: string;
+    expiryYear?: string;
+} | {
+    paymentType: 'SEPA';
+    bankCode: string;
+    branchCode: string;
+    country: string;
+    fingerprint: string;
+    last4: string;
+} | {
+    paymentType: 'BANK';
+    bankName: string;
+    bankAccountNumber: string;
+    iban: string;
+    bic: string;
+} | {
+    paymentType: 'PAYPAL';
+} | {
+    paymentType: 'EXTERNAL';
+});
 type SynchronizeResponse = {
     status: 'SUCCEEDED' | 'REQUIRES_CAPTURE' | 'FAILED';
 };

package/dist/index.d.ts

@@ -33,9 +33,32 @@ type PaymentDetail = {
     paymentMethod: 'SEPA' | 'IDEAL' | 'PAYPAL' | 'CREDIT_CARD' | 'WIRE_TRANSFER' | 'EXTERNAL';
     mopStatus: 'MOP_VALID' | 'MOP_MISSING' | 'MOP_EXPIRED' | 'MOP_INVALID' | 'MOP_UPDATING' | 'MOP_UPDATE_FAILED' | 'MOP_UNKNOWN';
     paymentCurrency: string;
-    paymentType: 'CARD' | 'BANK' | 'PAYPAL' | 'SEPA' | 'EXTERNAL';
     cardFunding: 'credit' | 'debit' | 'prepaid' | 'unknown';
-};
+} & ({
+    paymentType: 'CARD';
+    cardSummary?: string;
+    cardType?: string;
+    expiryDate?: number;
+    expiryMonth?: string;
+    expiryYear?: string;
+} | {
+    paymentType: 'SEPA';
+    bankCode: string;
+    branchCode: string;
+    country: string;
+    fingerprint: string;
+    last4: string;
+} | {
+    paymentType: 'BANK';
+    bankName: string;
+    bankAccountNumber: string;
+    iban: string;
+    bic: string;
+} | {
+    paymentType: 'PAYPAL';
+} | {
+    paymentType: 'EXTERNAL';
+});
 type SynchronizeResponse = {
     status: 'SUCCEEDED' | 'REQUIRES_CAPTURE' | 'FAILED';
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-payment",
-    "version": "1.1.88",
+    "version": "1.1.91",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
@@ -19,8 +19,8 @@
     "author": "Vulog",
     "license": "MIT",
     "dependencies": {
-        "@vulog/aima-client": "1.1.88",
-        "@vulog/aima-core": "1.1.88"
+        "@vulog/aima-client": "1.1.91",
+        "@vulog/aima-core": "1.1.91"
     },
     "peerDependencies": {
         "zod": "^3.25.76"

package/src/getPaymentMethodDetailsForUser.test.ts

@@ -0,0 +1,253 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getPaymentMethodDetailsForUser } from './getPaymentMethodDetailsForUser';
+import { randomUUID } from 'crypto';
+
+describe('getPaymentMethodDetailsForUser', () => {
+    const userId = randomUUID();
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+    beforeEach(() => {
+        getMock.mockReset();
+        vi.useFakeTimers({ now: new Date('2025-01-12T13:35:50.123Z') });
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    test('call OK visa', async () => {
+        const mockData = {
+            token: 'pm_1RqA47HGgb8lFOFDpTeFe16C',
+            holderName: 'John Doe',
+            fleetId: client.clientOptions.fleetId,
+            entityId: '2f16423b-2b75-4a6e-a82e-5087f98a4df8',
+            pspName: 'STRIPE',
+            customerPspReference: 'cus_ScgfSAgJ6rmaNo',
+            entityStatus: 'APPROVED',
+            profileId: '7ca3b51c-3ada-4fe0-8e36-0030940dfde1',
+            profileName: 'default',
+            profileType: 'Single',
+            paymentMethod: 'CREDIT_CARD',
+            mopStatus: 'MOP_VALID',
+            cardSummary: '0817',
+            cardType: 'visa',
+            cardFunding: 'credit',
+            expiryDate: 1856563200000,
+            expiryMonth: '10',
+            expiryYear: '2028',
+            paymentType: 'CARD',
+        };
+        getMock.mockResolvedValueOnce({ data: [
+            mockData,
+        ]});
+
+        const result = await getPaymentMethodDetailsForUser(client, userId);
+        
+        expect(getMock).toBeCalled();
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/fleets/FLEET_ID/users/${userId}/paymentMethodDetails`);
+        expect(result).toBeTruthy();
+        expect(result?.token).toEqual(mockData.token);
+        expect(result?.holderName).toEqual(mockData.holderName);
+        expect(result?.fleetId).toEqual(mockData.fleetId);
+        expect(result?.entityId).toEqual(mockData.entityId);
+        expect(result?.pspName).toEqual(mockData.pspName);
+        expect(result?.customerPspReference).toEqual(mockData.customerPspReference);
+        expect(result?.entityStatus).toEqual(mockData.entityStatus);
+        expect(result?.profileId).toEqual(mockData.profileId);
+        expect(result?.profileName).toEqual(mockData.profileName);
+        expect(result?.profileType).toEqual(mockData.profileType);
+        expect(result?.paymentMethod).toEqual(mockData.paymentMethod);
+        expect(result?.mopStatus).toEqual(mockData.mopStatus);
+        expect(result?.paymentCurrency).toBeUndefined();
+        expect(result?.paymentType).toEqual(mockData.paymentType);
+        expect(result?.cardFunding).toEqual(mockData.cardFunding);
+        expect(result?.paymentType).toEqual('CARD');
+        if (result?.paymentType === 'CARD') {
+            expect(result?.cardSummary).toEqual(mockData.cardSummary);
+            expect(result?.cardType).toEqual(mockData.cardType);
+            expect(result?.expiryDate).toEqual(mockData.expiryDate);
+            expect(result?.expiryMonth).toEqual(mockData.expiryMonth);
+            expect(result?.expiryYear).toEqual(mockData.expiryYear);
+        }
+    });
+
+    test('call OK SEPA', async () => {
+        const mockData = {
+            token: 'pm_1Kb5WdCOd50lRjiu9tPH3r5i',
+            holderName: 'Thomas Durant',
+            fleetId: client.clientOptions.fleetId,
+            entityId: '2330f5d0-91a3-49fb-8f85-4133384bc02c',
+            pspName: 'STRIPE',
+            customerPspReference: 'cus_LHcyYpiF7A2he3',
+            entityStatus: 'PENDING',
+            profileId: 'ec94adb1-98e8-48ec-952a-dddc6cba8464',
+            profileName: 'default',
+            profileType: 'Single',
+            paymentMethod: 'SEPA',
+            mopStatus: 'MOP_INVALID',
+            bankCode: '20041',
+            branchCode: '01005',
+            country: 'FR',
+            fingerprint: 'SPFArCDNSB9TvZuS',
+            last4: '2606',
+            paymentType: 'SEPA',
+        };
+        getMock.mockResolvedValueOnce({ data: [
+            mockData,
+        ]});
+
+        const result = await getPaymentMethodDetailsForUser(client, userId);
+        
+        expect(getMock).toBeCalled();
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/fleets/FLEET_ID/users/${userId}/paymentMethodDetails`);
+        expect(result).toBeTruthy();
+        expect(result?.token).toEqual(mockData.token);
+        expect(result?.holderName).toEqual(mockData.holderName);
+        expect(result?.fleetId).toEqual(mockData.fleetId);
+        expect(result?.entityId).toEqual(mockData.entityId);
+        expect(result?.pspName).toEqual(mockData.pspName);
+        expect(result?.customerPspReference).toEqual(mockData.customerPspReference);
+        expect(result?.entityStatus).toEqual(mockData.entityStatus);
+        expect(result?.profileId).toEqual(mockData.profileId);
+        expect(result?.profileName).toEqual(mockData.profileName);
+        expect(result?.profileType).toEqual(mockData.profileType);
+        expect(result?.paymentMethod).toEqual(mockData.paymentMethod);
+        expect(result?.mopStatus).toEqual(mockData.mopStatus);
+        expect(result?.paymentCurrency).toBeUndefined();
+        expect(result?.paymentType).toEqual(mockData.paymentType);
+        expect(result?.cardFunding).toBeUndefined;
+        expect(result?.paymentType).toEqual('SEPA');
+        if (result?.paymentType === 'SEPA') {
+            expect(result?.bankCode).toEqual(mockData.bankCode);
+            expect(result?.branchCode).toEqual(mockData.branchCode);
+            expect(result?.country).toEqual(mockData.country);
+            expect(result?.fingerprint).toEqual(mockData.fingerprint);
+            expect(result?.last4).toEqual(mockData.last4);
+        }
+    });
+
+    test('call OK BANK', async () => {
+        const mockData = {
+            token: '8416227869543125',
+            holderName: 'Jack Dalton',
+            fleetId: client.clientOptions.fleetId,
+            entityId: '2330f5d0-91a3-49fb-8f85-4133384bc02d',
+            pspName: null,
+            customerPspReference: null,
+            entityStatus: 'APPROVED',
+            profileId: 'ec94adb1-98e8-48ec-952a-dddc6cba8465',
+            profileName: 'default',
+            profileType: 'Single',
+            paymentMethod: 'IDEAL',
+            mopStatus: 'MOP_INVALID',
+            paymentCurrency: null,
+            bankName: 'Test Issuer',
+            bankAccountNumber: '951',
+            iban: 'NL13TEST0123456789',
+            bic: 'TESTNL01',
+            paymentType: 'BANK',
+        };
+        getMock.mockResolvedValueOnce({ data: [
+            mockData,
+        ]});
+
+        const result = await getPaymentMethodDetailsForUser(client, userId);
+        
+        expect(getMock).toBeCalled();
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/fleets/FLEET_ID/users/${userId}/paymentMethodDetails`);
+        expect(result).toBeTruthy();
+        expect(result?.token).toEqual(mockData.token);
+        expect(result?.holderName).toEqual(mockData.holderName);
+        expect(result?.fleetId).toEqual(mockData.fleetId);
+        expect(result?.entityId).toEqual(mockData.entityId);
+        expect(result?.pspName).toEqual(mockData.pspName);
+        expect(result?.customerPspReference).toEqual(mockData.customerPspReference);
+        expect(result?.entityStatus).toEqual(mockData.entityStatus);
+        expect(result?.profileId).toEqual(mockData.profileId);
+        expect(result?.profileName).toEqual(mockData.profileName);
+        expect(result?.profileType).toEqual(mockData.profileType);
+        expect(result?.paymentMethod).toEqual(mockData.paymentMethod);
+        expect(result?.mopStatus).toEqual(mockData.mopStatus);
+        expect(result?.paymentCurrency).toBeFalsy();
+        expect(result?.paymentType).toEqual(mockData.paymentType);
+        expect(result?.cardFunding).toBeUndefined;
+        expect(result?.paymentType).toEqual('BANK');
+        if (result?.paymentType === 'BANK') {
+            expect(result?.bankName).toEqual(mockData.bankName);
+            expect(result?.bankAccountNumber).toEqual(mockData.bankAccountNumber);
+            expect(result?.iban).toEqual(mockData.iban);
+            expect(result?.bic).toEqual(mockData.bic);
+        }
+    });
+
+    test('call OK missing + business', async () => {
+        const mockData = [
+            {
+                token: null,
+                holderName: null,
+                fleetId: 'KINTOEU-ESSHARE',
+                entityId: 'cc42a4ca-2881-4ea3-af0e-1d8b15599243',
+                pspName: null,
+                customerPspReference: null,
+                entityStatus: 'APPROVED',
+                profileId: '2dfd07c3-cb97-4df0-a496-48a1c6c7eed4',
+                profileName: 'default',
+                profileType: 'Business',
+                paymentMethod: 'WIRE_TRANSFER',
+                mopStatus: 'MOP_VALID',
+                paymentCurrency: null,
+                bankName: null,
+                bankAccountNumber: null,
+                iban: 'FR0000000000000000',
+                bic: null,
+                paymentType: 'BANK',
+            },
+            {
+                entityStatus: 'APPROVED',
+                profileId: 'd392469a-484e-4b86-b9f7-498c2e27e3e0',
+                profileName: 'default',
+                profileType: 'Single',
+                paymentMethod: 'CREDIT_CARD',
+                mopStatus: 'MOP_MISSING',
+                paymentType: 'CARD',
+            }
+        ];
+        getMock.mockResolvedValueOnce({ data: mockData });
+
+        const result = await getPaymentMethodDetailsForUser(client, userId);
+        
+        expect(getMock).toBeCalled();
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/fleets/FLEET_ID/users/${userId}/paymentMethodDetails`);
+        expect(result).toBeTruthy();
+        expect(result?.token).toBeUndefined();
+        expect(result?.holderName).toBeUndefined();
+        expect(result?.fleetId).toBeUndefined();
+        expect(result?.entityId).toBeUndefined();
+        expect(result?.pspName).toBeUndefined();
+        expect(result?.customerPspReference).toBeUndefined();
+        expect(result?.entityStatus).toEqual(mockData[1].entityStatus);
+        expect(result?.profileId).toEqual(mockData[1].profileId);
+        expect(result?.profileName).toEqual(mockData[1].profileName);
+        expect(result?.profileType).toEqual(mockData[1].profileType);
+        expect(result?.paymentMethod).toEqual(mockData[1].paymentMethod);
+        expect(result?.mopStatus).toEqual(mockData[1].mopStatus);
+        expect(result?.paymentCurrency).toBeUndefined();
+        expect(result?.paymentType).toEqual(mockData[1].paymentType);
+        expect(result?.cardFunding).toBeUndefined;
+        expect(result?.paymentType).toEqual('CARD');
+        expect(result?.mopStatus).toEqual('MOP_MISSING');
+        if (result?.paymentType === 'CARD') {
+            expect(result?.cardSummary).toBeUndefined();
+            expect(result?.cardType).toBeUndefined();
+            expect(result?.expiryDate).toBeUndefined();
+            expect(result?.expiryMonth).toBeUndefined();
+            expect(result?.expiryYear).toBeUndefined();
+        }
+    });
+});

package/src/types.ts

@@ -38,9 +38,40 @@ export type PaymentDetail = {
         | 'MOP_UPDATE_FAILED'
         | 'MOP_UNKNOWN';
     paymentCurrency: string;
-    paymentType: 'CARD' | 'BANK' | 'PAYPAL' | 'SEPA' | 'EXTERNAL';
     cardFunding: 'credit' | 'debit' | 'prepaid' | 'unknown';
-};
+} & (
+    | {
+          paymentType: 'CARD'; // CARD is also the type used when there is no MoP ... hence all are optional.
+          cardSummary?: string;
+          cardType?: string;
+          expiryDate?: number;
+          expiryMonth?: string;
+          expiryYear?: string;
+      }
+    | {
+          paymentType: 'SEPA';
+          bankCode: string;
+          branchCode: string;
+          country: string;
+          fingerprint: string;
+          last4: string;
+      }
+    | {
+          paymentType: 'BANK';
+          bankName: string;
+          bankAccountNumber: string;
+          iban: string;
+          bic: string;
+      }
+    | {
+          paymentType: 'PAYPAL';
+          // ??
+      }
+    | {
+          paymentType: 'EXTERNAL';
+          // nothing more
+      }
+);
 
 export type SynchronizeResponse = {
     status: 'SUCCEEDED' | 'REQUIRES_CAPTURE' | 'FAILED';