stripe 15.5.0 → 15.6.0.pre.alpha.2

data/lib/stripe/services/issuing/fraud_liability_debit_service.rb

@@ -0,0 +1,83 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class FraudLiabilityDebitService < StripeService
+      class ListParams < Stripe::RequestParams
+        class Created < Stripe::RequestParams
+          # Minimum value to filter by (exclusive)
+          attr_accessor :gt
+          # Minimum value to filter by (inclusive)
+          attr_accessor :gte
+          # Maximum value to filter by (exclusive)
+          attr_accessor :lt
+          # Maximum value to filter by (inclusive)
+          attr_accessor :lte
+
+          def initialize(gt: nil, gte: nil, lt: nil, lte: nil)
+            @gt = gt
+            @gte = gte
+            @lt = lt
+            @lte = lte
+          end
+        end
+        # Only return Issuing Fraud Liability Debits that were created during the given date interval.
+        attr_accessor :created
+        # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+        # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+        attr_accessor :limit
+        # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+        attr_accessor :starting_after
+
+        def initialize(
+          created: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          starting_after: nil
+        )
+          @created = created
+          @ending_before = ending_before
+          @expand = expand
+          @limit = limit
+          @starting_after = starting_after
+        end
+      end
+
+      class RetrieveParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        attr_accessor :expand
+
+        def initialize(expand: nil)
+          @expand = expand
+        end
+      end
+
+      # Returns a list of Issuing FraudLiabilityDebit objects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
+      def list(params = {}, opts = {})
+        request(
+          method: :get,
+          path: "/v1/issuing/fraud_liability_debits",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Retrieves an Issuing FraudLiabilityDebit object.
+      def retrieve(fraud_liability_debit, params = {}, opts = {})
+        request(
+          method: :get,
+          path: format("/v1/issuing/fraud_liability_debits/%<fraud_liability_debit>s", { fraud_liability_debit: CGI.escape(fraud_liability_debit) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

data/lib/stripe/services/issuing/transaction_service.rb

@@ -34,6 +34,8 @@ module Stripe
         attr_accessor :expand
         # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
         attr_accessor :limit
+        # Only return transactions that are associated with the given settlement.
+        attr_accessor :settlement
         # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
         attr_accessor :starting_after
         # Only return transactions that have the given type. One of `capture` or `refund`.
@@ -46,6 +48,7 @@ module Stripe
           ending_before: nil,
           expand: nil,
           limit: nil,
+          settlement: nil,
           starting_after: nil,
           type: nil
         )
@@ -55,6 +58,7 @@ module Stripe
           @ending_before = ending_before
           @expand = expand
           @limit = limit
+          @settlement = settlement
           @starting_after = starting_after
           @type = type
         end

data/lib/stripe/services/issuing_service.rb

@@ -3,14 +3,18 @@
 
 module Stripe
   class IssuingService < StripeService
-    attr_reader :authorizations, :cards, :cardholders, :disputes, :personalization_designs, :physical_bundles, :tokens, :transactions
+    attr_reader :authorizations, :cards, :cardholders, :credit_underwriting_records, :disputes, :dispute_settlement_details, :fraud_liability_debits, :personalization_designs, :physical_bundles, :tokens, :transactions
 
     def initialize(requestor)
       super
       @authorizations = Stripe::Issuing::AuthorizationService.new(@requestor)
       @cards = Stripe::Issuing::CardService.new(@requestor)
       @cardholders = Stripe::Issuing::CardholderService.new(@requestor)
+      @credit_underwriting_records = Stripe::Issuing::CreditUnderwritingRecordService
+                                     .new(@requestor)
       @disputes = Stripe::Issuing::DisputeService.new(@requestor)
+      @dispute_settlement_details = Stripe::Issuing::DisputeSettlementDetailService.new(@requestor)
+      @fraud_liability_debits = Stripe::Issuing::FraudLiabilityDebitService.new(@requestor)
       @personalization_designs = Stripe::Issuing::PersonalizationDesignService.new(@requestor)
       @physical_bundles = Stripe::Issuing::PhysicalBundleService.new(@requestor)
       @tokens = Stripe::Issuing::TokenService.new(@requestor)

data/lib/stripe/services/mandate_service.rb

@@ -3,6 +3,41 @@
 
 module Stripe
   class MandateService < StripeService
+    class ListParams < Stripe::RequestParams
+      # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
+      attr_accessor :ending_before
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+      # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+      attr_accessor :limit
+      # The Stripe account ID that the mandates are intended for. Learn more about the [use case for connected accounts payments](https://stripe.com/docs/payments/connected-accounts).
+      attr_accessor :on_behalf_of
+      # Attribute for param field payment_method
+      attr_accessor :payment_method
+      # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+      attr_accessor :starting_after
+      # The status of the mandates to retrieve. Status indicates whether or not you can use it to initiate a payment, and can have a value of `active`, `pending`, or `inactive`.
+      attr_accessor :status
+
+      def initialize(
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        on_behalf_of: nil,
+        payment_method: nil,
+        starting_after: nil,
+        status: nil
+      )
+        @ending_before = ending_before
+        @expand = expand
+        @limit = limit
+        @on_behalf_of = on_behalf_of
+        @payment_method = payment_method
+        @starting_after = starting_after
+        @status = status
+      end
+    end
+
     class RetrieveParams < Stripe::RequestParams
       # Specifies which fields in the response should be expanded.
       attr_accessor :expand
@@ -12,6 +47,11 @@ module Stripe
       end
     end
 
+    # Retrieves a list of Mandates for a given PaymentMethod.
+    def list(params = {}, opts = {})
+      request(method: :get, path: "/v1/mandates", params: params, opts: opts, base_address: :api)
+    end
+
     # Retrieves a Mandate object.
     def retrieve(mandate, params = {}, opts = {})
       request(

data/lib/stripe/services/margin_service.rb

@@ -0,0 +1,119 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class MarginService < StripeService
+    class ListParams < Stripe::RequestParams
+      # Only return margins that are active or inactive. For example, pass `true` to only list active margins.
+      attr_accessor :active
+      # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
+      attr_accessor :ending_before
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+      # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+      attr_accessor :limit
+      # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+      attr_accessor :starting_after
+
+      def initialize(active: nil, ending_before: nil, expand: nil, limit: nil, starting_after: nil)
+        @active = active
+        @ending_before = ending_before
+        @expand = expand
+        @limit = limit
+        @starting_after = starting_after
+      end
+    end
+
+    class CreateParams < Stripe::RequestParams
+      # Whether the margin can be applied to invoices, invoice items, or invoice line items or not. Defaults to `true`.
+      attr_accessor :active
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+      # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+      attr_accessor :metadata
+      # Name of the margin, which is displayed to customers, such as on invoices.
+      attr_accessor :name
+      # Percent that will be taken off the subtotal before tax (after all other discounts and promotions) of any invoice to which the margin is applied.
+      attr_accessor :percent_off
+
+      def initialize(active: nil, expand: nil, metadata: nil, name: nil, percent_off: nil)
+        @active = active
+        @expand = expand
+        @metadata = metadata
+        @name = name
+        @percent_off = percent_off
+      end
+    end
+
+    class RetrieveParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(expand: nil)
+        @expand = expand
+      end
+    end
+
+    class UpdateParams < Stripe::RequestParams
+      # Whether the margin can be applied to invoices, invoice items, or invoice line items or not.
+      attr_accessor :active
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+      # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+      attr_accessor :metadata
+      # Name of the margin, which is displayed to customers, such as on invoices.
+      attr_accessor :name
+
+      def initialize(active: nil, expand: nil, metadata: nil, name: nil)
+        @active = active
+        @expand = expand
+        @metadata = metadata
+        @name = name
+      end
+    end
+
+    # Create a margin object to be used with invoices, invoice items, and invoice line items for a customer to represent a partner discount. A margin has a percent_off which is the percent that will be taken off the subtotal after all items and other discounts and promotions) of any invoices for a customer. Calculation of prorations do not include any partner margins applied on the original invoice item.
+    def create(params = {}, opts = {})
+      request(
+        method: :post,
+        path: "/v1/billing/margins",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieve a list of your margins.
+    def list(params = {}, opts = {})
+      request(
+        method: :get,
+        path: "/v1/billing/margins",
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Retrieve a margin object with the given ID.
+    def retrieve(margin, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/billing/margins/%<margin>s", { margin: CGI.escape(margin) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Update the specified margin object. Certain fields of the margin object are not editable.
+    def update(margin, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/billing/margins/%<margin>s", { margin: CGI.escape(margin) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/{rbi/stripe/services/source_transaction_service.rbi → lib/stripe/services/order_line_item_service.rb}

@@ -1,31 +1,35 @@
 # File generated from our OpenAPI spec
 # frozen_string_literal: true
 
-# typed: true
 module Stripe
-  class SourceTransactionService < StripeService
+  class OrderLineItemService < StripeService
     class ListParams < Stripe::RequestParams
       # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
-      sig { returns(T.nilable(String)) }
       attr_accessor :ending_before
       # Specifies which fields in the response should be expanded.
-      sig { returns(T.nilable(T::Array[String])) }
       attr_accessor :expand
       # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
-      sig { returns(T.nilable(Integer)) }
       attr_accessor :limit
       # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
-      sig { returns(T.nilable(String)) }
       attr_accessor :starting_after
-      sig {
-        params(ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), starting_after: T.nilable(String)).void
-       }
-      def initialize(ending_before: nil, expand: nil, limit: nil, starting_after: nil); end
+
+      def initialize(ending_before: nil, expand: nil, limit: nil, starting_after: nil)
+        @ending_before = ending_before
+        @expand = expand
+        @limit = limit
+        @starting_after = starting_after
+      end
+    end
+
+    # When retrieving an order, there is an includable line_items property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of line items.
+    def list(id, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/orders/%<id>s/line_items", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
     end
-    # List source transactions for a given source.
-    sig {
-      params(source: String, params: T.any(::Stripe::SourceTransactionService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
-     }
-    def list(source, params = {}, opts = {}); end
   end
-end
+end