straddle 0.4.0 → 1.0.0

data/rbi/straddle/models/account.rbi

@@ -0,0 +1,209 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class Account < Straddle::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Straddle::Account, Straddle::Internal::AnyHash) }
+
+      # Straddle's unique ID for the account.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The account access level. `standard` provides normal account access, including
+      # access to the Straddle dashboard. `managed` means the platform manages the
+      # account and account users cannot access the Straddle dashboard.
+      sig { returns(Straddle::Account::AccessLevel::TaggedSymbol) }
+      attr_accessor :access_level
+
+      # ID of the organization that owns the account.
+      sig { returns(String) }
+      attr_accessor :organization_id
+
+      # The current lifecycle status of the account.
+      sig { returns(Straddle::Account::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      sig { returns(Straddle::AccountStatusDetail) }
+      attr_reader :status_detail
+
+      sig { params(status_detail: Straddle::AccountStatusDetail::OrHash).void }
+      attr_writer :status_detail
+
+      # The account type. Only `business` is supported.
+      sig { returns(Straddle::Account::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(Straddle::AccountBusinessProfile)) }
+      attr_reader :business_profile
+
+      sig do
+        params(business_profile: Straddle::AccountBusinessProfile::OrHash).void
+      end
+      attr_writer :business_profile
+
+      sig { returns(T.nilable(Straddle::AccountCapabilities)) }
+      attr_reader :capabilities
+
+      sig { params(capabilities: Straddle::AccountCapabilities::OrHash).void }
+      attr_writer :capabilities
+
+      # Date and time when Straddle created the account.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :created_at
+
+      # Your unique ID for the account.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_id
+
+      # Up to 20 user-defined key-value pairs.
+      sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+      attr_accessor :metadata
+
+      sig { returns(T.nilable(Straddle::AccountPaymentSettings)) }
+      attr_reader :settings
+
+      sig { params(settings: Straddle::AccountPaymentSettings::OrHash).void }
+      attr_writer :settings
+
+      sig { returns(T.nilable(Straddle::TermsOfService)) }
+      attr_reader :terms_of_service
+
+      sig { params(terms_of_service: Straddle::TermsOfService::OrHash).void }
+      attr_writer :terms_of_service
+
+      # Date and time of the most recent account update.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :updated_at
+
+      sig do
+        params(
+          id: String,
+          access_level: Straddle::Account::AccessLevel::OrSymbol,
+          organization_id: String,
+          status: Straddle::Account::Status::OrSymbol,
+          status_detail: Straddle::AccountStatusDetail::OrHash,
+          type: Straddle::Account::Type::OrSymbol,
+          business_profile: Straddle::AccountBusinessProfile::OrHash,
+          capabilities: Straddle::AccountCapabilities::OrHash,
+          created_at: T.nilable(Time),
+          external_id: T.nilable(String),
+          metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+          settings: Straddle::AccountPaymentSettings::OrHash,
+          terms_of_service: Straddle::TermsOfService::OrHash,
+          updated_at: T.nilable(Time)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Straddle's unique ID for the account.
+        id:,
+        # The account access level. `standard` provides normal account access, including
+        # access to the Straddle dashboard. `managed` means the platform manages the
+        # account and account users cannot access the Straddle dashboard.
+        access_level:,
+        # ID of the organization that owns the account.
+        organization_id:,
+        # The current lifecycle status of the account.
+        status:,
+        status_detail:,
+        # The account type. Only `business` is supported.
+        type:,
+        business_profile: nil,
+        capabilities: nil,
+        # Date and time when Straddle created the account.
+        created_at: nil,
+        # Your unique ID for the account.
+        external_id: nil,
+        # Up to 20 user-defined key-value pairs.
+        metadata: nil,
+        settings: nil,
+        terms_of_service: nil,
+        # Date and time of the most recent account update.
+        updated_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            access_level: Straddle::Account::AccessLevel::TaggedSymbol,
+            organization_id: String,
+            status: Straddle::Account::Status::TaggedSymbol,
+            status_detail: Straddle::AccountStatusDetail,
+            type: Straddle::Account::Type::TaggedSymbol,
+            business_profile: Straddle::AccountBusinessProfile,
+            capabilities: Straddle::AccountCapabilities,
+            created_at: T.nilable(Time),
+            external_id: T.nilable(String),
+            metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+            settings: Straddle::AccountPaymentSettings,
+            terms_of_service: Straddle::TermsOfService,
+            updated_at: T.nilable(Time)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The account access level. `standard` provides normal account access, including
+      # access to the Straddle dashboard. `managed` means the platform manages the
+      # account and account users cannot access the Straddle dashboard.
+      module AccessLevel
+        extend Straddle::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Straddle::Account::AccessLevel) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        STANDARD =
+          T.let(:standard, Straddle::Account::AccessLevel::TaggedSymbol)
+        MANAGED = T.let(:managed, Straddle::Account::AccessLevel::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Straddle::Account::AccessLevel::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The current lifecycle status of the account.
+      module Status
+        extend Straddle::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Straddle::Account::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CREATED = T.let(:created, Straddle::Account::Status::TaggedSymbol)
+        ONBOARDING = T.let(:onboarding, Straddle::Account::Status::TaggedSymbol)
+        ACTIVE = T.let(:active, Straddle::Account::Status::TaggedSymbol)
+        REJECTED = T.let(:rejected, Straddle::Account::Status::TaggedSymbol)
+        INACTIVE = T.let(:inactive, Straddle::Account::Status::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Straddle::Account::Status::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      # The account type. Only `business` is supported.
+      module Type
+        extend Straddle::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Straddle::Account::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        BUSINESS = T.let(:business, Straddle::Account::Type::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Straddle::Account::Type::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/straddle/models/account_address.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class AccountAddress < Straddle::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Straddle::AccountAddress, Straddle::Internal::AnyHash)
+        end
+
+      # City, district, suburb, town, or village.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :city
+
+      # Primary address line, such as a street address or PO Box.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :line1
+
+      # Postal or ZIP code.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :postal_code
+
+      # Two-letter state code.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :state
+
+      # Two-letter ISO 3166-1 country code. If omitted, Straddle applies US address
+      # validation.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :country
+
+      # Secondary address line, such as an apartment, suite, unit, or building.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :line2
+
+      # Optional business address. If provided, `line1`, `city`, `state`, and
+      # `postal_code` are required.
+      sig do
+        params(
+          city: T.nilable(String),
+          line1: T.nilable(String),
+          postal_code: T.nilable(String),
+          state: T.nilable(String),
+          country: T.nilable(String),
+          line2: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # City, district, suburb, town, or village.
+        city:,
+        # Primary address line, such as a street address or PO Box.
+        line1:,
+        # Postal or ZIP code.
+        postal_code:,
+        # Two-letter state code.
+        state:,
+        # Two-letter ISO 3166-1 country code. If omitted, Straddle applies US address
+        # validation.
+        country: nil,
+        # Secondary address line, such as an apartment, suite, unit, or building.
+        line2: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            city: T.nilable(String),
+            line1: T.nilable(String),
+            postal_code: T.nilable(String),
+            state: T.nilable(String),
+            country: T.nilable(String),
+            line2: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/straddle/models/account_business_profile.rbi

@@ -0,0 +1,120 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class AccountBusinessProfile < Straddle::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Straddle::AccountBusinessProfile, Straddle::Internal::AnyHash)
+        end
+
+      # The operating or trade name of the business.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # URL of the business's primary website.
+      sig { returns(String) }
+      attr_accessor :website
+
+      # Optional business address. If provided, `line1`, `city`, `state`, and
+      # `postal_code` are required.
+      sig { returns(T.nilable(Straddle::AccountAddress)) }
+      attr_reader :address
+
+      sig { params(address: T.nilable(Straddle::AccountAddress::OrHash)).void }
+      attr_writer :address
+
+      # Description of the business and its products or services.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      sig { returns(T.nilable(Straddle::AccountIndustry)) }
+      attr_reader :industry
+
+      sig { params(industry: Straddle::AccountIndustry::OrHash).void }
+      attr_writer :industry
+
+      # The official registered name of the business.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :legal_name
+
+      # Primary business phone number in E.164 format.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :phone
+
+      sig { returns(T.nilable(Straddle::AccountSupportChannels)) }
+      attr_reader :support_channels
+
+      sig do
+        params(support_channels: Straddle::AccountSupportChannels::OrHash).void
+      end
+      attr_writer :support_channels
+
+      # Business tax identification number, such as a US Employer Identification Number
+      # (EIN).
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tax_id
+
+      # How the business plans to use Straddle.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :use_case
+
+      sig do
+        params(
+          name: String,
+          website: String,
+          address: T.nilable(Straddle::AccountAddress::OrHash),
+          description: T.nilable(String),
+          industry: Straddle::AccountIndustry::OrHash,
+          legal_name: T.nilable(String),
+          phone: T.nilable(String),
+          support_channels: Straddle::AccountSupportChannels::OrHash,
+          tax_id: T.nilable(String),
+          use_case: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The operating or trade name of the business.
+        name:,
+        # URL of the business's primary website.
+        website:,
+        # Optional business address. If provided, `line1`, `city`, `state`, and
+        # `postal_code` are required.
+        address: nil,
+        # Description of the business and its products or services.
+        description: nil,
+        industry: nil,
+        # The official registered name of the business.
+        legal_name: nil,
+        # Primary business phone number in E.164 format.
+        phone: nil,
+        support_channels: nil,
+        # Business tax identification number, such as a US Employer Identification Number
+        # (EIN).
+        tax_id: nil,
+        # How the business plans to use Straddle.
+        use_case: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            website: String,
+            address: T.nilable(Straddle::AccountAddress),
+            description: T.nilable(String),
+            industry: Straddle::AccountIndustry,
+            legal_name: T.nilable(String),
+            phone: T.nilable(String),
+            support_channels: Straddle::AccountSupportChannels,
+            tax_id: T.nilable(String),
+            use_case: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/straddle/models/account_capabilities.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class AccountCapabilities < Straddle::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Straddle::AccountCapabilities, Straddle::Internal::AnyHash)
+        end
+
+      sig { returns(Straddle::AccountConsentCapabilities) }
+      attr_reader :consent_types
+
+      sig do
+        params(consent_types: Straddle::AccountConsentCapabilities::OrHash).void
+      end
+      attr_writer :consent_types
+
+      sig { returns(Straddle::AccountCustomerCapabilities) }
+      attr_reader :customer_types
+
+      sig do
+        params(
+          customer_types: Straddle::AccountCustomerCapabilities::OrHash
+        ).void
+      end
+      attr_writer :customer_types
+
+      sig { returns(Straddle::AccountPaymentCapabilities) }
+      attr_reader :payment_types
+
+      sig do
+        params(payment_types: Straddle::AccountPaymentCapabilities::OrHash).void
+      end
+      attr_writer :payment_types
+
+      sig do
+        params(
+          consent_types: Straddle::AccountConsentCapabilities::OrHash,
+          customer_types: Straddle::AccountCustomerCapabilities::OrHash,
+          payment_types: Straddle::AccountPaymentCapabilities::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(consent_types:, customer_types:, payment_types:)
+      end
+
+      sig do
+        override.returns(
+          {
+            consent_types: Straddle::AccountConsentCapabilities,
+            customer_types: Straddle::AccountCustomerCapabilities,
+            payment_types: Straddle::AccountPaymentCapabilities
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/straddle/models/account_capability.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class AccountCapability < Straddle::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Straddle::AccountCapability, Straddle::Internal::AnyHash)
+        end
+
+      # Status of the capability for the account.
+      sig do
+        returns(Straddle::AccountCapability::CapabilityStatus::TaggedSymbol)
+      end
+      attr_accessor :capability_status
+
+      sig do
+        params(
+          capability_status:
+            Straddle::AccountCapability::CapabilityStatus::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Status of the capability for the account.
+        capability_status:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            capability_status:
+              Straddle::AccountCapability::CapabilityStatus::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Status of the capability for the account.
+      module CapabilityStatus
+        extend Straddle::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Straddle::AccountCapability::CapabilityStatus)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACTIVE =
+          T.let(
+            :active,
+            Straddle::AccountCapability::CapabilityStatus::TaggedSymbol
+          )
+        INACTIVE =
+          T.let(
+            :inactive,
+            Straddle::AccountCapability::CapabilityStatus::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Straddle::AccountCapability::CapabilityStatus::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/straddle/models/account_charge_settings.rbi

@@ -0,0 +1,137 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class AccountChargeSettings < Straddle::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Straddle::AccountChargeSettings, Straddle::Internal::AnyHash)
+        end
+
+      # Daily charge amount limit in cents.
+      sig { returns(Integer) }
+      attr_accessor :daily_amount
+
+      # Funding schedule for charges. Straddle sets this value.
+      sig do
+        returns(Straddle::AccountChargeSettings::FundingTime::TaggedSymbol)
+      end
+      attr_accessor :funding_time
+
+      # ID of the linked bank account used for charge settlement. Straddle sets this
+      # value.
+      sig { returns(String) }
+      attr_accessor :linked_bank_account_id
+
+      # Maximum amount in cents for one charge.
+      sig { returns(Integer) }
+      attr_accessor :max_amount
+
+      # Monthly charge amount limit in cents.
+      sig { returns(Integer) }
+      attr_accessor :monthly_amount
+
+      # Maximum number of charges per calendar month.
+      sig { returns(Integer) }
+      attr_accessor :monthly_count
+
+      sig do
+        params(
+          daily_amount: Integer,
+          funding_time: Straddle::AccountChargeSettings::FundingTime::OrSymbol,
+          linked_bank_account_id: String,
+          max_amount: Integer,
+          monthly_amount: Integer,
+          monthly_count: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Daily charge amount limit in cents.
+        daily_amount:,
+        # Funding schedule for charges. Straddle sets this value.
+        funding_time:,
+        # ID of the linked bank account used for charge settlement. Straddle sets this
+        # value.
+        linked_bank_account_id:,
+        # Maximum amount in cents for one charge.
+        max_amount:,
+        # Monthly charge amount limit in cents.
+        monthly_amount:,
+        # Maximum number of charges per calendar month.
+        monthly_count:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            daily_amount: Integer,
+            funding_time:
+              Straddle::AccountChargeSettings::FundingTime::TaggedSymbol,
+            linked_bank_account_id: String,
+            max_amount: Integer,
+            monthly_amount: Integer,
+            monthly_count: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Funding schedule for charges. Straddle sets this value.
+      module FundingTime
+        extend Straddle::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Straddle::AccountChargeSettings::FundingTime)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        IMMEDIATE =
+          T.let(
+            :immediate,
+            Straddle::AccountChargeSettings::FundingTime::TaggedSymbol
+          )
+        NEXT_DAY =
+          T.let(
+            :next_day,
+            Straddle::AccountChargeSettings::FundingTime::TaggedSymbol
+          )
+        ONE_DAY =
+          T.let(
+            :one_day,
+            Straddle::AccountChargeSettings::FundingTime::TaggedSymbol
+          )
+        TWO_DAY =
+          T.let(
+            :two_day,
+            Straddle::AccountChargeSettings::FundingTime::TaggedSymbol
+          )
+        THREE_DAY =
+          T.let(
+            :three_day,
+            Straddle::AccountChargeSettings::FundingTime::TaggedSymbol
+          )
+        FOUR_DAY =
+          T.let(
+            :four_day,
+            Straddle::AccountChargeSettings::FundingTime::TaggedSymbol
+          )
+        FIVE_DAY =
+          T.let(
+            :five_day,
+            Straddle::AccountChargeSettings::FundingTime::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Straddle::AccountChargeSettings::FundingTime::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end