stripe 19.2.0 → 19.3.0.pre.alpha.2

data/lib/stripe/services/invoice_service.rb

@@ -80,6 +80,17 @@ module Stripe
       )
     end
 
+    # Detaches a payment from the invoice, removing it from the list of payments
+    def detach_payment(invoice, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/invoices/%<invoice>s/detach_payment", { invoice: CGI.escape(invoice) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
     # Stripe automatically finalizes drafts before sending and attempting payment on invoices. However, if you'd like to finalize a draft invoice manually, you can do so using this method.
     def finalize_invoice(invoice, params = {}, opts = {})
       request(
@@ -167,6 +178,184 @@ module Stripe
       )
     end
 
+    # Serializes an Invoice add_lines request into a batch job JSONL line.
+    def serialize_batch_add_lines(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice create request into a batch job JSONL line.
+    def serialize_batch_create(params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice create_preview request into a batch job JSONL line.
+    def serialize_batch_create_preview(params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice delete request into a batch job JSONL line.
+    def serialize_batch_delete(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice finalize_invoice request into a batch job JSONL line.
+    def serialize_batch_finalize_invoice(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice mark_uncollectible request into a batch job JSONL line.
+    def serialize_batch_mark_uncollectible(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice pay request into a batch job JSONL line.
+    def serialize_batch_pay(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice remove_lines request into a batch job JSONL line.
+    def serialize_batch_remove_lines(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice send_invoice request into a batch job JSONL line.
+    def serialize_batch_send_invoice(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice update request into a batch job JSONL line.
+    def serialize_batch_update(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice update_lines request into a batch job JSONL line.
+    def serialize_batch_update_lines(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
+    # Serializes an Invoice void_invoice request into a batch job JSONL line.
+    def serialize_batch_void_invoice(invoice, params = {}, opts = {})
+      request_id = SecureRandom.uuid
+      stripe_version = opts[:stripe_version] || Stripe.api_version
+
+      request_body = {
+        id: request_id,
+        params: params,
+        stripe_version: stripe_version,
+      }
+      request_body[:path_params] = { invoice: invoice }
+      request_body[:context] = opts[:stripe_context] if opts[:stripe_context]
+      JSON.generate(request_body)
+    end
+
     # Draft invoices are fully editable. Once an invoice is [finalized](https://docs.stripe.com/docs/billing/invoices/workflow#finalized),
     # monetary values, as well as collection_method, become uneditable.
     #

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

@@ -0,0 +1,74 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class CreditUnderwritingRecordService < StripeService
+      # Update a CreditUnderwritingRecord object to correct mistakes.
+      def correct(credit_underwriting_record, params = {}, opts = {})
+        request(
+          method: :post,
+          path: format("/v1/issuing/credit_underwriting_records/%<credit_underwriting_record>s/correct", { credit_underwriting_record: CGI.escape(credit_underwriting_record) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Creates a CreditUnderwritingRecord object with information about a credit application submission.
+      def create_from_application(params = {}, opts = {})
+        request(
+          method: :post,
+          path: "/v1/issuing/credit_underwriting_records/create_from_application",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Creates a CreditUnderwritingRecord object from an underwriting decision coming from a proactive review of an existing accountholder.
+      def create_from_proactive_review(params = {}, opts = {})
+        request(
+          method: :post,
+          path: "/v1/issuing/credit_underwriting_records/create_from_proactive_review",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Retrieves a list of CreditUnderwritingRecord 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/credit_underwriting_records",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Update a CreditUnderwritingRecord object from a decision made on a credit application.
+      def report_decision(credit_underwriting_record, params = {}, opts = {})
+        request(
+          method: :post,
+          path: format("/v1/issuing/credit_underwriting_records/%<credit_underwriting_record>s/report_decision", { credit_underwriting_record: CGI.escape(credit_underwriting_record) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Retrieves a CreditUnderwritingRecord object.
+      def retrieve(credit_underwriting_record, params = {}, opts = {})
+        request(
+          method: :get,
+          path: format("/v1/issuing/credit_underwriting_records/%<credit_underwriting_record>s", { credit_underwriting_record: CGI.escape(credit_underwriting_record) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class DisputeSettlementDetailService < StripeService
+      # Returns a list of Issuing DisputeSettlementDetail 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/dispute_settlement_details",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Retrieves an Issuing DisputeSettlementDetail object.
+      def retrieve(dispute_settlement_detail, params = {}, opts = {})
+        request(
+          method: :get,
+          path: format("/v1/issuing/dispute_settlement_details/%<dispute_settlement_detail>s", { dispute_settlement_detail: CGI.escape(dispute_settlement_detail) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class FraudLiabilityDebitService < StripeService
+      # 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/program_service.rb

@@ -0,0 +1,52 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Issuing
+    class ProgramService < StripeService
+      # Create a Program object.
+      def create(params = {}, opts = {})
+        request(
+          method: :post,
+          path: "/v1/issuing/programs",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # List all of the programs the given Issuing user has access to.
+      def list(params = {}, opts = {})
+        request(
+          method: :get,
+          path: "/v1/issuing/programs",
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Retrieves the program specified by the given id.
+      def retrieve(program, params = {}, opts = {})
+        request(
+          method: :get,
+          path: format("/v1/issuing/programs/%<program>s", { program: CGI.escape(program) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+
+      # Updates a Program object.
+      def update(program, params = {}, opts = {})
+        request(
+          method: :post,
+          path: format("/v1/issuing/programs/%<program>s", { program: CGI.escape(program) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

data/lib/stripe/services/issuing_service.rb

@@ -3,16 +3,21 @@
 
 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, :programs, :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)
+      @programs = Stripe::Issuing::ProgramService.new(@requestor)
       @tokens = Stripe::Issuing::TokenService.new(@requestor)
       @transactions = Stripe::Issuing::TransactionService.new(@requestor)
     end

data/lib/stripe/services/mandate_service.rb

@@ -3,6 +3,11 @@
 
 module Stripe
   class MandateService < StripeService
+    # 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,50 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class MarginService < StripeService
+    # 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/lib/stripe/services/orchestration/payment_attempt_service.rb

@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module Orchestration
+    class PaymentAttemptService < StripeService
+      # Retrieves orchestration information for the given payment attempt record (e.g. return url).
+      def retrieve(payment_attempt_record, params = {}, opts = {})
+        request(
+          method: :get,
+          path: format("/v1/orchestration/payment_attempts/%<payment_attempt_record>s", { payment_attempt_record: CGI.escape(payment_attempt_record) }),
+          params: params,
+          opts: opts,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

data/lib/stripe/services/orchestration_service.rb

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class OrchestrationService < StripeService
+    attr_reader :payment_attempts
+
+    def initialize(requestor)
+      super
+      @payment_attempts = Stripe::Orchestration::PaymentAttemptService.new(@requestor)
+    end
+  end
+end

data/lib/stripe/services/order_service.rb

@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  class OrderService < StripeService
+    # Creates a new open order object.
+    def create(params = {}, opts = {})
+      params = ::Stripe::OrderCreateParams.coerce_params(params) unless params.is_a?(Stripe::RequestParams)
+
+      request(method: :post, path: "/v1/orders", params: params, opts: opts, base_address: :api)
+    end
+
+    # Returns a list of your orders. The orders are returned sorted by creation date, with the most recently created orders appearing first.
+    def list(params = {}, opts = {})
+      request(method: :get, path: "/v1/orders", params: params, opts: opts, base_address: :api)
+    end
+
+    # Retrieves the details of an existing order. Supply the unique order ID from either an order creation request or the order list, and Stripe will return the corresponding order information.
+    def retrieve(id, params = {}, opts = {})
+      request(
+        method: :get,
+        path: format("/v1/orders/%<id>s", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Submitting an Order transitions the status to processing and creates a PaymentIntent object so the order can be paid. If the Order has an amount_total of 0, no PaymentIntent object will be created. Once the order is submitted, its contents cannot be changed, unless the [reopen](https://docs.stripe.com/api#reopen_order) method is called.
+    def submit(id, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/orders/%<id>s/submit", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Updates the specific order by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
+    def update(id, params = {}, opts = {})
+      params = ::Stripe::OrderUpdateParams.coerce_params(params) unless params.is_a?(Stripe::RequestParams)
+
+      request(
+        method: :post,
+        path: format("/v1/orders/%<id>s", { id: CGI.escape(id) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+  end
+end

data/lib/stripe/services/payment_attempt_record_service.rb

@@ -14,6 +14,83 @@ module Stripe
       )
     end
 
+    # Report that the specified Payment Attempt Record was authenticated.
+    def report_authenticated(payment_attempt_record, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_attempt_records/%<payment_attempt_record>s/report_authenticated", { payment_attempt_record: CGI.escape(payment_attempt_record) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report that the specified Payment Attempt Record was authorized.
+    def report_authorized(payment_attempt_record, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_attempt_records/%<payment_attempt_record>s/report_authorized", { payment_attempt_record: CGI.escape(payment_attempt_record) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report that the specified Payment Attempt Record was canceled.
+    def report_canceled(payment_attempt_record, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_attempt_records/%<payment_attempt_record>s/report_canceled", { payment_attempt_record: CGI.escape(payment_attempt_record) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report that the specified Payment Attempt Record failed.
+    def report_failed(payment_attempt_record, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_attempt_records/%<payment_attempt_record>s/report_failed", { payment_attempt_record: CGI.escape(payment_attempt_record) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report that the specified Payment Attempt Record was guaranteed.
+    def report_guaranteed(payment_attempt_record, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_attempt_records/%<payment_attempt_record>s/report_guaranteed", { payment_attempt_record: CGI.escape(payment_attempt_record) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report informational updates on the specified Payment Attempt Record.
+    def report_informational(payment_attempt_record, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_attempt_records/%<payment_attempt_record>s/report_informational", { payment_attempt_record: CGI.escape(payment_attempt_record) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
+    # Report that the specified Payment Attempt Record was refunded.
+    def report_refund(payment_attempt_record, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/payment_attempt_records/%<payment_attempt_record>s/report_refund", { payment_attempt_record: CGI.escape(payment_attempt_record) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
     # Retrieves a Payment Attempt Record with the given ID
     def retrieve(id, params = {}, opts = {})
       request(