mollie-ruby-sdk 0.0.1.pre.alpha.9

data/lib/mollie/models/components/list_payment_response.rb

@@ -0,0 +1,614 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module Mollie
+  module Models
+    module Components
+
+      class ListPaymentResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Indicates the response contains a payment object. Will always contain the string `payment` for this endpoint.
+        field(
+          :resource,
+          ::String,
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("resource"), required: true}}
+        )
+        # The identifier uniquely referring to this payment. Mollie assigns this identifier at payment creation time. Mollie
+        # will always refer to the payment by this ID. Example: `tr_5B8cwPMGnU6qLbRvo7qEZo`.
+        field :id, ::String, {'format_json': {'letter_case': ::Mollie::Utils.field_name("id"), required: true}}
+        # Whether this entity was created in live mode or in test mode.
+        field(
+          :mode,
+          Models::Components::Mode,
+          {
+            'format_json': {
+              'letter_case': ::Mollie::Utils.field_name("mode"),
+              required: true,
+              'decoder': ::Mollie::Utils.open_enum_from_string(Models::Components::Mode, false)
+            }
+          }
+        )
+        # The description of the payment will be shown to your customer on their card or bank statement when possible.
+        # We truncate the description automatically according to the limits of the used payment method. The description is
+        # also visible in any exports you generate.
+        #
+        # We recommend you use a unique identifier so that you can always link the payment to the order in your back office.
+        # This is particularly useful for bookkeeping.
+        #
+        # The maximum length of the description field differs per payment method, with the absolute maximum being 255
+        # characters. The API will not reject strings longer than the maximum length but it will truncate them to fit.
+        field(
+          :description,
+          ::String,
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("description"), required: true}}
+        )
+        # In v2 endpoints, monetary amounts are represented as objects with a `currency` and `value` field.
+        field(
+          :amount,
+          Models::Components::Amount,
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("amount"), required: true}}
+        )
+
+        field(
+          :sequence_type,
+          Models::Components::SequenceTypeResponse,
+          {
+            'format_json': {
+              'letter_case': ::Mollie::Utils.field_name("sequenceType"),
+              required: true,
+              'decoder': ::Mollie::Utils.open_enum_from_string(Models::Components::SequenceTypeResponse, false)
+            }
+          }
+        )
+        # The identifier referring to the [profile](get-profile) this entity belongs to.
+        #
+        # Most API credentials are linked to a single profile. In these cases the `profileId` can be omitted in the creation
+        # request. For organization-level credentials such as OAuth access tokens however, the `profileId` parameter is
+        # required.
+        field(
+          :profile_id,
+          ::String,
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("profileId"), required: true}}
+        )
+
+        field(
+          :status,
+          Models::Components::ListPaymentResponseStatus,
+          {
+            'format_json': {
+              'letter_case': ::Mollie::Utils.field_name("status"),
+              required: true,
+              'decoder': ::Mollie::Utils.open_enum_from_string(Models::Components::ListPaymentResponseStatus, false)
+            }
+          }
+        )
+        # The entity's date and time of creation, in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+        field(
+          :created_at,
+          ::String,
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("createdAt"), required: true}}
+        )
+        # An object with several relevant URLs. Every URL object will contain an `href` and a `type` field.
+        field(
+          :links,
+          Models::Components::ListPaymentResponseLinks,
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("_links"), required: true}}
+        )
+
+        field(
+          :amount_refunded,
+          Crystalline::Nilable.new(Models::Components::ListPaymentResponseAmountRefunded),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("amountRefunded")}}
+        )
+
+        field(
+          :amount_remaining,
+          Crystalline::Nilable.new(Models::Components::ListPaymentResponseAmountRemaining),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("amountRemaining")}}
+        )
+
+        field(
+          :amount_captured,
+          Crystalline::Nilable.new(Models::Components::ListPaymentResponseAmountCaptured),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("amountCaptured")}}
+        )
+
+        field(
+          :amount_charged_back,
+          Crystalline::Nilable.new(Models::Components::ListPaymentResponseAmountChargedBack),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("amountChargedBack")}}
+        )
+        # The customer's billing address details. We advise to provide these details to improve fraud protection and
+        # conversion.
+        #
+        # Should include `email` or a valid postal address consisting of `streetAndNumber`, `postalCode`, `city` and
+        # `country`.
+        #
+        # Required for payment method `alma`, `in3`, `klarna`, `billie`, `billink` and `riverty`.
+        field(
+          :billing_address,
+          Crystalline::Nilable.new(Models::Components::ListPaymentResponseBillingAddress),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("billingAddress")}}
+        )
+
+        field(
+          :shipping_address,
+          Crystalline::Nilable.new(Models::Components::PaymentAddress),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("shippingAddress")}}
+        )
+
+        field(
+          :customer_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("customerId")}}
+        )
+        # The URL your customer will be redirected to after the payment process.
+        #
+        # It could make sense for the redirectUrl to contain a unique identifier – like your order ID – so you can show the
+        # right page referencing the order when your customer returns.
+        #
+        # The parameter is normally required, but can be omitted for recurring payments (`sequenceType: recurring`) and for
+        # Apple Pay payments with an `applePayPaymentToken`.
+        field(
+          :redirect_url,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("redirectUrl")}}
+        )
+        # The URL your customer will be redirected to when the customer explicitly cancels the payment. If this URL is not
+        # provided, the customer will be redirected to the `redirectUrl` instead — see above.
+        #
+        # Mollie will always give you status updates via webhooks, including for the canceled status. This parameter is
+        # therefore entirely optional, but can be useful when implementing a dedicated customer-facing flow to handle
+        # payment cancellations.
+        field(
+          :cancel_url,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("cancelUrl")}}
+        )
+        # The webhook URL where we will send payment status updates to.
+        #
+        # The webhookUrl is optional, but without a webhook you will miss out on important status changes to your payment.
+        #
+        # The webhookUrl must be reachable from Mollie's point of view, so you cannot use `localhost`. If you want to use
+        # webhook during development on `localhost`, you must use a tool like ngrok to have the webhooks delivered to your
+        # local machine.
+        field(
+          :webhook_url,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("webhookUrl")}}
+        )
+        # Optionally provide the order lines for the payment. Each line contains details such as a description of the item
+        # ordered and its price.
+        #
+        # All lines must have the same currency as the payment.
+        #
+        # Required for payment methods `billie`, `billink`, `in3`, `klarna`, `riverty` and `voucher`.
+        field(
+          :lines,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Components::ListPaymentResponseLine)),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("lines")}}
+        )
+        # Sets the language for customer-facing content and communications.
+        field(
+          :locale,
+          Crystalline::Nilable.new(Models::Components::LocaleResponse),
+          {
+            'format_json': {
+              'letter_case': ::Mollie::Utils.field_name("locale"),
+              'decoder': ::Mollie::Utils.open_enum_from_string(Models::Components::LocaleResponse, true)
+            }
+          }
+        )
+        # This optional field contains your customer's ISO 3166-1 alpha-2 country code, detected by us during checkout. This
+        # field is omitted if the country code was not detected.
+        field(
+          :country_code,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("countryCode")}}
+        )
+
+        field(
+          :method,
+          Crystalline::Nilable.new(Models::Components::MethodResponse),
+          {
+            'format_json': {
+              'letter_case': ::Mollie::Utils.field_name("method"),
+              'decoder': ::Mollie::Utils.open_enum_from_string(Models::Components::MethodResponse, true)
+            }
+          }
+        )
+        # For digital goods in most jurisdictions, you must apply the VAT rate from your customer's country. Choose the VAT
+        # rates you have used for the order to ensure your customer's country matches the VAT country.
+        #
+        # Use this parameter to restrict the payment methods available to your customer to those from a single country.
+        #
+        # If available, the credit card method will still be offered, but only cards from the allowed country are accepted.
+        #
+        # The field expects a country code in ISO 3166-1 alpha-2 format, for example `NL`.
+        field(
+          :restrict_payment_methods_to_country,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("restrictPaymentMethodsToCountry")}}
+        )
+        # Provide any data you like, for example a string or a JSON object. We will save the data alongside the entity. Whenever
+        # you fetch the entity with our API, we will also include the metadata. You can use up to approximately 1kB.
+        field(
+          :metadata,
+          Crystalline::Nilable.new(
+            Crystalline::Union.new(
+              ::String,
+              ::Float,
+              Crystalline::Hash.new(::Symbol, ::Object),
+              Crystalline::Array.new(::String)
+            )
+          ),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("metadata")}}
+        )
+        # Indicate if the funds should be captured immediately or if you want to [place a hold](https://docs.mollie.com/docs/place-a-hold-for-a-payment#/)
+        # and capture at a later time.
+        #
+        # This field needs to be set to `manual` for method `riverty`.
+        field(
+          :capture_mode,
+          Crystalline::Nilable.new(Models::Components::CaptureModeResponse),
+          {
+            'format_json': {
+              'letter_case': ::Mollie::Utils.field_name("captureMode"),
+              'decoder': ::Mollie::Utils.open_enum_from_string(Models::Components::CaptureModeResponse, true)
+            }
+          }
+        )
+        # **Only relevant if you wish to manage authorization and capturing separately.**
+        #
+        # Some payment methods allow placing a hold on the card or bank account. This hold or 'authorization' can then at a
+        # later point either be 'captured' or canceled.
+        #
+        # By default, we charge the customer's card or bank account immediately when they complete the payment. If you set a
+        # capture delay however, we will delay the automatic capturing of the payment for the specified amount of time. For
+        # example `8 hours` or `2 days`.
+        #
+        # To schedule an automatic capture, the `captureMode` must be set to `automatic`.
+        #
+        # The maximum delay is 7 days (168 hours).
+        #
+        # Possible values: `... hours` `... days`
+        field(
+          :capture_delay,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("captureDelay")}}
+        )
+        # Indicates the date before which the payment needs to be captured, in ISO 8601 format. From this date onwards we
+        # can no longer guarantee a successful capture. The parameter is omitted if the payment is not authorized (yet).
+        field(
+          :capture_before,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("captureBefore")}}
+        )
+        # With Mollie Connect you can charge fees on payments that your app is processing on behalf of other Mollie
+        # merchants.
+        #
+        # If you use OAuth to create payments on a connected merchant's account, you can charge a fee using this
+        # `applicationFee` parameter. If the payment succeeds, the fee will be deducted from the merchant's balance and sent
+        # to your own account balance.
+        #
+        # If instead you want to split a payment on your own account between yourself and a connected merchant, refer to the
+        # `routing` parameter.
+        field(
+          :application_fee,
+          Crystalline::Nilable.new(Models::Components::ListPaymentResponseApplicationFee),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("applicationFee")}}
+        )
+        # *This functionality is not enabled by default. Reach out to our partner management team if you wish to use it.*
+        #
+        # With Mollie Connect you can charge fees on payments that your app is processing on behalf of other Mollie
+        # merchants.
+        #
+        # If you create payments on your own account that you want to split between yourself and one or more connected
+        # merchants, you can use this `routing` parameter to route the payment accordingly.
+        #
+        # The `routing` parameter should contain an array of objects, with each object describing the destination for a
+        # specific portion of the payment.
+        #
+        # It is not necessary to indicate in the array which portion goes to yourself. After all portions of the total
+        # payment amount have been routed, the amount left will be routed to the current organization automatically.
+        #
+        # If instead you use OAuth to create payments on a connected merchant's account, refer to the `applicationFee`
+        # parameter.
+        field(
+          :routing,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Components::EntityPaymentRouteResponse)),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("routing")}}
+        )
+        # If the payment was automatically created via a subscription, the ID of the [subscription](get-subscription) will
+        # be added to the response.
+        field(
+          :subscription_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("subscriptionId")}}
+        )
+        # **Only relevant for recurring payments and stored cards.**
+        #
+        # When creating recurring or stored cards payments, the ID of a specific [mandate](get-mandate) can be supplied to indicate which of
+        # the customer's accounts should be debited.
+        field(
+          :mandate_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("mandateId")}}
+        )
+        # The identifier referring to the [settlement](get-settlement) this payment was settled with.
+        field(
+          :settlement_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("settlementId")}}
+        )
+        # If the payment was created for an [order](get-order), the ID of that order will be part of the response.
+        field(
+          :order_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("orderId")}}
+        )
+        # This object offers details about the status of a payment. Currently it is only available for point-of-sale
+        # payments.
+        #
+        # You can find more information about the possible values of this object on
+        # [this page](status-reasons).**
+        field(
+          :status_reason,
+          Crystalline::Nilable.new(Models::Components::StatusReason),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("statusReason")}}
+        )
+        # Whether the payment can be canceled. This parameter is omitted if the payment reaches a final state.
+        field(
+          :is_cancelable,
+          Crystalline::Nilable.new(Crystalline::Boolean.new),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("isCancelable")}}
+        )
+        # An object containing payment details collected during the payment process. For example, details may include the
+        # customer's card or bank details and a payment reference. For the full list of details, please refer to the
+        # [method-specific parameters](extra-payment-parameters) guide.
+        field(
+          :details,
+          Crystalline::Nilable.new(Models::Components::PaymentDetails),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("details")}}
+        )
+        # The date and time the payment became authorized, in ISO 8601 format. This parameter is omitted if the payment is
+        # not authorized (yet).
+        field(
+          :authorized_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("authorizedAt")}}
+        )
+        # The date and time the payment became paid, in ISO 8601 format. This parameter is omitted if the payment is not
+        # completed (yet).
+        field(
+          :paid_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("paidAt")}}
+        )
+        # The date and time the payment was canceled, in ISO 8601 format. This parameter is omitted if the payment is not
+        # canceled (yet).
+        field(
+          :canceled_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("canceledAt")}}
+        )
+        # The date and time the payment will expire, in ISO 8601 format. This parameter is omitted if the payment can no
+        # longer expire.
+        field(
+          :expires_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("expiresAt")}}
+        )
+        # The date and time the payment was expired, in ISO 8601 format. This parameter is omitted if the payment did not
+        # expire (yet).
+        field(
+          :expired_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("expiredAt")}}
+        )
+        # The date and time the payment failed, in ISO 8601 format. This parameter is omitted if the payment did not fail
+        # (yet).
+        field(
+          :failed_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::Mollie::Utils.field_name("failedAt")}}
+        )
+
+        sig {
+          params(
+            resource: ::String,
+            id: ::String,
+            mode: Models::Components::Mode,
+            description: ::String,
+            amount: Models::Components::Amount,
+            sequence_type: Models::Components::SequenceTypeResponse,
+            profile_id: ::String,
+            status: Models::Components::ListPaymentResponseStatus,
+            created_at: ::String,
+            links: Models::Components::ListPaymentResponseLinks,
+            amount_refunded: T.nilable(Models::Components::ListPaymentResponseAmountRefunded),
+            amount_remaining: T.nilable(Models::Components::ListPaymentResponseAmountRemaining),
+            amount_captured: T.nilable(Models::Components::ListPaymentResponseAmountCaptured),
+            amount_charged_back: T.nilable(Models::Components::ListPaymentResponseAmountChargedBack),
+            billing_address: T.nilable(Models::Components::ListPaymentResponseBillingAddress),
+            shipping_address: T.nilable(Models::Components::PaymentAddress),
+            customer_id: T.nilable(::String),
+            redirect_url: T.nilable(::String),
+            cancel_url: T.nilable(::String),
+            webhook_url: T.nilable(::String),
+            lines: T.nilable(T::Array[Models::Components::ListPaymentResponseLine]),
+            locale: T.nilable(Models::Components::LocaleResponse),
+            country_code: T.nilable(::String),
+            method: T.nilable(Models::Components::MethodResponse),
+            restrict_payment_methods_to_country: T.nilable(::String),
+            metadata: T.nilable(T.any(::String, ::Float, T::Hash[::Symbol, ::Object], T::Array[::String])),
+            capture_mode: T.nilable(Models::Components::CaptureModeResponse),
+            capture_delay: T.nilable(::String),
+            capture_before: T.nilable(::String),
+            application_fee: T.nilable(Models::Components::ListPaymentResponseApplicationFee),
+            routing: T.nilable(T::Array[Models::Components::EntityPaymentRouteResponse]),
+            subscription_id: T.nilable(::String),
+            mandate_id: T.nilable(::String),
+            settlement_id: T.nilable(::String),
+            order_id: T.nilable(::String),
+            status_reason: T.nilable(Models::Components::StatusReason),
+            is_cancelable: T.nilable(T::Boolean),
+            details: T.nilable(Models::Components::PaymentDetails),
+            authorized_at: T.nilable(::String),
+            paid_at: T.nilable(::String),
+            canceled_at: T.nilable(::String),
+            expires_at: T.nilable(::String),
+            expired_at: T.nilable(::String),
+            failed_at: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          resource:,
+          id:,
+          mode:,
+          description:,
+          amount:,
+          sequence_type:,
+          profile_id:,
+          status:,
+          created_at:,
+          links:,
+          amount_refunded: nil,
+          amount_remaining: nil,
+          amount_captured: nil,
+          amount_charged_back: nil,
+          billing_address: nil,
+          shipping_address: nil,
+          customer_id: nil,
+          redirect_url: nil,
+          cancel_url: nil,
+          webhook_url: nil,
+          lines: nil,
+          locale: nil,
+          country_code: nil,
+          method: nil,
+          restrict_payment_methods_to_country: nil,
+          metadata: nil,
+          capture_mode: nil,
+          capture_delay: nil,
+          capture_before: nil,
+          application_fee: nil,
+          routing: nil,
+          subscription_id: nil,
+          mandate_id: nil,
+          settlement_id: nil,
+          order_id: nil,
+          status_reason: nil,
+          is_cancelable: nil,
+          details: nil,
+          authorized_at: nil,
+          paid_at: nil,
+          canceled_at: nil,
+          expires_at: nil,
+          expired_at: nil,
+          failed_at: nil
+        )
+          @resource = resource
+          @id = id
+          @mode = mode
+          @description = description
+          @amount = amount
+          @sequence_type = sequence_type
+          @profile_id = profile_id
+          @status = status
+          @created_at = created_at
+          @links = links
+          @amount_refunded = amount_refunded
+          @amount_remaining = amount_remaining
+          @amount_captured = amount_captured
+          @amount_charged_back = amount_charged_back
+          @billing_address = billing_address
+          @shipping_address = shipping_address
+          @customer_id = customer_id
+          @redirect_url = redirect_url
+          @cancel_url = cancel_url
+          @webhook_url = webhook_url
+          @lines = lines
+          @locale = locale
+          @country_code = country_code
+          @method = method
+          @restrict_payment_methods_to_country = restrict_payment_methods_to_country
+          @metadata = metadata
+          @capture_mode = capture_mode
+          @capture_delay = capture_delay
+          @capture_before = capture_before
+          @application_fee = application_fee
+          @routing = routing
+          @subscription_id = subscription_id
+          @mandate_id = mandate_id
+          @settlement_id = settlement_id
+          @order_id = order_id
+          @status_reason = status_reason
+          @is_cancelable = is_cancelable
+          @details = details
+          @authorized_at = authorized_at
+          @paid_at = paid_at
+          @canceled_at = canceled_at
+          @expires_at = expires_at
+          @expired_at = expired_at
+          @failed_at = failed_at
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @resource == other.resource
+          return false unless @id == other.id
+          return false unless @mode == other.mode
+          return false unless @description == other.description
+          return false unless @amount == other.amount
+          return false unless @sequence_type == other.sequence_type
+          return false unless @profile_id == other.profile_id
+          return false unless @status == other.status
+          return false unless @created_at == other.created_at
+          return false unless @links == other.links
+          return false unless @amount_refunded == other.amount_refunded
+          return false unless @amount_remaining == other.amount_remaining
+          return false unless @amount_captured == other.amount_captured
+          return false unless @amount_charged_back == other.amount_charged_back
+          return false unless @billing_address == other.billing_address
+          return false unless @shipping_address == other.shipping_address
+          return false unless @customer_id == other.customer_id
+          return false unless @redirect_url == other.redirect_url
+          return false unless @cancel_url == other.cancel_url
+          return false unless @webhook_url == other.webhook_url
+          return false unless @lines == other.lines
+          return false unless @locale == other.locale
+          return false unless @country_code == other.country_code
+          return false unless @method == other.method
+          return false unless @restrict_payment_methods_to_country == other.restrict_payment_methods_to_country
+          return false unless @metadata == other.metadata
+          return false unless @capture_mode == other.capture_mode
+          return false unless @capture_delay == other.capture_delay
+          return false unless @capture_before == other.capture_before
+          return false unless @application_fee == other.application_fee
+          return false unless @routing == other.routing
+          return false unless @subscription_id == other.subscription_id
+          return false unless @mandate_id == other.mandate_id
+          return false unless @settlement_id == other.settlement_id
+          return false unless @order_id == other.order_id
+          return false unless @status_reason == other.status_reason
+          return false unless @is_cancelable == other.is_cancelable
+          return false unless @details == other.details
+          return false unless @authorized_at == other.authorized_at
+          return false unless @paid_at == other.paid_at
+          return false unless @canceled_at == other.canceled_at
+          return false unless @expires_at == other.expires_at
+          return false unless @expired_at == other.expired_at
+          return false unless @failed_at == other.failed_at
+          true
+        end
+      end
+    end
+  end
+end