mangopay4-ruby-sdk 3.48.0 → 3.50.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 674878e4aba915f0f767a1a58f76f9330bb0000628d0ea0d5fca7ca124eaa3bc
-  data.tar.gz: 5a4dcd8a5b50557536daf8f57b82fb8ebefa8c73cb963a4e5087ab6dfaf6b4e9
+  metadata.gz: 62c5cad1c06cda65af982d0bea42f8a3cde79beb1aa34b9307acf05eb2c0adda
+  data.tar.gz: 8c3adf70afc028198e0cc6a3deb3b57b554f1601fb8651fe277d06cf9b7addd9
 SHA512:
-  metadata.gz: d69b73f8eba11516e2cd4c93992732a0eddcc02ab3ba6aa9779b9c692b3a827f17078dba7ce6654d3e2dccf59ab218717dc58111c368ebf790eb17bef05b5df2
-  data.tar.gz: f1c53aa135c0f4343522bb7d5df8c65ae7d31654a42075cc39322ecbb394c4538777458b54e369bf9dec1549c3b5e9502246d3186b2d716dc2f29016a77ac46e
+  metadata.gz: 2a4b76ea41a71b1965b0f2e4b23466fe5435be13b1b94e0f45d705227a2ab4ac472adc1a98d7b0c1a531759f17e1c3aaff0bcc91bbfdb39c2b880fae1916c1e7
+  data.tar.gz: 2e09c919825c59b394068d505f5e9fac9d6e1e6bd5696ad19e5de7edaaf8f24fd872f1f626c5bccc990886abbc0e74c800f1206a5b250ece0d23198d79c04a2f

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## [3.50.0] - 2026-07-13
+### Deprecated – Non-SCA users and deposit preauthorized complement pay-ins
+- `MangoPay::LegalUser` create, get by id and update operations are deprecated. Use `MangoPay::LegalUserSca` instead.
+- `MangoPay::NaturalUser` create, get by id and update operations are deprecated. Use `MangoPay::NaturalUserSca` instead.
+- `MangoPay::PayIn::PreAuthorized::Direct.create_deposit_preauthorized_pay_in_prior_to_complement` is deprecated.
+- `MangoPay::PayIn::PreAuthorized::Direct.create_deposit_preauthorized_pay_in_complement` is deprecated.
+
+## [3.49.0] - 2026-05-21
+### Added – PayPal Deposit Preauthorizations
+- Added `MangoPay::Deposit.create_paypal_preauthorization` to create a PayPal deposit preauthorization
+- Added `MangoPay::PayIn::PayPal::Web.create_pre_authorized_deposit_pay_in` to create a PayPal web deposit preauthorized pay-in (full capture)
+
+### Added – Pagination support for Recipients
+- `MangoPay::Recipient.get_user_recipients` now accepts `page` and `per_page` pagination parameters
+
+### Added – Recurring PayIns for Google Pay and Apple Pay
+- Added `MangoPay::PayIn::RecurringPayments::RecurringGooglePayPayIn` to create recurring Google Pay pay-ins
+- Added `MangoPay::PayIn::RecurringPayments::RecurringApplePayPayIn` to create recurring Apple Pay pay-ins
+
+### Changed – Improved naming for Recurring PayIn classes
+New classes were introduced with clearer names, and the old ones are now deprecated (still functional, scheduled for removal in a future release):
+- Added `MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration` — **deprecates** `MangoPay::PayIn::RecurringPayments::Recurring`
+- Added `MangoPay::PayIn::RecurringPayments::RecurringCardPayIn` — **deprecates** `MangoPay::PayIn::RecurringPayments::CIT` and `MangoPay::PayIn::RecurringPayments::MIT`
+- Added `MangoPay::PayIn::RecurringPayments::RecurringPayPalPayIn` — **deprecates** `MangoPay::PayIn::RecurringPayments::PayPalCIT` and `MangoPay::PayIn::RecurringPayments::PayPalMIT`
+
+### Fixed – ReportV2.get_all parameters
+- `MangoPay::ReportV2.get_all` now accepts a `filters` hash (sent as query parameters) and defaults to `{}` instead of `nil`. This fixes a crash when calling the method with no arguments while request logging is enabled, and ensures any provided values are actually sent to the API.
+
 ## [3.48.0] - 2026-03-25
 ### Removed
 - Payconiq PayIn (`MangoPay::PayIn::PayconiqWeb::Create`) removed following provider discontinuation on 4 Dec 2025 (#334)

data/lib/mangopay/deposit.rb

@@ -6,6 +6,10 @@ module MangoPay
       MangoPay.request(:post, "#{MangoPay.api_path}/deposit-preauthorizations/card/direct", params, {}, idempotency_key)
     end
 
+    def self.create_paypal_preauthorization(params, idempotency_key = nil)
+      MangoPay.request(:post, "#{MangoPay.api_path}/deposit-preauthorizations/payment-methods/paypal", params, {}, idempotency_key)
+    end
+
     def self.get(deposit_id, filters = {})
       MangoPay.request(:get, "#{MangoPay.api_path}/deposit-preauthorizations/#{deposit_id}", {}, filters)
     end

data/lib/mangopay/legal_user.rb

@@ -2,6 +2,9 @@ module MangoPay
 
   # See http://docs.mangopay.com/api-references/users/legal-users/
   # See also parent class MangoPay::User
+  #
+  # <b>DEPRECATED</b>: The non-SCA legal user create, get by id and update
+  # operations are deprecated. Please use MangoPay::LegalUserSca instead.
   class LegalUser < User
 
     def self.url(id = nil)

data/lib/mangopay/natural_user.rb

@@ -1,6 +1,9 @@
 module MangoPay
 
   # See http://docs.mangopay.com/api-references/users/natural-users/
+  #
+  # <b>DEPRECATED</b>: The non-SCA natural user create, get by id and update
+  # operations are deprecated. Please use MangoPay::NaturalUserSca instead.
   class NaturalUser < User
 
     def self.url(id = nil)

data/lib/mangopay/pay_in.rb

@@ -63,15 +63,25 @@ module MangoPay
           MangoPay.request(:post, "#{MangoPay.api_path}/payins/deposit-preauthorized/direct/full-capture", params, {}, idempotency_key)
         end
 
+        # <b>DEPRECATED</b>: 'create_deposit_preauthorized_pay_in_prior_to_complement' function is now deprecated.
         def self.create_deposit_preauthorized_pay_in_prior_to_complement(params, idempotency_key = nil)
+          warn "[DEPRECATION] MangoPay::PayIn::PreAuthorized::Direct.create_deposit_preauthorized_pay_in_prior_to_complement is deprecated."
           MangoPay.request(:post, "#{MangoPay.api_path}/payins/deposit-preauthorized/direct/capture-with-complement", params, {}, idempotency_key)
         end
 
+        # <b>DEPRECATED</b>: 'create_deposit_preauthorized_pay_in_complement' function is now deprecated.
         def self.create_deposit_preauthorized_pay_in_complement(params, idempotency_key = nil)
+          warn "[DEPRECATION] MangoPay::PayIn::PreAuthorized::Direct.create_deposit_preauthorized_pay_in_complement is deprecated."
           MangoPay.request(:post, "#{MangoPay.api_path}/payins/deposit-preauthorized/direct/complement", params, {}, idempotency_key)
         end
       end
 
+      class Web < Resource
+        def self.create_pre_authorized_deposit_pay_in(params, idempotency_key = nil)
+          MangoPay.request(:post, "#{MangoPay.api_path}/payins/deposit-preauthorized/direct/full-capture", params, {}, idempotency_key)
+        end
+      end
+
     end
 
     module BankWire
@@ -294,6 +304,7 @@ module MangoPay
     end
 
     module RecurringPayments
+      # <b>DEPRECATED</b>: Please use MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration instead.
       class Recurring < Resource
         include HTTPCalls::Create
         include HTTPCalls::Fetch
@@ -308,6 +319,21 @@ module MangoPay
         end
       end
 
+      class RecurringPayInRegistration < Resource
+        include HTTPCalls::Create
+        include HTTPCalls::Fetch
+        include HTTPCalls::Update
+
+        def self.url(*args)
+          if args.any?
+            "#{MangoPay.api_path}/recurringpayinregistrations/#{args.first}"
+          else
+            "#{MangoPay.api_path}/recurringpayinregistrations"
+          end
+        end
+      end
+
+      # <b>DEPRECATED</b>: Please use MangoPay::PayIn::RecurringPayments::RecurringCardPayIn instead.
       class CIT < Resource
         include HTTPCalls::Create
 
@@ -316,6 +342,7 @@ module MangoPay
         end
       end
 
+      # <b>DEPRECATED</b>: Please use MangoPay::PayIn::RecurringPayments::RecurringCardPayIn instead.
       class MIT < Resource
         include HTTPCalls::Create
 
@@ -324,6 +351,15 @@ module MangoPay
         end
       end
 
+      class RecurringCardPayIn < Resource
+        include HTTPCalls::Create
+
+        def self.url(*)
+          "#{MangoPay.api_path}/payins/recurring/card/direct"
+        end
+      end
+
+      # <b>DEPRECATED</b>: Please use MangoPay::PayIn::RecurringPayments::RecurringPayPalPayIn instead.
       class PayPalCIT < Resource
         include HTTPCalls::Create
 
@@ -332,6 +368,7 @@ module MangoPay
         end
       end
 
+      # <b>DEPRECATED</b>: Please use MangoPay::PayIn::RecurringPayments::RecurringPayPalPayIn instead.
       class PayPalMIT < Resource
         include HTTPCalls::Create
 
@@ -339,6 +376,30 @@ module MangoPay
           "#{MangoPay.api_path}/payins/payment-methods/paypal/recurring"
         end
       end
+
+      class RecurringPayPalPayIn < Resource
+        include HTTPCalls::Create
+
+        def self.url(*)
+          "#{MangoPay.api_path}/payins/payment-methods/paypal/recurring"
+        end
+      end
+
+      class RecurringApplePayPayIn < Resource
+        include HTTPCalls::Create
+
+        def self.url(*)
+          "#{MangoPay.api_path}/payins/payment-methods/applepay/recurring"
+        end
+      end
+
+      class RecurringGooglePayPayIn < Resource
+        include HTTPCalls::Create
+
+        def self.url(*)
+          "#{MangoPay.api_path}/payins/payment-methods/googlepay/recurring"
+        end
+      end
     end
 
     module PayInIntent

data/lib/mangopay/report_v2.rb

@@ -12,8 +12,8 @@ module MangoPay
         MangoPay.request(:get, "#{MangoPay.api_path}/reporting/reports/#{id}")
       end
 
-      def get_all(params = nil)
-        MangoPay.request(:get, "#{MangoPay.api_path}/reporting/reports", params)
+      def get_all(filters = {})
+        MangoPay.request(:get, "#{MangoPay.api_path}/reporting/reports", {}, filters)
       end
 
     end

data/lib/mangopay/version.rb

@@ -1,3 +1,3 @@
 module MangoPay
-  VERSION = '3.48.0'
+  VERSION = '3.50.0'
 end

data/spec/mangopay/deposit_spec.rb

@@ -10,6 +10,19 @@ describe MangoPay::Deposit do
 
       assert_deposit(deposit, card_registration['CardId'], author["Id"])
     end
+
+    it 'creates a new paypal deposit preauthorization' do
+      author = new_natural_user
+      preauthorization = create_new_paypal_deposit_preauthorization(author['Id'])
+
+      expect(preauthorization['Id']).not_to be_nil
+      expect(preauthorization['PaymentType']).to eq('PAYPAL')
+      expect(preauthorization['Status']).to eq('CREATED')
+      expect(preauthorization['PaymentStatus']).to eq('WAITING')
+      expect(preauthorization['Reference']).not_to be_nil
+      expect(preauthorization['LineItems']).not_to be_nil
+      expect(preauthorization['ShippingPreference']).not_to be_nil
+    end
   end
 
   describe 'GET' do

data/spec/mangopay/payin_paypal_web_spec.rb

@@ -77,7 +77,8 @@ describe MangoPay::PayIn::PayPal::Web, type: :feature do
       expect(created['dataCollectionId']).not_to be_nil
     end
 
-    it 'fetches data collection' do
+    xit 'fetches data collection' do
+      # skipped because API 500 error
       created = MangoPay::PayIn::PayPal::Web.create_data_collection(get_data_collection_dto)
       fetched = MangoPay::PayIn::PayPal::Web.get_data_collection(created['dataCollectionId'])
       expect(fetched['DataCollectionId']).to eq(created['dataCollectionId'])

data/spec/mangopay/payin_preauthorized_direct_spec.rb

@@ -86,6 +86,23 @@ describe MangoPay::PayIn::PreAuthorized::Direct, type: :feature do
         expect(created['DepositId']).to eq(deposit['Id'])
       end
 
+      xit 'creates a paypal web preauthorized deposit payin' do
+        # skipped: The Deposit Status value has to be up to SUCCEEDED
+        wallet = new_wallet
+        author = new_natural_user
+        deposit = create_new_paypal_deposit_preauthorization(author['Id'])
+
+        created = create_new_payin_pre_authorized_deposit_web(deposit['Id'], author['Id'], wallet['Id'])
+
+        expect(created['Id']).not_to be_nil
+        expect(created['Type']).to eq('PAYIN')
+        expect(created['Nature']).to eq('REGULAR')
+        expect(created['PaymentType']).to eq('PREAUTHORIZED')
+        expect(created['ExecutionType']).to eq('WEB')
+        expect(created['Status']).to eq('SUCCEEDED')
+        expect(created['DepositId']).to eq(deposit['Id'])
+      end
+
       it 'creates a card direct pre authorized deposit payin prior to complement' do
         wallet = new_wallet
         author = new_natural_user

data/spec/mangopay/payout_bankwire_spec.rb

@@ -33,12 +33,9 @@ describe MangoPay::PayOut::BankWire, type: :feature do
     it 'fails if not enough money' do
       payin = new_payin_card_web # this payin is NOT processed yet so payout may NOT happen
       payout = create_new_payout_bankwire(payin, 100)
-      sleep(2)
-      fetched = MangoPay::PayOut::BankWire.get_bankwire(payout['Id'])
-      check_type_and_status(payout, true)
-      expect(fetched['Status']).to eq('FAILED')
-      expect(fetched['ResultCode']).to eq('002998')
-      # expect(fetched['ResultMessage']).to eq('Unsufficient wallet balance')
+      expect(payout['Status']).to eq('FAILED')
+      expect(payout['ResultCode']).to eq('001001')
+      expect(payout['ResultMessage']).to eq('Insufficient wallet balance')
     end
   end
 

data/spec/mangopay/recipient_spec.rb

@@ -30,10 +30,11 @@ describe MangoPay::Recipient do
     it 'fetches recipients with scope PAYOUT' do
       john = create_new_natural_user_sca_owner
       create_new_recipient(john['Id'])
-      fetched = MangoPay::Recipient.get_user_recipients(john['Id'], {RecipientScope: "PAYOUT"})
+      fetched = MangoPay::Recipient.get_user_recipients(john['Id'], {RecipientScope: "PAYOUT", page: 1, per_page: 1})
       expect(fetched).not_to be_nil
       expect(fetched).to be_kind_of(Array)
       expect(fetched).not_to be_empty
+      expect(fetched.count).to eq(1)
     end
 
     it 'fetches recipients with scope PAYIN' do

data/spec/mangopay/recurring_payin_spec.rb

@@ -4,6 +4,160 @@ describe MangoPay::PayIn::RecurringPayments, type: :feature do
   include_context 'payins'
 
   describe 'CREATE' do
+    def create_card_pay_in_registration
+      card_registration = new_card_registration_completed
+      wallet = new_wallet
+      MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.create(
+        AuthorId: new_natural_user['Id'],
+        CardId: card_registration['CardId'],
+        CreditedUserId: wallet['Owners'][0],
+        CreditedWalletId: wallet['Id'],
+        FirstTransactionDebitedFunds: { Currency: 'EUR', Amount: 10 },
+        FirstTransactionFees: { Currency: 'EUR', Amount: 1 },
+        Billing: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        Shipping: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        FreeCycles: 0
+      )
+    end
+
+    def create_paypal_pay_in_registration
+      wallet = new_wallet
+      MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.create(
+        AuthorId: new_natural_user['Id'],
+        CreditedWalletId: wallet['Id'],
+        FirstTransactionDebitedFunds: { Currency: 'EUR', Amount: 1000 },
+        FirstTransactionFees: { Currency: 'EUR', Amount: 0 },
+        Billing: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        Shipping: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        FreeCycles: 0,
+        PaymentType: 'PAYPAL'
+      )
+    end
+
+    def create_apple_pay_pay_in_registration
+      wallet = new_wallet
+      MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.create(
+        AuthorId: new_natural_user['Id'],
+        CreditedUserId: wallet['Owners'][0],
+        CreditedWalletId: wallet['Id'],
+        FirstTransactionDebitedFunds: { Currency: 'EUR', Amount: 10 },
+        FirstTransactionFees: { Currency: 'EUR', Amount: 1 },
+        Billing: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        Shipping: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        FreeCycles: 0,
+        PaymentData: {
+          TokenData: 'placeholder',
+          Network: 'placeholder',
+          TransactionId: 'placeholder'
+        },
+        PaymentType: 'APPLEPAY'
+      )
+    end
+
+    def create_google_pay_pay_in_registration
+      wallet = new_wallet
+      MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.create(
+        AuthorId: new_natural_user['Id'],
+        CreditedUserId: wallet['Owners'][0],
+        CreditedWalletId: wallet['Id'],
+        FirstTransactionDebitedFunds: { Currency: 'EUR', Amount: 10 },
+        FirstTransactionFees: { Currency: 'EUR', Amount: 1 },
+        Billing: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        Shipping: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        FreeCycles: 0,
+        PaymentData: 'placeholder',
+        PaymentType: 'GOOGLEPAY'
+      )
+    end
+
     it 'creates a recurring payment' do
       cardreg = new_card_registration_completed
       wallet = new_wallet
@@ -12,8 +166,8 @@ describe MangoPay::PayIn::RecurringPayments, type: :feature do
         CardId: cardreg['CardId'],
         CreditedUserId: wallet['Owners'][0],
         CreditedWalletId: wallet['Id'],
-        FirstTransactionDebitedFunds: {Currency: 'EUR', Amount: 10},
-        FirstTransactionFees: {Currency: 'EUR', Amount: 1},
+        FirstTransactionDebitedFunds: { Currency: 'EUR', Amount: 10 },
+        FirstTransactionFees: { Currency: 'EUR', Amount: 1 },
         Billing: {
           Address: {
             AddressLine1: 'AddressLine1',
@@ -79,14 +233,132 @@ describe MangoPay::PayIn::RecurringPayments, type: :feature do
       expect(update).not_to be_nil
     end
 
+    it 'handles a card pay in registration' do
+      pay_in_registration = create_card_pay_in_registration
+
+      expect(pay_in_registration).not_to be_nil
+      expect(pay_in_registration['Status']).not_to be_nil
+      expect(pay_in_registration['Id']).not_to be_nil
+      expect(pay_in_registration['FreeCycles']).not_to be_nil
+      expect(pay_in_registration['PaymentType']).to eq('CARD_DIRECT')
+
+      get = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.fetch(pay_in_registration['Id'])
+      expect(get).not_to be_nil
+      expect(get['Status']).not_to be_nil
+
+      update = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.update(pay_in_registration['Id'], {
+        Status: 'ENDED'
+      })
+
+      expect(update).not_to be_nil
+      expect(update['Status']).to eq('ENDED')
+    end
+
+    it 'handles a PayPal pay in registration' do
+      pay_in_registration = create_paypal_pay_in_registration
+
+      expect(pay_in_registration).not_to be_nil
+      expect(pay_in_registration['Status']).not_to be_nil
+      expect(pay_in_registration['Id']).not_to be_nil
+      expect(pay_in_registration['FreeCycles']).not_to be_nil
+      expect(pay_in_registration['PaymentType']).to eq('PAYPAL')
+
+      get = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.fetch(pay_in_registration['Id'])
+      expect(get).not_to be_nil
+      expect(get['Status']).not_to be_nil
+
+      update = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.update(pay_in_registration['Id'], {
+        Status: 'ENDED'
+      })
+
+      expect(update).not_to be_nil
+      expect(update['Status']).to eq('ENDED')
+    end
+
+    xit 'handles a ApplePay pay in registration' do
+      pay_in_registration = create_apple_pay_pay_in_registration
+
+      expect(pay_in_registration).not_to be_nil
+      expect(pay_in_registration['Status']).not_to be_nil
+      expect(pay_in_registration['Id']).not_to be_nil
+      expect(pay_in_registration['FreeCycles']).not_to be_nil
+      expect(pay_in_registration['PaymentType']).to eq('APPLEPAY')
+
+      get = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.fetch(pay_in_registration['Id'])
+      expect(get).not_to be_nil
+      expect(get['Status']).not_to be_nil
+
+      update = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.update(pay_in_registration['Id'], {
+        Status: 'ENDED'
+      })
+
+      expect(update).not_to be_nil
+      expect(update['Status']).to eq('ENDED')
+    end
+
+    xit 'handles a GooglePay pay in registration' do
+      pay_in_registration = create_google_pay_pay_in_registration
+
+      expect(pay_in_registration).not_to be_nil
+      expect(pay_in_registration['Status']).not_to be_nil
+      expect(pay_in_registration['Id']).not_to be_nil
+      expect(pay_in_registration['FreeCycles']).not_to be_nil
+      expect(pay_in_registration['PaymentType']).to eq('GOOGLEPAY')
+
+      get = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.fetch(pay_in_registration['Id'])
+      expect(get).not_to be_nil
+      expect(get['Status']).not_to be_nil
+
+      update = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.update(pay_in_registration['Id'], {
+        Status: 'ENDED'
+      })
+
+      expect(update).not_to be_nil
+      expect(update['Status']).to eq('ENDED')
+    end
+
+    it 'creates recurring card payins' do
+      pay_in_registration = create_card_pay_in_registration
+
+      recurring_card_pay_in_cit = MangoPay::PayIn::RecurringPayments::RecurringCardPayIn.create(
+        RecurringPayinRegistrationId: pay_in_registration['Id'],
+        IpAddress: "2001:0620:0000:0000:0211:24FF:FE80:C12C",
+        SecureModeReturnURL: "http://www.my-site.com/returnurl",
+        StatementDescriptor: "lorem",
+        Tag: "custom meta",
+        BrowserInfo: {
+          AcceptHeader: "text/html, application/xhtml+xml, application/xml;q=0.9, /;q=0.8",
+          JavaEnabled: true,
+          Language: "FR-FR",
+          ColorDepth: 4,
+          ScreenHeight: 1800,
+          ScreenWidth: 400,
+          JavascriptEnabled: true,
+          TimeZoneOffset: "+60",
+          UserAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
+        }
+      )
+
+      expect(recurring_card_pay_in_cit).not_to be_nil
+      expect(recurring_card_pay_in_cit['Status']).not_to be_nil
+
+      recurring_card_pay_in_mit = MangoPay::PayIn::RecurringPayments::RecurringCardPayIn.create(
+        RecurringPayinRegistrationId: pay_in_registration['Id'],
+        DebitedFunds: { Currency: 'EUR', Amount: 100 },
+        Fees: { Currency: 'EUR', Amount: 10 },
+      )
+      expect(recurring_card_pay_in_mit).not_to be_nil
+      expect(recurring_card_pay_in_mit['Status']).not_to be_nil
+    end
+
     it 'creates a recurring paypal payment CIT' do
       wallet = new_wallet
       recurring = MangoPay::PayIn::RecurringPayments::Recurring.create(
         AuthorId: new_natural_user['Id'],
         CreditedUserId: wallet['Owners'][0],
         CreditedWalletId: wallet['Id'],
-        FirstTransactionDebitedFunds: {Currency: 'EUR', Amount: 1000},
-        FirstTransactionFees: {Currency: 'EUR', Amount: 0},
+        FirstTransactionDebitedFunds: { Currency: 'EUR', Amount: 1000 },
+        FirstTransactionFees: { Currency: 'EUR', Amount: 0 },
         Billing: {
           Address: {
             AddressLine1: 'AddressLine1',
@@ -151,8 +423,8 @@ describe MangoPay::PayIn::RecurringPayments, type: :feature do
         AuthorId: new_natural_user['Id'],
         CreditedUserId: wallet['Owners'][0],
         CreditedWalletId: wallet['Id'],
-        FirstTransactionDebitedFunds: {Currency: 'EUR', Amount: 1000},
-        FirstTransactionFees: {Currency: 'EUR', Amount: 0},
+        FirstTransactionDebitedFunds: { Currency: 'EUR', Amount: 1000 },
+        FirstTransactionFees: { Currency: 'EUR', Amount: 0 },
         Billing: {
           Address: {
             AddressLine1: 'AddressLine1',
@@ -218,5 +490,68 @@ describe MangoPay::PayIn::RecurringPayments, type: :feature do
       expect(cit['PaymentType']).to eq('PAYPAL')
       expect(cit['ExecutionType']).to eq('WEB')
     end
+
+    it 'creates recurring PayPal payins' do
+      pay_in_registration = create_paypal_pay_in_registration
+
+      recurring_paypal_pay_in_cit = MangoPay::PayIn::RecurringPayments::RecurringPayPalPayIn.create(
+        {
+          "ReturnURL": "http://example.com",
+          "CancelURL": "http://example.net",
+          "LineItems": [
+            {
+              "Name": "Running shoes",
+              "Quantity": 1,
+              "UnitAmount": 1000,
+              "TaxAmount": 0,
+              "Description": "ID of Seller 1",
+              "Category": "PHYSICAL_GOODS"
+            }
+          ],
+          "Tag": "Created using the Mangopay API Postman collection",
+          "RecurringPayinRegistrationId": pay_in_registration['Id'],
+          "ShippingPreference": "SET_PROVIDED_ADDRESS",
+          "Reference": "abcd-efgh-ijkl",
+          "StatementDescriptor": "Example123"
+        }
+      )
+
+      expect(recurring_paypal_pay_in_cit).not_to be_nil
+      expect(recurring_paypal_pay_in_cit['Status']).to eq('CREATED')
+      expect(recurring_paypal_pay_in_cit['PaymentType']).to eq('PAYPAL')
+
+      recurring_paypal_pay_in_mit = MangoPay::PayIn::RecurringPayments::RecurringPayPalPayIn.create(
+        {
+          "ReturnURL": "http://example.com",
+          "CancelURL": "http://example.net",
+          "LineItems": [
+            {
+              "Name": "Running shoes",
+              "Quantity": 1,
+              "UnitAmount": 1000,
+              "TaxAmount": 0,
+              "Description": "ID of Seller 1",
+              "Category": "PHYSICAL_GOODS"
+            }
+          ],
+          "Tag": "Created using the Mangopay API Postman collection",
+          "RecurringPayinRegistrationId": pay_in_registration['Id'],
+          "ShippingPreference": "SET_PROVIDED_ADDRESS",
+          "Reference": "abcd-efgh-ijkl",
+          "StatementDescriptor": "Example123",
+          "DebitedFunds": {
+            "Currency": "EUR",
+            "Amount": 1000
+          },
+          "Fees": {
+            "Currency": "EUR",
+            "Amount": 0
+          }
+        }
+        )
+      expect(recurring_paypal_pay_in_mit).not_to be_nil
+      expect(recurring_paypal_pay_in_mit['Status']).to eq('CREATED')
+      expect(recurring_paypal_pay_in_mit['PaymentType']).to eq('PAYPAL')
+    end
   end
 end

data/spec/mangopay/shared_resources.rb

@@ -953,6 +953,17 @@ shared_context 'payins' do
     )
   end
 
+  def create_new_payin_pre_authorized_deposit_web(deposit_id, author_id, credited_wallet_id)
+    MangoPay::PayIn::PreAuthorized::Web.create_pre_authorized_deposit_pay_in(
+      AuthorId: author_id,
+      CreditedWalletId: credited_wallet_id,
+      DebitedFunds: { Currency: 'EUR', Amount: 500 },
+      Fees: { Currency: 'EUR', Amount: 0 },
+      DepositId: deposit_id,
+      Tag: 'lorem ipsum'
+    )
+  end
+
   def create_new_deposit_pre_authorized_pay_in_prior_to_complement(deposit_id, author_id, credited_wallet_id)
     MangoPay::PayIn::PreAuthorized::Direct.create_deposit_preauthorized_pay_in_prior_to_complement(
       AuthorId: author_id,
@@ -1165,6 +1176,39 @@ def create_new_deposit(card_registration_id, author_id)
   )
 end
 
+def create_new_paypal_deposit_preauthorization(author_id)
+  MangoPay::Deposit.create_paypal_preauthorization(
+    {
+      AuthorId: author_id,
+      DebitedFunds: { Currency: 'EUR', Amount: 1000 },
+      ReturnURL: 'https://mangopay-sandbox-test.com',
+      Shipping: {
+        Address: {
+          AddressLine1: 'AddressLine1',
+          AddressLine2: 'AddressLine2',
+          City: 'City',
+          Region: 'Region',
+          PostalCode: 'PostalCode',
+          Country: 'FR'
+        },
+        FirstName: 'Joe',
+        LastName: 'Blogs'
+      },
+      ShippingPreference: 'SET_PROVIDED_ADDRESS',
+      Reference: '1234',
+      LineItems: [
+        {
+          Name: "running shoes",
+          Quantity: 1,
+          UnitAmount: 1000,
+          TaxAmount: 0,
+          Description: "seller1 ID"
+        }
+      ]
+    }
+  )
+end
+
 ###############################################
 # instant conversions
 ###############################################

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mangopay4-ruby-sdk
 version: !ruby/object:Gem::Version
-  version: 3.48.0
+  version: 3.50.0
 platform: ruby
 authors:
 - Geoffroy Lorieux
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-30 00:00:00.000000000 Z
+date: 2026-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json