stripe 14.0.0 → 14.1.0.pre.beta.1

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(requestor)
       @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/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