From a0c2bd81ccced82164b5c62b6fed121526abe790 Mon Sep 17 00:00:00 2001 From: Stripe OpenAPI <105521251+stripe-openapi[bot]@users.noreply.github.com> Date: Tue, 16 Sep 2025 20:32:51 +0000 Subject: [PATCH] Update generated code for v1975 and 2025-09-30.preview --- OPENAPI_VERSION | 2 +- lib/stripe/resources/issuing/authorization.rb | 50 +++++ .../issuing/authorization_service.rb | 50 +++++ rbi/stripe.rbi | 180 +++++++++++++++++- .../resources/issuing/authorization.rbi | 89 ++++++++- .../issuing/authorization_service.rbi | 91 ++++++++- 6 files changed, 457 insertions(+), 5 deletions(-) diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index 20ce6f67..39ed2f18 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v1974 \ No newline at end of file +v1975 \ No newline at end of file diff --git a/lib/stripe/resources/issuing/authorization.rb b/lib/stripe/resources/issuing/authorization.rb index 68c7746b..7754eb8a 100644 --- a/lib/stripe/resources/issuing/authorization.rb +++ b/lib/stripe/resources/issuing/authorization.rb @@ -504,6 +504,48 @@ module Stripe end end + class RiskAssessment < Stripe::RequestParams + class CardTestingRisk < Stripe::RequestParams + # The % of declines due to a card number not existing in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of card testing activity, meaning bad actors may be attempting different card number combinations to guess a correct one. Takes on values between 0 and 100. + attr_accessor :invalid_account_number_decline_rate_past_hour + # The % of declines due to incorrect verification data (like CVV or expiry) in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of bad actors attempting to utilize valid card credentials at merchants with verification requirements. Takes on values between 0 and 100. + attr_accessor :invalid_credentials_decline_rate_past_hour + # The likelihood that this authorization is associated with card testing activity. This is assessed by evaluating decline activity over the last hour. + attr_accessor :risk_level + + def initialize( + invalid_account_number_decline_rate_past_hour: nil, + invalid_credentials_decline_rate_past_hour: nil, + risk_level: nil + ) + @invalid_account_number_decline_rate_past_hour = invalid_account_number_decline_rate_past_hour + @invalid_credentials_decline_rate_past_hour = invalid_credentials_decline_rate_past_hour + @risk_level = risk_level + end + end + + class MerchantDisputeRisk < Stripe::RequestParams + # The dispute rate observed across all Stripe Issuing authorizations for this merchant. For example, a value of 50 means 50% of authorizations from this merchant on Stripe Issuing have resulted in a dispute. Higher values mean a higher likelihood the authorization is disputed. Takes on values between 0 and 100. + attr_accessor :dispute_rate + # The likelihood that authorizations from this merchant will result in a dispute based on their history on Stripe Issuing. + attr_accessor :risk_level + + def initialize(dispute_rate: nil, risk_level: nil) + @dispute_rate = dispute_rate + @risk_level = risk_level + end + end + # Stripe's assessment of this authorization's likelihood of being card testing activity. + attr_accessor :card_testing_risk + # The dispute risk of the merchant (the seller on a purchase) on an authorization based on all Stripe Issuing activity. + attr_accessor :merchant_dispute_risk + + def initialize(card_testing_risk: nil, merchant_dispute_risk: nil) + @card_testing_risk = card_testing_risk + @merchant_dispute_risk = merchant_dispute_risk + end + end + class VerificationData < Stripe::RequestParams class AuthenticationExemption < Stripe::RequestParams # The entity that requested the exemption, either the acquiring merchant or the Issuing user. @@ -568,6 +610,8 @@ module Stripe attr_accessor :expand # Fleet-specific information for authorizations using Fleet cards. attr_accessor :fleet + # Probability that this transaction can be disputed in the event of fraud. Assessed by comparing the characteristics of the authorization to card network rules. + attr_accessor :fraud_disputability_likelihood # Information about fuel that was purchased with this transaction. attr_accessor :fuel # If set `true`, you may provide [amount](https://stripe.com/docs/api/issuing/authorizations/approve#approve_issuing_authorization-amount) to control how much to hold for the authorization. @@ -580,6 +624,8 @@ module Stripe attr_accessor :merchant_data # Details about the authorization, such as identifiers, set by the card network. attr_accessor :network_data + # Stripe’s assessment of the fraud risk for this authorization. + attr_accessor :risk_assessment # Verifications that Stripe performed on information that the cardholder provided to the merchant. attr_accessor :verification_data # The digital wallet used for this transaction. One of `apple_pay`, `google_pay`, or `samsung_pay`. Will populate as `null` when no digital wallet was utilized. @@ -593,12 +639,14 @@ module Stripe currency: nil, expand: nil, fleet: nil, + fraud_disputability_likelihood: nil, fuel: nil, is_amount_controllable: nil, merchant_amount: nil, merchant_currency: nil, merchant_data: nil, network_data: nil, + risk_assessment: nil, verification_data: nil, wallet: nil ) @@ -609,12 +657,14 @@ module Stripe @currency = currency @expand = expand @fleet = fleet + @fraud_disputability_likelihood = fraud_disputability_likelihood @fuel = fuel @is_amount_controllable = is_amount_controllable @merchant_amount = merchant_amount @merchant_currency = merchant_currency @merchant_data = merchant_data @network_data = network_data + @risk_assessment = risk_assessment @verification_data = verification_data @wallet = wallet end diff --git a/lib/stripe/services/test_helpers/issuing/authorization_service.rb b/lib/stripe/services/test_helpers/issuing/authorization_service.rb index b38b0c55..997f5287 100644 --- a/lib/stripe/services/test_helpers/issuing/authorization_service.rb +++ b/lib/stripe/services/test_helpers/issuing/authorization_service.rb @@ -190,6 +190,48 @@ module Stripe end end + class RiskAssessment < Stripe::RequestParams + class CardTestingRisk < Stripe::RequestParams + # The % of declines due to a card number not existing in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of card testing activity, meaning bad actors may be attempting different card number combinations to guess a correct one. Takes on values between 0 and 100. + attr_accessor :invalid_account_number_decline_rate_past_hour + # The % of declines due to incorrect verification data (like CVV or expiry) in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of bad actors attempting to utilize valid card credentials at merchants with verification requirements. Takes on values between 0 and 100. + attr_accessor :invalid_credentials_decline_rate_past_hour + # The likelihood that this authorization is associated with card testing activity. This is assessed by evaluating decline activity over the last hour. + attr_accessor :risk_level + + def initialize( + invalid_account_number_decline_rate_past_hour: nil, + invalid_credentials_decline_rate_past_hour: nil, + risk_level: nil + ) + @invalid_account_number_decline_rate_past_hour = invalid_account_number_decline_rate_past_hour + @invalid_credentials_decline_rate_past_hour = invalid_credentials_decline_rate_past_hour + @risk_level = risk_level + end + end + + class MerchantDisputeRisk < Stripe::RequestParams + # The dispute rate observed across all Stripe Issuing authorizations for this merchant. For example, a value of 50 means 50% of authorizations from this merchant on Stripe Issuing have resulted in a dispute. Higher values mean a higher likelihood the authorization is disputed. Takes on values between 0 and 100. + attr_accessor :dispute_rate + # The likelihood that authorizations from this merchant will result in a dispute based on their history on Stripe Issuing. + attr_accessor :risk_level + + def initialize(dispute_rate: nil, risk_level: nil) + @dispute_rate = dispute_rate + @risk_level = risk_level + end + end + # Stripe's assessment of this authorization's likelihood of being card testing activity. + attr_accessor :card_testing_risk + # The dispute risk of the merchant (the seller on a purchase) on an authorization based on all Stripe Issuing activity. + attr_accessor :merchant_dispute_risk + + def initialize(card_testing_risk: nil, merchant_dispute_risk: nil) + @card_testing_risk = card_testing_risk + @merchant_dispute_risk = merchant_dispute_risk + end + end + class VerificationData < Stripe::RequestParams class AuthenticationExemption < Stripe::RequestParams # The entity that requested the exemption, either the acquiring merchant or the Issuing user. @@ -254,6 +296,8 @@ module Stripe attr_accessor :expand # Fleet-specific information for authorizations using Fleet cards. attr_accessor :fleet + # Probability that this transaction can be disputed in the event of fraud. Assessed by comparing the characteristics of the authorization to card network rules. + attr_accessor :fraud_disputability_likelihood # Information about fuel that was purchased with this transaction. attr_accessor :fuel # If set `true`, you may provide [amount](https://stripe.com/docs/api/issuing/authorizations/approve#approve_issuing_authorization-amount) to control how much to hold for the authorization. @@ -266,6 +310,8 @@ module Stripe attr_accessor :merchant_data # Details about the authorization, such as identifiers, set by the card network. attr_accessor :network_data + # Stripe’s assessment of the fraud risk for this authorization. + attr_accessor :risk_assessment # Verifications that Stripe performed on information that the cardholder provided to the merchant. attr_accessor :verification_data # The digital wallet used for this transaction. One of `apple_pay`, `google_pay`, or `samsung_pay`. Will populate as `null` when no digital wallet was utilized. @@ -279,12 +325,14 @@ module Stripe currency: nil, expand: nil, fleet: nil, + fraud_disputability_likelihood: nil, fuel: nil, is_amount_controllable: nil, merchant_amount: nil, merchant_currency: nil, merchant_data: nil, network_data: nil, + risk_assessment: nil, verification_data: nil, wallet: nil ) @@ -295,12 +343,14 @@ module Stripe @currency = currency @expand = expand @fleet = fleet + @fraud_disputability_likelihood = fraud_disputability_likelihood @fuel = fuel @is_amount_controllable = is_amount_controllable @merchant_amount = merchant_amount @merchant_currency = merchant_currency @merchant_data = merchant_data @network_data = network_data + @risk_assessment = risk_assessment @verification_data = verification_data @wallet = wallet end diff --git a/rbi/stripe.rbi b/rbi/stripe.rbi index 87962429..3ef97378 100644 --- a/rbi/stripe.rbi +++ b/rbi/stripe.rbi @@ -48134,6 +48134,77 @@ module Stripe sig { params(acquiring_institution_id: T.nilable(String)).void } def initialize(acquiring_institution_id: nil); end end + class RiskAssessment < Stripe::RequestParams + class CardTestingRisk < Stripe::RequestParams + # The % of declines due to a card number not existing in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of card testing activity, meaning bad actors may be attempting different card number combinations to guess a correct one. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def invalid_account_number_decline_rate_past_hour; end + sig { + params(_invalid_account_number_decline_rate_past_hour: T.nilable(Integer)).returns(T.nilable(Integer)) + } + def invalid_account_number_decline_rate_past_hour=( + _invalid_account_number_decline_rate_past_hour + ); end + # The % of declines due to incorrect verification data (like CVV or expiry) in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of bad actors attempting to utilize valid card credentials at merchants with verification requirements. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def invalid_credentials_decline_rate_past_hour; end + sig { + params(_invalid_credentials_decline_rate_past_hour: T.nilable(Integer)).returns(T.nilable(Integer)) + } + def invalid_credentials_decline_rate_past_hour=( + _invalid_credentials_decline_rate_past_hour + ); end + # The likelihood that this authorization is associated with card testing activity. This is assessed by evaluating decline activity over the last hour. + sig { returns(String) } + def risk_level; end + sig { params(_risk_level: String).returns(String) } + def risk_level=(_risk_level); end + sig { + params(invalid_account_number_decline_rate_past_hour: T.nilable(Integer), invalid_credentials_decline_rate_past_hour: T.nilable(Integer), risk_level: String).void + } + def initialize( + invalid_account_number_decline_rate_past_hour: nil, + invalid_credentials_decline_rate_past_hour: nil, + risk_level: nil + ); end + end + class MerchantDisputeRisk < Stripe::RequestParams + # The dispute rate observed across all Stripe Issuing authorizations for this merchant. For example, a value of 50 means 50% of authorizations from this merchant on Stripe Issuing have resulted in a dispute. Higher values mean a higher likelihood the authorization is disputed. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def dispute_rate; end + sig { params(_dispute_rate: T.nilable(Integer)).returns(T.nilable(Integer)) } + def dispute_rate=(_dispute_rate); end + # The likelihood that authorizations from this merchant will result in a dispute based on their history on Stripe Issuing. + sig { returns(String) } + def risk_level; end + sig { params(_risk_level: String).returns(String) } + def risk_level=(_risk_level); end + sig { params(dispute_rate: T.nilable(Integer), risk_level: String).void } + def initialize(dispute_rate: nil, risk_level: nil); end + end + # Stripe's assessment of this authorization's likelihood of being card testing activity. + sig { + returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::CardTestingRisk)) + } + def card_testing_risk; end + sig { + params(_card_testing_risk: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::CardTestingRisk)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::CardTestingRisk)) + } + def card_testing_risk=(_card_testing_risk); end + # The dispute risk of the merchant (the seller on a purchase) on an authorization based on all Stripe Issuing activity. + sig { + returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::MerchantDisputeRisk)) + } + def merchant_dispute_risk; end + sig { + params(_merchant_dispute_risk: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::MerchantDisputeRisk)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::MerchantDisputeRisk)) + } + def merchant_dispute_risk=(_merchant_dispute_risk); end + sig { + params(card_testing_risk: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::CardTestingRisk), merchant_dispute_risk: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::MerchantDisputeRisk)).void + } + def initialize(card_testing_risk: nil, merchant_dispute_risk: nil); end + end class VerificationData < Stripe::RequestParams class AuthenticationExemption < Stripe::RequestParams # The entity that requested the exemption, either the acquiring merchant or the Issuing user. @@ -48247,6 +48318,13 @@ module Stripe params(_fleet: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fleet)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fleet)) } def fleet=(_fleet); end + # Probability that this transaction can be disputed in the event of fraud. Assessed by comparing the characteristics of the authorization to card network rules. + sig { returns(T.nilable(String)) } + def fraud_disputability_likelihood; end + sig { + params(_fraud_disputability_likelihood: T.nilable(String)).returns(T.nilable(String)) + } + def fraud_disputability_likelihood=(_fraud_disputability_likelihood); end # Information about fuel that was purchased with this transaction. sig { returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fuel)) } def fuel; end @@ -48285,6 +48363,13 @@ module Stripe params(_network_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::NetworkData)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::NetworkData)) } def network_data=(_network_data); end + # Stripe’s assessment of the fraud risk for this authorization. + sig { returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment)) } + def risk_assessment; end + sig { + params(_risk_assessment: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment)) + } + def risk_assessment=(_risk_assessment); end # Verifications that Stripe performed on information that the cardholder provided to the merchant. sig { returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::VerificationData)) } def verification_data; end @@ -48298,7 +48383,7 @@ module Stripe sig { params(_wallet: T.nilable(String)).returns(T.nilable(String)) } def wallet=(_wallet); end sig { - params(amount: T.nilable(Integer), amount_details: T.nilable(::Stripe::Issuing::Authorization::CreateParams::AmountDetails), authorization_method: T.nilable(String), card: String, currency: T.nilable(String), expand: T.nilable(T::Array[String]), fleet: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fleet), fuel: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fuel), is_amount_controllable: T.nilable(T::Boolean), merchant_amount: T.nilable(Integer), merchant_currency: T.nilable(String), merchant_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::MerchantData), network_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::NetworkData), verification_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::VerificationData), wallet: T.nilable(String)).void + params(amount: T.nilable(Integer), amount_details: T.nilable(::Stripe::Issuing::Authorization::CreateParams::AmountDetails), authorization_method: T.nilable(String), card: String, currency: T.nilable(String), expand: T.nilable(T::Array[String]), fleet: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fleet), fraud_disputability_likelihood: T.nilable(String), fuel: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fuel), is_amount_controllable: T.nilable(T::Boolean), merchant_amount: T.nilable(Integer), merchant_currency: T.nilable(String), merchant_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::MerchantData), network_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::NetworkData), risk_assessment: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment), verification_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::VerificationData), wallet: T.nilable(String)).void } def initialize( amount: nil, @@ -48308,12 +48393,14 @@ module Stripe currency: nil, expand: nil, fleet: nil, + fraud_disputability_likelihood: nil, fuel: nil, is_amount_controllable: nil, merchant_amount: nil, merchant_currency: nil, merchant_data: nil, network_data: nil, + risk_assessment: nil, verification_data: nil, wallet: nil ); end @@ -254033,6 +254120,77 @@ module Stripe sig { params(acquiring_institution_id: T.nilable(String)).void } def initialize(acquiring_institution_id: nil); end end + class RiskAssessment < Stripe::RequestParams + class CardTestingRisk < Stripe::RequestParams + # The % of declines due to a card number not existing in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of card testing activity, meaning bad actors may be attempting different card number combinations to guess a correct one. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def invalid_account_number_decline_rate_past_hour; end + sig { + params(_invalid_account_number_decline_rate_past_hour: T.nilable(Integer)).returns(T.nilable(Integer)) + } + def invalid_account_number_decline_rate_past_hour=( + _invalid_account_number_decline_rate_past_hour + ); end + # The % of declines due to incorrect verification data (like CVV or expiry) in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of bad actors attempting to utilize valid card credentials at merchants with verification requirements. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def invalid_credentials_decline_rate_past_hour; end + sig { + params(_invalid_credentials_decline_rate_past_hour: T.nilable(Integer)).returns(T.nilable(Integer)) + } + def invalid_credentials_decline_rate_past_hour=( + _invalid_credentials_decline_rate_past_hour + ); end + # The likelihood that this authorization is associated with card testing activity. This is assessed by evaluating decline activity over the last hour. + sig { returns(String) } + def risk_level; end + sig { params(_risk_level: String).returns(String) } + def risk_level=(_risk_level); end + sig { + params(invalid_account_number_decline_rate_past_hour: T.nilable(Integer), invalid_credentials_decline_rate_past_hour: T.nilable(Integer), risk_level: String).void + } + def initialize( + invalid_account_number_decline_rate_past_hour: nil, + invalid_credentials_decline_rate_past_hour: nil, + risk_level: nil + ); end + end + class MerchantDisputeRisk < Stripe::RequestParams + # The dispute rate observed across all Stripe Issuing authorizations for this merchant. For example, a value of 50 means 50% of authorizations from this merchant on Stripe Issuing have resulted in a dispute. Higher values mean a higher likelihood the authorization is disputed. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def dispute_rate; end + sig { params(_dispute_rate: T.nilable(Integer)).returns(T.nilable(Integer)) } + def dispute_rate=(_dispute_rate); end + # The likelihood that authorizations from this merchant will result in a dispute based on their history on Stripe Issuing. + sig { returns(String) } + def risk_level; end + sig { params(_risk_level: String).returns(String) } + def risk_level=(_risk_level); end + sig { params(dispute_rate: T.nilable(Integer), risk_level: String).void } + def initialize(dispute_rate: nil, risk_level: nil); end + end + # Stripe's assessment of this authorization's likelihood of being card testing activity. + sig { + returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::CardTestingRisk)) + } + def card_testing_risk; end + sig { + params(_card_testing_risk: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::CardTestingRisk)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::CardTestingRisk)) + } + def card_testing_risk=(_card_testing_risk); end + # The dispute risk of the merchant (the seller on a purchase) on an authorization based on all Stripe Issuing activity. + sig { + returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::MerchantDisputeRisk)) + } + def merchant_dispute_risk; end + sig { + params(_merchant_dispute_risk: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::MerchantDisputeRisk)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::MerchantDisputeRisk)) + } + def merchant_dispute_risk=(_merchant_dispute_risk); end + sig { + params(card_testing_risk: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::CardTestingRisk), merchant_dispute_risk: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::MerchantDisputeRisk)).void + } + def initialize(card_testing_risk: nil, merchant_dispute_risk: nil); end + end class VerificationData < Stripe::RequestParams class AuthenticationExemption < Stripe::RequestParams # The entity that requested the exemption, either the acquiring merchant or the Issuing user. @@ -254150,6 +254308,13 @@ module Stripe params(_fleet: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fleet)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fleet)) } def fleet=(_fleet); end + # Probability that this transaction can be disputed in the event of fraud. Assessed by comparing the characteristics of the authorization to card network rules. + sig { returns(T.nilable(String)) } + def fraud_disputability_likelihood; end + sig { + params(_fraud_disputability_likelihood: T.nilable(String)).returns(T.nilable(String)) + } + def fraud_disputability_likelihood=(_fraud_disputability_likelihood); end # Information about fuel that was purchased with this transaction. sig { returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fuel)) @@ -254194,6 +254359,15 @@ module Stripe params(_network_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::NetworkData)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::NetworkData)) } def network_data=(_network_data); end + # Stripe’s assessment of the fraud risk for this authorization. + sig { + returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment)) + } + def risk_assessment; end + sig { + params(_risk_assessment: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment)) + } + def risk_assessment=(_risk_assessment); end # Verifications that Stripe performed on information that the cardholder provided to the merchant. sig { returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::VerificationData)) @@ -254209,7 +254383,7 @@ module Stripe sig { params(_wallet: T.nilable(String)).returns(T.nilable(String)) } def wallet=(_wallet); end sig { - params(amount: T.nilable(Integer), amount_details: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::AmountDetails), authorization_method: T.nilable(String), card: String, currency: T.nilable(String), expand: T.nilable(T::Array[String]), fleet: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fleet), fuel: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fuel), is_amount_controllable: T.nilable(T::Boolean), merchant_amount: T.nilable(Integer), merchant_currency: T.nilable(String), merchant_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::MerchantData), network_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::NetworkData), verification_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::VerificationData), wallet: T.nilable(String)).void + params(amount: T.nilable(Integer), amount_details: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::AmountDetails), authorization_method: T.nilable(String), card: String, currency: T.nilable(String), expand: T.nilable(T::Array[String]), fleet: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fleet), fraud_disputability_likelihood: T.nilable(String), fuel: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fuel), is_amount_controllable: T.nilable(T::Boolean), merchant_amount: T.nilable(Integer), merchant_currency: T.nilable(String), merchant_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::MerchantData), network_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::NetworkData), risk_assessment: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment), verification_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::VerificationData), wallet: T.nilable(String)).void } def initialize( amount: nil, @@ -254219,12 +254393,14 @@ module Stripe currency: nil, expand: nil, fleet: nil, + fraud_disputability_likelihood: nil, fuel: nil, is_amount_controllable: nil, merchant_amount: nil, merchant_currency: nil, merchant_data: nil, network_data: nil, + risk_assessment: nil, verification_data: nil, wallet: nil ); end diff --git a/rbi/stripe/resources/issuing/authorization.rbi b/rbi/stripe/resources/issuing/authorization.rbi index db16a7b8..50bafff5 100644 --- a/rbi/stripe/resources/issuing/authorization.rbi +++ b/rbi/stripe/resources/issuing/authorization.rbi @@ -775,6 +775,77 @@ module Stripe sig { params(acquiring_institution_id: T.nilable(String)).void } def initialize(acquiring_institution_id: nil); end end + class RiskAssessment < Stripe::RequestParams + class CardTestingRisk < Stripe::RequestParams + # The % of declines due to a card number not existing in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of card testing activity, meaning bad actors may be attempting different card number combinations to guess a correct one. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def invalid_account_number_decline_rate_past_hour; end + sig { + params(_invalid_account_number_decline_rate_past_hour: T.nilable(Integer)).returns(T.nilable(Integer)) + } + def invalid_account_number_decline_rate_past_hour=( + _invalid_account_number_decline_rate_past_hour + ); end + # The % of declines due to incorrect verification data (like CVV or expiry) in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of bad actors attempting to utilize valid card credentials at merchants with verification requirements. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def invalid_credentials_decline_rate_past_hour; end + sig { + params(_invalid_credentials_decline_rate_past_hour: T.nilable(Integer)).returns(T.nilable(Integer)) + } + def invalid_credentials_decline_rate_past_hour=( + _invalid_credentials_decline_rate_past_hour + ); end + # The likelihood that this authorization is associated with card testing activity. This is assessed by evaluating decline activity over the last hour. + sig { returns(String) } + def risk_level; end + sig { params(_risk_level: String).returns(String) } + def risk_level=(_risk_level); end + sig { + params(invalid_account_number_decline_rate_past_hour: T.nilable(Integer), invalid_credentials_decline_rate_past_hour: T.nilable(Integer), risk_level: String).void + } + def initialize( + invalid_account_number_decline_rate_past_hour: nil, + invalid_credentials_decline_rate_past_hour: nil, + risk_level: nil + ); end + end + class MerchantDisputeRisk < Stripe::RequestParams + # The dispute rate observed across all Stripe Issuing authorizations for this merchant. For example, a value of 50 means 50% of authorizations from this merchant on Stripe Issuing have resulted in a dispute. Higher values mean a higher likelihood the authorization is disputed. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def dispute_rate; end + sig { params(_dispute_rate: T.nilable(Integer)).returns(T.nilable(Integer)) } + def dispute_rate=(_dispute_rate); end + # The likelihood that authorizations from this merchant will result in a dispute based on their history on Stripe Issuing. + sig { returns(String) } + def risk_level; end + sig { params(_risk_level: String).returns(String) } + def risk_level=(_risk_level); end + sig { params(dispute_rate: T.nilable(Integer), risk_level: String).void } + def initialize(dispute_rate: nil, risk_level: nil); end + end + # Stripe's assessment of this authorization's likelihood of being card testing activity. + sig { + returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::CardTestingRisk)) + } + def card_testing_risk; end + sig { + params(_card_testing_risk: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::CardTestingRisk)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::CardTestingRisk)) + } + def card_testing_risk=(_card_testing_risk); end + # The dispute risk of the merchant (the seller on a purchase) on an authorization based on all Stripe Issuing activity. + sig { + returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::MerchantDisputeRisk)) + } + def merchant_dispute_risk; end + sig { + params(_merchant_dispute_risk: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::MerchantDisputeRisk)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::MerchantDisputeRisk)) + } + def merchant_dispute_risk=(_merchant_dispute_risk); end + sig { + params(card_testing_risk: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::CardTestingRisk), merchant_dispute_risk: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment::MerchantDisputeRisk)).void + } + def initialize(card_testing_risk: nil, merchant_dispute_risk: nil); end + end class VerificationData < Stripe::RequestParams class AuthenticationExemption < Stripe::RequestParams # The entity that requested the exemption, either the acquiring merchant or the Issuing user. @@ -888,6 +959,13 @@ module Stripe params(_fleet: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fleet)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fleet)) } def fleet=(_fleet); end + # Probability that this transaction can be disputed in the event of fraud. Assessed by comparing the characteristics of the authorization to card network rules. + sig { returns(T.nilable(String)) } + def fraud_disputability_likelihood; end + sig { + params(_fraud_disputability_likelihood: T.nilable(String)).returns(T.nilable(String)) + } + def fraud_disputability_likelihood=(_fraud_disputability_likelihood); end # Information about fuel that was purchased with this transaction. sig { returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fuel)) } def fuel; end @@ -926,6 +1004,13 @@ module Stripe params(_network_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::NetworkData)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::NetworkData)) } def network_data=(_network_data); end + # Stripe’s assessment of the fraud risk for this authorization. + sig { returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment)) } + def risk_assessment; end + sig { + params(_risk_assessment: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment)).returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment)) + } + def risk_assessment=(_risk_assessment); end # Verifications that Stripe performed on information that the cardholder provided to the merchant. sig { returns(T.nilable(::Stripe::Issuing::Authorization::CreateParams::VerificationData)) } def verification_data; end @@ -939,7 +1024,7 @@ module Stripe sig { params(_wallet: T.nilable(String)).returns(T.nilable(String)) } def wallet=(_wallet); end sig { - params(amount: T.nilable(Integer), amount_details: T.nilable(::Stripe::Issuing::Authorization::CreateParams::AmountDetails), authorization_method: T.nilable(String), card: String, currency: T.nilable(String), expand: T.nilable(T::Array[String]), fleet: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fleet), fuel: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fuel), is_amount_controllable: T.nilable(T::Boolean), merchant_amount: T.nilable(Integer), merchant_currency: T.nilable(String), merchant_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::MerchantData), network_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::NetworkData), verification_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::VerificationData), wallet: T.nilable(String)).void + params(amount: T.nilable(Integer), amount_details: T.nilable(::Stripe::Issuing::Authorization::CreateParams::AmountDetails), authorization_method: T.nilable(String), card: String, currency: T.nilable(String), expand: T.nilable(T::Array[String]), fleet: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fleet), fraud_disputability_likelihood: T.nilable(String), fuel: T.nilable(::Stripe::Issuing::Authorization::CreateParams::Fuel), is_amount_controllable: T.nilable(T::Boolean), merchant_amount: T.nilable(Integer), merchant_currency: T.nilable(String), merchant_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::MerchantData), network_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::NetworkData), risk_assessment: T.nilable(::Stripe::Issuing::Authorization::CreateParams::RiskAssessment), verification_data: T.nilable(::Stripe::Issuing::Authorization::CreateParams::VerificationData), wallet: T.nilable(String)).void } def initialize( amount: nil, @@ -949,12 +1034,14 @@ module Stripe currency: nil, expand: nil, fleet: nil, + fraud_disputability_likelihood: nil, fuel: nil, is_amount_controllable: nil, merchant_amount: nil, merchant_currency: nil, merchant_data: nil, network_data: nil, + risk_assessment: nil, verification_data: nil, wallet: nil ); end diff --git a/rbi/stripe/services/test_helpers/issuing/authorization_service.rbi b/rbi/stripe/services/test_helpers/issuing/authorization_service.rbi index 2a70ac8e..4f0687d8 100644 --- a/rbi/stripe/services/test_helpers/issuing/authorization_service.rbi +++ b/rbi/stripe/services/test_helpers/issuing/authorization_service.rbi @@ -273,6 +273,77 @@ module Stripe sig { params(acquiring_institution_id: T.nilable(String)).void } def initialize(acquiring_institution_id: nil); end end + class RiskAssessment < Stripe::RequestParams + class CardTestingRisk < Stripe::RequestParams + # The % of declines due to a card number not existing in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of card testing activity, meaning bad actors may be attempting different card number combinations to guess a correct one. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def invalid_account_number_decline_rate_past_hour; end + sig { + params(_invalid_account_number_decline_rate_past_hour: T.nilable(Integer)).returns(T.nilable(Integer)) + } + def invalid_account_number_decline_rate_past_hour=( + _invalid_account_number_decline_rate_past_hour + ); end + # The % of declines due to incorrect verification data (like CVV or expiry) in the past hour, taking place at the same merchant. Higher rates correspond to a greater probability of bad actors attempting to utilize valid card credentials at merchants with verification requirements. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def invalid_credentials_decline_rate_past_hour; end + sig { + params(_invalid_credentials_decline_rate_past_hour: T.nilable(Integer)).returns(T.nilable(Integer)) + } + def invalid_credentials_decline_rate_past_hour=( + _invalid_credentials_decline_rate_past_hour + ); end + # The likelihood that this authorization is associated with card testing activity. This is assessed by evaluating decline activity over the last hour. + sig { returns(String) } + def risk_level; end + sig { params(_risk_level: String).returns(String) } + def risk_level=(_risk_level); end + sig { + params(invalid_account_number_decline_rate_past_hour: T.nilable(Integer), invalid_credentials_decline_rate_past_hour: T.nilable(Integer), risk_level: String).void + } + def initialize( + invalid_account_number_decline_rate_past_hour: nil, + invalid_credentials_decline_rate_past_hour: nil, + risk_level: nil + ); end + end + class MerchantDisputeRisk < Stripe::RequestParams + # The dispute rate observed across all Stripe Issuing authorizations for this merchant. For example, a value of 50 means 50% of authorizations from this merchant on Stripe Issuing have resulted in a dispute. Higher values mean a higher likelihood the authorization is disputed. Takes on values between 0 and 100. + sig { returns(T.nilable(Integer)) } + def dispute_rate; end + sig { params(_dispute_rate: T.nilable(Integer)).returns(T.nilable(Integer)) } + def dispute_rate=(_dispute_rate); end + # The likelihood that authorizations from this merchant will result in a dispute based on their history on Stripe Issuing. + sig { returns(String) } + def risk_level; end + sig { params(_risk_level: String).returns(String) } + def risk_level=(_risk_level); end + sig { params(dispute_rate: T.nilable(Integer), risk_level: String).void } + def initialize(dispute_rate: nil, risk_level: nil); end + end + # Stripe's assessment of this authorization's likelihood of being card testing activity. + sig { + returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::CardTestingRisk)) + } + def card_testing_risk; end + sig { + params(_card_testing_risk: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::CardTestingRisk)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::CardTestingRisk)) + } + def card_testing_risk=(_card_testing_risk); end + # The dispute risk of the merchant (the seller on a purchase) on an authorization based on all Stripe Issuing activity. + sig { + returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::MerchantDisputeRisk)) + } + def merchant_dispute_risk; end + sig { + params(_merchant_dispute_risk: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::MerchantDisputeRisk)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::MerchantDisputeRisk)) + } + def merchant_dispute_risk=(_merchant_dispute_risk); end + sig { + params(card_testing_risk: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::CardTestingRisk), merchant_dispute_risk: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment::MerchantDisputeRisk)).void + } + def initialize(card_testing_risk: nil, merchant_dispute_risk: nil); end + end class VerificationData < Stripe::RequestParams class AuthenticationExemption < Stripe::RequestParams # The entity that requested the exemption, either the acquiring merchant or the Issuing user. @@ -390,6 +461,13 @@ module Stripe params(_fleet: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fleet)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fleet)) } def fleet=(_fleet); end + # Probability that this transaction can be disputed in the event of fraud. Assessed by comparing the characteristics of the authorization to card network rules. + sig { returns(T.nilable(String)) } + def fraud_disputability_likelihood; end + sig { + params(_fraud_disputability_likelihood: T.nilable(String)).returns(T.nilable(String)) + } + def fraud_disputability_likelihood=(_fraud_disputability_likelihood); end # Information about fuel that was purchased with this transaction. sig { returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fuel)) @@ -434,6 +512,15 @@ module Stripe params(_network_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::NetworkData)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::NetworkData)) } def network_data=(_network_data); end + # Stripe’s assessment of the fraud risk for this authorization. + sig { + returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment)) + } + def risk_assessment; end + sig { + params(_risk_assessment: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment)).returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment)) + } + def risk_assessment=(_risk_assessment); end # Verifications that Stripe performed on information that the cardholder provided to the merchant. sig { returns(T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::VerificationData)) @@ -449,7 +536,7 @@ module Stripe sig { params(_wallet: T.nilable(String)).returns(T.nilable(String)) } def wallet=(_wallet); end sig { - params(amount: T.nilable(Integer), amount_details: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::AmountDetails), authorization_method: T.nilable(String), card: String, currency: T.nilable(String), expand: T.nilable(T::Array[String]), fleet: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fleet), fuel: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fuel), is_amount_controllable: T.nilable(T::Boolean), merchant_amount: T.nilable(Integer), merchant_currency: T.nilable(String), merchant_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::MerchantData), network_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::NetworkData), verification_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::VerificationData), wallet: T.nilable(String)).void + params(amount: T.nilable(Integer), amount_details: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::AmountDetails), authorization_method: T.nilable(String), card: String, currency: T.nilable(String), expand: T.nilable(T::Array[String]), fleet: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fleet), fraud_disputability_likelihood: T.nilable(String), fuel: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::Fuel), is_amount_controllable: T.nilable(T::Boolean), merchant_amount: T.nilable(Integer), merchant_currency: T.nilable(String), merchant_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::MerchantData), network_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::NetworkData), risk_assessment: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::RiskAssessment), verification_data: T.nilable(::Stripe::TestHelpers::Issuing::AuthorizationService::CreateParams::VerificationData), wallet: T.nilable(String)).void } def initialize( amount: nil, @@ -459,12 +546,14 @@ module Stripe currency: nil, expand: nil, fleet: nil, + fraud_disputability_likelihood: nil, fuel: nil, is_amount_controllable: nil, merchant_amount: nil, merchant_currency: nil, merchant_data: nil, network_data: nil, + risk_assessment: nil, verification_data: nil, wallet: nil ); end