lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/models/management_operation_reverse_params.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ManagementOperationReverseParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      sig { returns(Date) }
+      attr_accessor :effective_date
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :memo
+
+      sig { params(memo: String).void }
+      attr_writer :memo
+
+      sig do
+        params(
+          effective_date: Date,
+          memo: String,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(effective_date:, memo: nil, request_options: {})
+      end
+
+      sig { override.returns({effective_date: Date, memo: String, request_options: Lithic::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/management_operation_transaction.rbi

@@ -0,0 +1,330 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ManagementOperationTransaction < Lithic::BaseModel
+      sig { returns(String) }
+      attr_accessor :token
+
+      sig { returns(Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol) }
+      attr_accessor :category
+
+      sig { returns(Time) }
+      attr_accessor :created
+
+      sig { returns(String) }
+      attr_accessor :currency
+
+      sig { returns(Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol) }
+      attr_accessor :direction
+
+      sig { returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event]) }
+      attr_accessor :events
+
+      sig { returns(String) }
+      attr_accessor :financial_account_token
+
+      sig { returns(Integer) }
+      attr_accessor :pending_amount
+
+      sig { returns(Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol) }
+      attr_accessor :result
+
+      sig { returns(Integer) }
+      attr_accessor :settled_amount
+
+      sig { returns(Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      sig { returns(Time) }
+      attr_accessor :updated
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :user_defined_id
+
+      sig { params(user_defined_id: String).void }
+      attr_writer :user_defined_id
+
+      sig do
+        params(
+          token: String,
+          category: Lithic::Models::ManagementOperationTransaction::Category::OrSymbol,
+          created: Time,
+          currency: String,
+          direction: Lithic::Models::ManagementOperationTransaction::Direction::OrSymbol,
+          events: T::Array[T.any(Lithic::Models::ManagementOperationTransaction::Event, Lithic::Util::AnyHash)],
+          financial_account_token: String,
+          pending_amount: Integer,
+          result: Lithic::Models::ManagementOperationTransaction::Result::OrSymbol,
+          settled_amount: Integer,
+          status: Lithic::Models::ManagementOperationTransaction::Status::OrSymbol,
+          updated: Time,
+          user_defined_id: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        token:,
+        category:,
+        created:,
+        currency:,
+        direction:,
+        events:,
+        financial_account_token:,
+        pending_amount:,
+        result:,
+        settled_amount:,
+        status:,
+        updated:,
+        user_defined_id: nil
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              token: String,
+              category: Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol,
+              created: Time,
+              currency: String,
+              direction: Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol,
+              events: T::Array[Lithic::Models::ManagementOperationTransaction::Event],
+              financial_account_token: String,
+              pending_amount: Integer,
+              result: Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol,
+              settled_amount: Integer,
+              status: Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol,
+              updated: Time,
+              user_defined_id: String
+            }
+          )
+      end
+      def to_hash
+      end
+
+      module Category
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Category) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol) }
+
+        MANAGEMENT_FEE =
+          T.let(:MANAGEMENT_FEE, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol)
+        MANAGEMENT_DISPUTE =
+          T.let(:MANAGEMENT_DISPUTE, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol)
+        MANAGEMENT_REWARD =
+          T.let(:MANAGEMENT_REWARD, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol)
+        MANAGEMENT_ADJUSTMENT =
+          T.let(:MANAGEMENT_ADJUSTMENT, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      module Direction
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Direction) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol) }
+
+        CREDIT = T.let(:CREDIT, Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol)
+        DEBIT = T.let(:DEBIT, Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      class Event < Lithic::BaseModel
+        sig { returns(String) }
+        attr_accessor :token
+
+        sig { returns(Integer) }
+        attr_accessor :amount
+
+        sig { returns(Time) }
+        attr_accessor :created
+
+        sig { returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol]) }
+        attr_accessor :detailed_results
+
+        sig { returns(Date) }
+        attr_accessor :effective_date
+
+        sig { returns(String) }
+        attr_accessor :memo
+
+        sig { returns(Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol) }
+        attr_accessor :result
+
+        sig { returns(Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol) }
+        attr_accessor :type
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :subtype
+
+        sig { params(subtype: String).void }
+        attr_writer :subtype
+
+        sig do
+          params(
+            token: String,
+            amount: Integer,
+            created: Time,
+            detailed_results: T::Array[Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::OrSymbol],
+            effective_date: Date,
+            memo: String,
+            result: Lithic::Models::ManagementOperationTransaction::Event::Result::OrSymbol,
+            type: Lithic::Models::ManagementOperationTransaction::Event::Type::OrSymbol,
+            subtype: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(token:, amount:, created:, detailed_results:, effective_date:, memo:, result:, type:, subtype: nil)
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                token: String,
+                amount: Integer,
+                created: Time,
+                detailed_results: T::Array[Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol],
+                effective_date: Date,
+                memo: String,
+                result: Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol,
+                type: Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol,
+                subtype: String
+              }
+            )
+        end
+        def to_hash
+        end
+
+        module DetailedResult
+          extend Lithic::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Event::DetailedResult) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol) }
+
+          APPROVED =
+            T.let(:APPROVED, Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol)
+
+          sig do
+            override
+              .returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol])
+          end
+          def self.values
+          end
+        end
+
+        module Result
+          extend Lithic::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Event::Result) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol) }
+
+          APPROVED = T.let(:APPROVED, Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol)
+          DECLINED = T.let(:DECLINED, Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+        module Type
+          extend Lithic::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Event::Type) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol) }
+
+          CASH_BACK = T.let(:CASH_BACK, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          CURRENCY_CONVERSION =
+            T.let(:CURRENCY_CONVERSION, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          INTEREST = T.let(:INTEREST, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          LATE_PAYMENT =
+            T.let(:LATE_PAYMENT, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          BILLING_ERROR =
+            T.let(:BILLING_ERROR, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          PROVISIONAL_CREDIT =
+            T.let(:PROVISIONAL_CREDIT, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          LOSS_WRITE_OFF =
+            T.let(:LOSS_WRITE_OFF, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          CASH_BACK_REVERSAL =
+            T.let(:CASH_BACK_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          CURRENCY_CONVERSION_REVERSAL =
+            T.let(
+              :CURRENCY_CONVERSION_REVERSAL,
+              Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          INTEREST_REVERSAL =
+            T.let(:INTEREST_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          LATE_PAYMENT_REVERSAL =
+            T.let(:LATE_PAYMENT_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          BILLING_ERROR_REVERSAL =
+            T.let(:BILLING_ERROR_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          PROVISIONAL_CREDIT_REVERSAL =
+            T.let(
+              :PROVISIONAL_CREDIT_REVERSAL,
+              Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          RETURNED_PAYMENT =
+            T.let(:RETURNED_PAYMENT, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+          RETURNED_PAYMENT_REVERSAL =
+            T.let(
+              :RETURNED_PAYMENT_REVERSAL,
+              Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+
+          sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol]) }
+          def self.values
+          end
+        end
+      end
+
+      module Result
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Result) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol) }
+
+        APPROVED = T.let(:APPROVED, Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol)
+        DECLINED = T.let(:DECLINED, Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      module Status
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol) }
+
+        PENDING = T.let(:PENDING, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
+        SETTLED = T.let(:SETTLED, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
+        DECLINED = T.let(:DECLINED, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
+        REVERSED = T.let(:REVERSED, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
+        CANCELED = T.let(:CANCELED, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/message_attempt.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class MessageAttempt < Lithic::BaseModel
+      # Globally unique identifier.
+      sig { returns(String) }
+      attr_accessor :token
+
+      # An RFC 3339 timestamp for when the event was created. UTC time zone.
+      #
+      #   If no timezone is specified, UTC will be used.
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # Globally unique identifier.
+      sig { returns(String) }
+      attr_accessor :event_subscription_token
+
+      # Globally unique identifier.
+      sig { returns(String) }
+      attr_accessor :event_token
+
+      # The response body from the event subscription's URL.
+      sig { returns(String) }
+      attr_accessor :response
+
+      # The response status code from the event subscription's URL.
+      sig { returns(Integer) }
+      attr_accessor :response_status_code
+
+      # The status of the event attempt.
+      sig { returns(Lithic::Models::MessageAttempt::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      sig { returns(String) }
+      attr_accessor :url
+
+      # A subscription to specific event types.
+      sig do
+        params(
+          token: String,
+          created: Time,
+          event_subscription_token: String,
+          event_token: String,
+          response: String,
+          response_status_code: Integer,
+          status: Lithic::Models::MessageAttempt::Status::OrSymbol,
+          url: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(token:, created:, event_subscription_token:, event_token:, response:, response_status_code:, status:, url:)
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              token: String,
+              created: Time,
+              event_subscription_token: String,
+              event_token: String,
+              response: String,
+              response_status_code: Integer,
+              status: Lithic::Models::MessageAttempt::Status::TaggedSymbol,
+              url: String
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # The status of the event attempt.
+      module Status
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::MessageAttempt::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::MessageAttempt::Status::TaggedSymbol) }
+
+        FAILED = T.let(:FAILED, Lithic::Models::MessageAttempt::Status::TaggedSymbol)
+        PENDING = T.let(:PENDING, Lithic::Models::MessageAttempt::Status::TaggedSymbol)
+        SENDING = T.let(:SENDING, Lithic::Models::MessageAttempt::Status::TaggedSymbol)
+        SUCCESS = T.let(:SUCCESS, Lithic::Models::MessageAttempt::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::MessageAttempt::Status::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/owner_type.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module OwnerType
+      extend Lithic::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::OwnerType) }
+      OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::OwnerType::TaggedSymbol) }
+
+      INDIVIDUAL = T.let(:INDIVIDUAL, Lithic::Models::OwnerType::TaggedSymbol)
+      BUSINESS = T.let(:BUSINESS, Lithic::Models::OwnerType::TaggedSymbol)
+
+      sig { override.returns(T::Array[Lithic::Models::OwnerType::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end