modern_treasury 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.17

data/rbi/lib/modern_treasury/models/payment_reference_list_params.rbi

@@ -2,49 +2,46 @@
 
 module ModernTreasury
   module Models
-    class PaymentReferenceListParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class PaymentReferenceListParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
       sig { returns(T.nilable(String)) }
-      def after_cursor
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def after_cursor=(_)
-      end
+      attr_accessor :after_cursor
 
       sig { returns(T.nilable(Integer)) }
-      def per_page
-      end
+      attr_reader :per_page
 
-      sig { params(_: Integer).returns(Integer) }
-      def per_page=(_)
-      end
+      sig { params(per_page: Integer).void }
+      attr_writer :per_page
 
+      # The actual reference number assigned by the bank.
       sig { returns(T.nilable(String)) }
-      def reference_number
-      end
+      attr_reader :reference_number
 
-      sig { params(_: String).returns(String) }
-      def reference_number=(_)
-      end
+      sig { params(reference_number: String).void }
+      attr_writer :reference_number
 
+      # The id of the referenceable to search for. Must be accompanied by the
+      # referenceable_type or will return an error.
       sig { returns(T.nilable(String)) }
-      def referenceable_id
-      end
+      attr_reader :referenceable_id
 
-      sig { params(_: String).returns(String) }
-      def referenceable_id=(_)
-      end
+      sig { params(referenceable_id: String).void }
+      attr_writer :referenceable_id
 
-      sig { returns(T.nilable(Symbol)) }
-      def referenceable_type
-      end
+      # One of the referenceable types. This must be accompanied by the id of the
+      # referenceable or will return an error.
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::OrSymbol)) }
+      attr_reader :referenceable_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def referenceable_type=(_)
+      sig do
+        params(
+          referenceable_type: ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::OrSymbol
+        )
+          .void
       end
+      attr_writer :referenceable_type
 
       sig do
         params(
@@ -52,21 +49,19 @@ module ModernTreasury
           per_page: Integer,
           reference_number: String,
           referenceable_id: String,
-          referenceable_type: Symbol,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          referenceable_type: ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::OrSymbol,
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         after_cursor: nil,
         per_page: nil,
         reference_number: nil,
         referenceable_id: nil,
         referenceable_type: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -75,24 +70,35 @@ module ModernTreasury
               per_page: Integer,
               reference_number: String,
               referenceable_id: String,
-              referenceable_type: Symbol,
+              referenceable_type: ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::OrSymbol,
               request_options: ModernTreasury::RequestOptions
             }
           )
       end
-      def to_hash
-      end
-
-      class ReferenceableType < ModernTreasury::Enum
-        abstract!
-
-        PAYMENT_ORDER = :payment_order
-        RETURN = :return
-        REVERSAL = :reversal
-
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
+      def to_hash; end
+
+      # One of the referenceable types. This must be accompanied by the id of the
+      # referenceable or will return an error.
+      module ReferenceableType
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::TaggedSymbol) }
+
+        PAYMENT_ORDER =
+          T.let(:payment_order, ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::TaggedSymbol)
+        RETURN =
+          T.let(:return, ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::TaggedSymbol)
+        REVERSAL =
+          T.let(:reversal, ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::TaggedSymbol)
+
+        sig do
+          override
+            .returns(T::Array[ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::TaggedSymbol])
         end
+        def self.values; end
       end
     end
   end

data/rbi/lib/modern_treasury/models/payment_reference_retireve_params.rbi

@@ -2,17 +2,18 @@
 
 module ModernTreasury
   module Models
-    class PaymentReferenceRetireveParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class PaymentReferenceRetireveParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
-      sig { params(request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])).void }
-      def initialize(request_options: {})
+      sig do
+        params(request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
+          .returns(T.attached_class)
       end
+      def self.new(request_options: {}); end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/modern_treasury/models/payment_reference_retrieve_params.rbi

@@ -2,17 +2,18 @@
 
 module ModernTreasury
   module Models
-    class PaymentReferenceRetrieveParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class PaymentReferenceRetrieveParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
-      sig { params(request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])).void }
-      def initialize(request_options: {})
+      sig do
+        params(request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
+          .returns(T.attached_class)
       end
+      def self.new(request_options: {}); end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/modern_treasury/models/ping_response.rbi

@@ -2,22 +2,15 @@
 
 module ModernTreasury
   module Models
-    class PingResponse < ModernTreasury::BaseModel
+    class PingResponse < ModernTreasury::Internal::Type::BaseModel
       sig { returns(String) }
-      def ping
-      end
+      attr_accessor :ping
 
-      sig { params(_: String).returns(String) }
-      def ping=(_)
-      end
-
-      sig { params(ping: String).void }
-      def initialize(ping:)
-      end
+      sig { params(ping: String).returns(T.attached_class) }
+      def self.new(ping:); end
 
       sig { override.returns({ping: String}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/modern_treasury/models/reconciliation_rule.rbi

@@ -2,103 +2,70 @@
 
 module ModernTreasury
   module Models
-    class ReconciliationRule < ModernTreasury::BaseModel
+    class ReconciliationRule < ModernTreasury::Internal::Type::BaseModel
+      # The lowest amount this expected payment may be equal to. Value in specified
+      # currency's smallest unit. e.g. $10 would be represented as 1000.
       sig { returns(Integer) }
-      def amount_lower_bound
-      end
-
-      sig { params(_: Integer).returns(Integer) }
-      def amount_lower_bound=(_)
-      end
+      attr_accessor :amount_lower_bound
 
+      # The highest amount this expected payment may be equal to. Value in specified
+      # currency's smallest unit. e.g. $10 would be represented as 1000.
       sig { returns(Integer) }
-      def amount_upper_bound
-      end
-
-      sig { params(_: Integer).returns(Integer) }
-      def amount_upper_bound=(_)
-      end
+      attr_accessor :amount_upper_bound
 
-      sig { returns(Symbol) }
-      def direction
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def direction=(_)
-      end
+      # One of credit or debit. When you are receiving money, use credit. When you are
+      # being charged, use debit.
+      sig { returns(ModernTreasury::Models::ReconciliationRule::Direction::OrSymbol) }
+      attr_accessor :direction
 
+      # The ID of the Internal Account for the expected payment
       sig { returns(String) }
-      def internal_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def internal_account_id=(_)
-      end
+      attr_accessor :internal_account_id
 
+      # The ID of the counterparty you expect for this payment
       sig { returns(T.nilable(String)) }
-      def counterparty_id
-      end
+      attr_accessor :counterparty_id
 
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def counterparty_id=(_)
-      end
+      # Must conform to ISO 4217. Defaults to the currency of the internal account
+      sig { returns(T.nilable(ModernTreasury::Models::Currency::OrSymbol)) }
+      attr_reader :currency
 
-      sig { returns(T.nilable(Symbol)) }
-      def currency
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def currency=(_)
-      end
+      sig { params(currency: ModernTreasury::Models::Currency::OrSymbol).void }
+      attr_writer :currency
 
+      # A hash of custom identifiers for this payment
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
-      def custom_identifiers
-      end
-
-      sig { params(_: T.nilable(T::Hash[Symbol, String])).returns(T.nilable(T::Hash[Symbol, String])) }
-      def custom_identifiers=(_)
-      end
+      attr_accessor :custom_identifiers
 
+      # The earliest date the payment may come in. Format is yyyy-mm-dd
       sig { returns(T.nilable(Date)) }
-      def date_lower_bound
-      end
-
-      sig { params(_: T.nilable(Date)).returns(T.nilable(Date)) }
-      def date_lower_bound=(_)
-      end
+      attr_accessor :date_lower_bound
 
+      # The latest date the payment may come in. Format is yyyy-mm-dd
       sig { returns(T.nilable(Date)) }
-      def date_upper_bound
-      end
-
-      sig { params(_: T.nilable(Date)).returns(T.nilable(Date)) }
-      def date_upper_bound=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def type
-      end
+      attr_accessor :date_upper_bound
 
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def type=(_)
-      end
+      # One of ach, au_becs, bacs, book, check, eft, interac, provxchange, rtp, sen,
+      # sepa, signet wire
+      sig { returns(T.nilable(ModernTreasury::Models::ReconciliationRule::Type::OrSymbol)) }
+      attr_accessor :type
 
       sig do
         params(
           amount_lower_bound: Integer,
           amount_upper_bound: Integer,
-          direction: Symbol,
+          direction: ModernTreasury::Models::ReconciliationRule::Direction::OrSymbol,
           internal_account_id: String,
           counterparty_id: T.nilable(String),
-          currency: Symbol,
+          currency: ModernTreasury::Models::Currency::OrSymbol,
           custom_identifiers: T.nilable(T::Hash[Symbol, String]),
           date_lower_bound: T.nilable(Date),
           date_upper_bound: T.nilable(Date),
-          type: T.nilable(Symbol)
+          type: T.nilable(ModernTreasury::Models::ReconciliationRule::Type::OrSymbol)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         amount_lower_bound:,
         amount_upper_bound:,
         direction:,
@@ -109,77 +76,84 @@ module ModernTreasury
         date_lower_bound: nil,
         date_upper_bound: nil,
         type: nil
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
             {
               amount_lower_bound: Integer,
               amount_upper_bound: Integer,
-              direction: Symbol,
+              direction: ModernTreasury::Models::ReconciliationRule::Direction::OrSymbol,
               internal_account_id: String,
               counterparty_id: T.nilable(String),
-              currency: Symbol,
+              currency: ModernTreasury::Models::Currency::OrSymbol,
               custom_identifiers: T.nilable(T::Hash[Symbol, String]),
               date_lower_bound: T.nilable(Date),
               date_upper_bound: T.nilable(Date),
-              type: T.nilable(Symbol)
+              type: T.nilable(ModernTreasury::Models::ReconciliationRule::Type::OrSymbol)
             }
           )
       end
-      def to_hash
-      end
-
-      class Direction < ModernTreasury::Enum
-        abstract!
-
-        CREDIT = :credit
-        DEBIT = :debit
-
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
-      end
-
-      class Type < ModernTreasury::Enum
-        abstract!
-
-        ACH = T.let(:ach, T.nilable(Symbol))
-        AU_BECS = T.let(:au_becs, T.nilable(Symbol))
-        BACS = T.let(:bacs, T.nilable(Symbol))
-        BOOK = T.let(:book, T.nilable(Symbol))
-        CARD = T.let(:card, T.nilable(Symbol))
-        CHATS = T.let(:chats, T.nilable(Symbol))
-        CHECK = T.let(:check, T.nilable(Symbol))
-        CROSS_BORDER = T.let(:cross_border, T.nilable(Symbol))
-        DK_NETS = T.let(:dk_nets, T.nilable(Symbol))
-        EFT = T.let(:eft, T.nilable(Symbol))
-        HU_ICS = T.let(:hu_ics, T.nilable(Symbol))
-        INTERAC = T.let(:interac, T.nilable(Symbol))
-        MASAV = T.let(:masav, T.nilable(Symbol))
-        MX_CCEN = T.let(:mx_ccen, T.nilable(Symbol))
-        NEFT = T.let(:neft, T.nilable(Symbol))
-        NICS = T.let(:nics, T.nilable(Symbol))
-        NZ_BECS = T.let(:nz_becs, T.nilable(Symbol))
-        PL_ELIXIR = T.let(:pl_elixir, T.nilable(Symbol))
-        PROVXCHANGE = T.let(:provxchange, T.nilable(Symbol))
-        RO_SENT = T.let(:ro_sent, T.nilable(Symbol))
-        RTP = T.let(:rtp, T.nilable(Symbol))
-        SE_BANKGIROT = T.let(:se_bankgirot, T.nilable(Symbol))
-        SEN = T.let(:sen, T.nilable(Symbol))
-        SEPA = T.let(:sepa, T.nilable(Symbol))
-        SG_GIRO = T.let(:sg_giro, T.nilable(Symbol))
-        SIC = T.let(:sic, T.nilable(Symbol))
-        SIGNET = T.let(:signet, T.nilable(Symbol))
-        SKNBI = T.let(:sknbi, T.nilable(Symbol))
-        WIRE = T.let(:wire, T.nilable(Symbol))
-        ZENGIN = T.let(:zengin, T.nilable(Symbol))
-
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+      def to_hash; end
+
+      # One of credit or debit. When you are receiving money, use credit. When you are
+      # being charged, use debit.
+      module Direction
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::ReconciliationRule::Direction) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::ReconciliationRule::Direction::TaggedSymbol) }
+
+        CREDIT = T.let(:credit, ModernTreasury::Models::ReconciliationRule::Direction::TaggedSymbol)
+        DEBIT = T.let(:debit, ModernTreasury::Models::ReconciliationRule::Direction::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::ReconciliationRule::Direction::TaggedSymbol]) }
+        def self.values; end
+      end
+
+      # One of ach, au_becs, bacs, book, check, eft, interac, provxchange, rtp, sen,
+      # sepa, signet wire
+      module Type
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::ReconciliationRule::Type) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol) }
+
+        ACH = T.let(:ach, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        AU_BECS = T.let(:au_becs, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        BACS = T.let(:bacs, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        BOOK = T.let(:book, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        CARD = T.let(:card, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        CHATS = T.let(:chats, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        CHECK = T.let(:check, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        CROSS_BORDER = T.let(:cross_border, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        DK_NETS = T.let(:dk_nets, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        EFT = T.let(:eft, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        HU_ICS = T.let(:hu_ics, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        INTERAC = T.let(:interac, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        MASAV = T.let(:masav, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        MX_CCEN = T.let(:mx_ccen, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        NEFT = T.let(:neft, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        NICS = T.let(:nics, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        NZ_BECS = T.let(:nz_becs, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        PL_ELIXIR = T.let(:pl_elixir, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        PROVXCHANGE = T.let(:provxchange, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        RO_SENT = T.let(:ro_sent, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        RTP = T.let(:rtp, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        SE_BANKGIROT = T.let(:se_bankgirot, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        SEN = T.let(:sen, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        SEPA = T.let(:sepa, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        SG_GIRO = T.let(:sg_giro, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        SIC = T.let(:sic, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        SIGNET = T.let(:signet, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        SKNBI = T.let(:sknbi, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        WIRE = T.let(:wire, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+        ZENGIN = T.let(:zengin, ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::ReconciliationRule::Type::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end