straddle 0.4.0 → 1.0.0

data/rbi/straddle/models/charge_configuration.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class ChargeConfiguration < Straddle::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Straddle::ChargeConfiguration, Straddle::Internal::AnyHash)
+        end
+
+      # Balance check mode to use before processing the charge.
+      sig { returns(Straddle::BalanceCheckMode::OrSymbol) }
+      attr_accessor :balance_check
+
+      # Whether to place the charge on hold automatically after creation.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :auto_hold
+
+      # Reason for placing the charge on hold automatically.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :auto_hold_message
+
+      # Payment will simulate processing if not Standard.
+      sig { returns(T.nilable(Straddle::SimulatedPaymentOutcome::OrSymbol)) }
+      attr_reader :sandbox_outcome
+
+      sig do
+        params(
+          sandbox_outcome: Straddle::SimulatedPaymentOutcome::OrSymbol
+        ).void
+      end
+      attr_writer :sandbox_outcome
+
+      sig do
+        params(
+          balance_check: Straddle::BalanceCheckMode::OrSymbol,
+          auto_hold: T.nilable(T::Boolean),
+          auto_hold_message: T.nilable(String),
+          sandbox_outcome: Straddle::SimulatedPaymentOutcome::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Balance check mode to use before processing the charge.
+        balance_check:,
+        # Whether to place the charge on hold automatically after creation.
+        auto_hold: nil,
+        # Reason for placing the charge on hold automatically.
+        auto_hold_message: nil,
+        # Payment will simulate processing if not Standard.
+        sandbox_outcome: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            balance_check: Straddle::BalanceCheckMode::OrSymbol,
+            auto_hold: T.nilable(T::Boolean),
+            auto_hold_message: T.nilable(String),
+            sandbox_outcome: Straddle::SimulatedPaymentOutcome::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/straddle/models/charge_create_params.rbi

@@ -11,74 +11,73 @@ module Straddle
           T.any(Straddle::ChargeCreateParams, Straddle::Internal::AnyHash)
         end
 
-      # The amount of the charge in cents.
+      # Amount in cents.
       sig { returns(Integer) }
       attr_accessor :amount
 
-      sig { returns(Straddle::ChargeCreateParams::Config) }
+      sig { returns(Straddle::ChargeConfiguration) }
       attr_reader :config
 
-      sig { params(config: Straddle::ChargeCreateParams::Config::OrHash).void }
+      sig { params(config: Straddle::ChargeConfiguration::OrHash).void }
       attr_writer :config
 
-      # The channel or mechanism through which the payment was authorized. Use
-      # `internet` for payments made online or through a mobile app and `signed` for
-      # signed agreements where there is a consent form or contract. Use `signed` for
-      # PDF signatures.
-      sig { returns(Straddle::ChargeCreateParams::ConsentType::OrSymbol) }
+      # How the customer authorized the charge. `internet` covers online and mobile
+      # authorization. `signed` covers written or PDF-signed agreements.
+      sig { returns(Straddle::ConsentType::OrSymbol) }
       attr_accessor :consent_type
 
-      # The currency of the charge. Only USD is supported.
+      # Currency code. Only `USD` is supported.
       sig { returns(String) }
       attr_accessor :currency
 
-      # An arbitrary description for the charge.
+      # Description shown on the customer's bank statement where supported.
       sig { returns(T.nilable(String)) }
       attr_accessor :description
 
-      sig { returns(Straddle::DeviceInfoV1) }
+      sig { returns(Straddle::PaymentDevice) }
       attr_reader :device
 
-      sig { params(device: Straddle::DeviceInfoV1::OrHash).void }
+      sig { params(device: Straddle::PaymentDevice::OrHash).void }
       attr_writer :device
 
-      # Unique identifier for the charge in your database. This value must be unique
-      # across all charges.
+      # Your unique identifier for the charge. Must be unique across charges.
       sig { returns(String) }
       attr_accessor :external_id
 
-      # Value of the `paykey` used for the charge.
+      # The paykey token that identifies the customer's bank account.
       sig { returns(String) }
       attr_accessor :paykey
 
-      # The desired date on which the payment should be occur. For charges, this means
-      # the date you want the customer to be debited on.
+      # Date when Straddle submits the charge for processing.
       sig { returns(Date) }
       attr_accessor :payment_date
 
-      # Up to 20 additional user-defined key-value pairs. Useful for storing additional
-      # information about the charge in a structured format.
+      # Up to 20 user-defined string key-value pairs.
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
       attr_accessor :metadata
 
+      # Optional client-generated identifier for tracing a series of related requests.
       sig { returns(T.nilable(String)) }
       attr_reader :correlation_id
 
       sig { params(correlation_id: String).void }
       attr_writer :correlation_id
 
+      # Optional client-generated key for an idempotent request.
       sig { returns(T.nilable(String)) }
       attr_reader :idempotency_key
 
       sig { params(idempotency_key: String).void }
       attr_writer :idempotency_key
 
+      # Optional client-generated identifier for tracing one request.
       sig { returns(T.nilable(String)) }
       attr_reader :request_id
 
       sig { params(request_id: String).void }
       attr_writer :request_id
 
+      # For platform requests, the embedded account UUID that sets the request scope.
       sig { returns(T.nilable(String)) }
       attr_reader :straddle_account_id
 
@@ -88,11 +87,11 @@ module Straddle
       sig do
         params(
           amount: Integer,
-          config: Straddle::ChargeCreateParams::Config::OrHash,
-          consent_type: Straddle::ChargeCreateParams::ConsentType::OrSymbol,
+          config: Straddle::ChargeConfiguration::OrHash,
+          consent_type: Straddle::ConsentType::OrSymbol,
           currency: String,
           description: T.nilable(String),
-          device: Straddle::DeviceInfoV1::OrHash,
+          device: Straddle::PaymentDevice::OrHash,
           external_id: String,
           paykey: String,
           payment_date: Date,
@@ -105,33 +104,32 @@ module Straddle
         ).returns(T.attached_class)
       end
       def self.new(
-        # The amount of the charge in cents.
+        # Amount in cents.
         amount:,
         config:,
-        # The channel or mechanism through which the payment was authorized. Use
-        # `internet` for payments made online or through a mobile app and `signed` for
-        # signed agreements where there is a consent form or contract. Use `signed` for
-        # PDF signatures.
+        # How the customer authorized the charge. `internet` covers online and mobile
+        # authorization. `signed` covers written or PDF-signed agreements.
         consent_type:,
-        # The currency of the charge. Only USD is supported.
+        # Currency code. Only `USD` is supported.
         currency:,
-        # An arbitrary description for the charge.
+        # Description shown on the customer's bank statement where supported.
         description:,
         device:,
-        # Unique identifier for the charge in your database. This value must be unique
-        # across all charges.
+        # Your unique identifier for the charge. Must be unique across charges.
         external_id:,
-        # Value of the `paykey` used for the charge.
+        # The paykey token that identifies the customer's bank account.
         paykey:,
-        # The desired date on which the payment should be occur. For charges, this means
-        # the date you want the customer to be debited on.
+        # Date when Straddle submits the charge for processing.
         payment_date:,
-        # Up to 20 additional user-defined key-value pairs. Useful for storing additional
-        # information about the charge in a structured format.
+        # Up to 20 user-defined string key-value pairs.
         metadata: nil,
+        # Optional client-generated identifier for tracing a series of related requests.
         correlation_id: nil,
+        # Optional client-generated key for an idempotent request.
         idempotency_key: nil,
+        # Optional client-generated identifier for tracing one request.
         request_id: nil,
+        # For platform requests, the embedded account UUID that sets the request scope.
         straddle_account_id: nil,
         request_options: {}
       )
@@ -141,11 +139,11 @@ module Straddle
         override.returns(
           {
             amount: Integer,
-            config: Straddle::ChargeCreateParams::Config,
-            consent_type: Straddle::ChargeCreateParams::ConsentType::OrSymbol,
+            config: Straddle::ChargeConfiguration,
+            consent_type: Straddle::ConsentType::OrSymbol,
             currency: String,
             description: T.nilable(String),
-            device: Straddle::DeviceInfoV1,
+            device: Straddle::PaymentDevice,
             external_id: String,
             paykey: String,
             payment_date: Date,
@@ -160,235 +158,6 @@ module Straddle
       end
       def to_hash
       end
-
-      class Config < Straddle::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Straddle::ChargeCreateParams::Config,
-              Straddle::Internal::AnyHash
-            )
-          end
-
-        # Defines whether to check the customer's balance before processing the charge.
-        sig do
-          returns(Straddle::ChargeCreateParams::Config::BalanceCheck::OrSymbol)
-        end
-        attr_accessor :balance_check
-
-        # Defines whether to automatically place this charge on hold after being created.
-        sig { returns(T.nilable(T::Boolean)) }
-        attr_accessor :auto_hold
-
-        # The reason the charge is being automatically held on creation.
-        sig { returns(T.nilable(String)) }
-        attr_accessor :auto_hold_message
-
-        # Payment will simulate processing if not Standard.
-        sig do
-          returns(
-            T.nilable(
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::OrSymbol
-            )
-          )
-        end
-        attr_reader :sandbox_outcome
-
-        sig do
-          params(
-            sandbox_outcome:
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::OrSymbol
-          ).void
-        end
-        attr_writer :sandbox_outcome
-
-        sig do
-          params(
-            balance_check:
-              Straddle::ChargeCreateParams::Config::BalanceCheck::OrSymbol,
-            auto_hold: T.nilable(T::Boolean),
-            auto_hold_message: T.nilable(String),
-            sandbox_outcome:
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::OrSymbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Defines whether to check the customer's balance before processing the charge.
-          balance_check:,
-          # Defines whether to automatically place this charge on hold after being created.
-          auto_hold: nil,
-          # The reason the charge is being automatically held on creation.
-          auto_hold_message: nil,
-          # Payment will simulate processing if not Standard.
-          sandbox_outcome: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              balance_check:
-                Straddle::ChargeCreateParams::Config::BalanceCheck::OrSymbol,
-              auto_hold: T.nilable(T::Boolean),
-              auto_hold_message: T.nilable(String),
-              sandbox_outcome:
-                Straddle::ChargeCreateParams::Config::SandboxOutcome::OrSymbol
-            }
-          )
-        end
-        def to_hash
-        end
-
-        # Defines whether to check the customer's balance before processing the charge.
-        module BalanceCheck
-          extend Straddle::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, Straddle::ChargeCreateParams::Config::BalanceCheck)
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          REQUIRED =
-            T.let(
-              :required,
-              Straddle::ChargeCreateParams::Config::BalanceCheck::TaggedSymbol
-            )
-          ENABLED =
-            T.let(
-              :enabled,
-              Straddle::ChargeCreateParams::Config::BalanceCheck::TaggedSymbol
-            )
-          DISABLED =
-            T.let(
-              :disabled,
-              Straddle::ChargeCreateParams::Config::BalanceCheck::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                Straddle::ChargeCreateParams::Config::BalanceCheck::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-
-        # Payment will simulate processing if not Standard.
-        module SandboxOutcome
-          extend Straddle::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(
-                Symbol,
-                Straddle::ChargeCreateParams::Config::SandboxOutcome
-              )
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          STANDARD =
-            T.let(
-              :standard,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          PAID =
-            T.let(
-              :paid,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          ON_HOLD_DAILY_LIMIT =
-            T.let(
-              :on_hold_daily_limit,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          CANCELLED_FOR_FRAUD_RISK =
-            T.let(
-              :cancelled_for_fraud_risk,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          CANCELLED_FOR_BALANCE_CHECK =
-            T.let(
-              :cancelled_for_balance_check,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          FAILED_INSUFFICIENT_FUNDS =
-            T.let(
-              :failed_insufficient_funds,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          REVERSED_INSUFFICIENT_FUNDS =
-            T.let(
-              :reversed_insufficient_funds,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          FAILED_CUSTOMER_DISPUTE =
-            T.let(
-              :failed_customer_dispute,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          REVERSED_CUSTOMER_DISPUTE =
-            T.let(
-              :reversed_customer_dispute,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          FAILED_CLOSED_BANK_ACCOUNT =
-            T.let(
-              :failed_closed_bank_account,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-          REVERSED_CLOSED_BANK_ACCOUNT =
-            T.let(
-              :reversed_closed_bank_account,
-              Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                Straddle::ChargeCreateParams::Config::SandboxOutcome::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-      end
-
-      # The channel or mechanism through which the payment was authorized. Use
-      # `internet` for payments made online or through a mobile app and `signed` for
-      # signed agreements where there is a consent form or contract. Use `signed` for
-      # PDF signatures.
-      module ConsentType
-        extend Straddle::Internal::Type::Enum
-
-        TaggedSymbol =
-          T.type_alias do
-            T.all(Symbol, Straddle::ChargeCreateParams::ConsentType)
-          end
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        INTERNET =
-          T.let(
-            :internet,
-            Straddle::ChargeCreateParams::ConsentType::TaggedSymbol
-          )
-        SIGNED =
-          T.let(
-            :signed,
-            Straddle::ChargeCreateParams::ConsentType::TaggedSymbol
-          )
-
-        sig do
-          override.returns(
-            T::Array[Straddle::ChargeCreateParams::ConsentType::TaggedSymbol]
-          )
-        end
-        def self.values
-        end
-      end
     end
   end
 end