finch-api 0.1.0.pre.alpha.1 → 0.1.0.pre.alpha.2

data/rbi/lib/finch-api/models/hris/w42020.rbi

@@ -4,117 +4,102 @@ module FinchAPI
   module Models
     module HRIS
       class W42020 < FinchAPI::BaseModel
+        # Detailed information specific to the 2020 W4 form.
         sig { returns(T.nilable(FinchAPI::Models::HRIS::W42020::Data)) }
-        def data
-        end
+        attr_reader :data
 
-        sig { params(_: FinchAPI::Models::HRIS::W42020::Data).returns(FinchAPI::Models::HRIS::W42020::Data) }
-        def data=(_)
-        end
+        sig { params(data: T.any(FinchAPI::Models::HRIS::W42020::Data, FinchAPI::Util::AnyHash)).void }
+        attr_writer :data
 
-        sig { returns(T.nilable(Symbol)) }
-        def type
-        end
+        # Specifies the form type, indicating that this document is a 2020 W4 form.
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::W42020::Type::TaggedSymbol)) }
+        attr_reader :type
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def type=(_)
-        end
+        sig { params(type: FinchAPI::Models::HRIS::W42020::Type::OrSymbol).void }
+        attr_writer :type
 
+        # The tax year this W4 document applies to.
         sig { returns(T.nilable(Float)) }
-        def year
+        attr_accessor :year
+
+        # A 2020 version of the W-4 tax form containing information on an individual's
+        #   filing status, dependents, and withholding details.
+        sig do
+          params(
+            data: T.any(FinchAPI::Models::HRIS::W42020::Data, FinchAPI::Util::AnyHash),
+            type: FinchAPI::Models::HRIS::W42020::Type::OrSymbol,
+            year: T.nilable(Float)
+          )
+            .returns(T.attached_class)
         end
-
-        sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
-        def year=(_)
+        def self.new(data: nil, type: nil, year: nil)
         end
 
-        sig { params(data: FinchAPI::Models::HRIS::W42020::Data, type: Symbol, year: T.nilable(Float)).void }
-        def initialize(data: nil, type: nil, year: nil)
+        sig do
+          override
+            .returns(
+              {
+                data: FinchAPI::Models::HRIS::W42020::Data,
+                type: FinchAPI::Models::HRIS::W42020::Type::TaggedSymbol,
+                year: T.nilable(Float)
+              }
+            )
         end
-
-        sig { override.returns({data: FinchAPI::Models::HRIS::W42020::Data, type: Symbol, year: T.nilable(Float)}) }
         def to_hash
         end
 
         class Data < FinchAPI::BaseModel
+          # Amount claimed for dependents other than qualifying children under 17 (in
+          #   cents).
           sig { returns(T.nilable(Integer)) }
-          def amount_for_other_dependents
-          end
-
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def amount_for_other_dependents=(_)
-          end
+          attr_accessor :amount_for_other_dependents
 
+          # Amount claimed for dependents under 17 years old (in cents).
           sig { returns(T.nilable(Integer)) }
-          def amount_for_qualifying_children_under_17
-          end
-
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def amount_for_qualifying_children_under_17=(_)
-          end
+          attr_accessor :amount_for_qualifying_children_under_17
 
+          # Deductible expenses (in cents).
           sig { returns(T.nilable(Integer)) }
-          def deductions
-          end
-
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def deductions=(_)
-          end
+          attr_accessor :deductions
 
+          # Additional withholding amount (in cents).
           sig { returns(T.nilable(Integer)) }
-          def extra_withholding
-          end
+          attr_accessor :extra_withholding
 
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def extra_withholding=(_)
-          end
-
-          sig { returns(T.nilable(Symbol)) }
-          def filing_status
-          end
-
-          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-          def filing_status=(_)
-          end
+          # The individual's filing status for tax purposes.
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::W42020::Data::FilingStatus::TaggedSymbol)) }
+          attr_accessor :filing_status
 
+          # The unique identifier for the individual associated with this document.
           sig { returns(T.nilable(String)) }
-          def individual_id
-          end
+          attr_reader :individual_id
 
-          sig { params(_: String).returns(String) }
-          def individual_id=(_)
-          end
+          sig { params(individual_id: String).void }
+          attr_writer :individual_id
 
+          # Additional income from sources outside of primary employment (in cents).
           sig { returns(T.nilable(Integer)) }
-          def other_income
-          end
-
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def other_income=(_)
-          end
+          attr_accessor :other_income
 
+          # Total amount claimed for dependents and other credits (in cents).
           sig { returns(T.nilable(Integer)) }
-          def total_claim_dependent_and_other_credits
-          end
-
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def total_claim_dependent_and_other_credits=(_)
-          end
+          attr_accessor :total_claim_dependent_and_other_credits
 
+          # Detailed information specific to the 2020 W4 form.
           sig do
             params(
               amount_for_other_dependents: T.nilable(Integer),
               amount_for_qualifying_children_under_17: T.nilable(Integer),
               deductions: T.nilable(Integer),
               extra_withholding: T.nilable(Integer),
-              filing_status: T.nilable(Symbol),
+              filing_status: T.nilable(FinchAPI::Models::HRIS::W42020::Data::FilingStatus::OrSymbol),
               individual_id: String,
               other_income: T.nilable(Integer),
               total_claim_dependent_and_other_credits: T.nilable(Integer)
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
+          def self.new(
             amount_for_other_dependents: nil,
             amount_for_qualifying_children_under_17: nil,
             deductions: nil,
@@ -134,7 +119,7 @@ module FinchAPI
                   amount_for_qualifying_children_under_17: T.nilable(Integer),
                   deductions: T.nilable(Integer),
                   extra_withholding: T.nilable(Integer),
-                  filing_status: T.nilable(Symbol),
+                  filing_status: T.nilable(FinchAPI::Models::HRIS::W42020::Data::FilingStatus::TaggedSymbol),
                   individual_id: String,
                   other_income: T.nilable(Integer),
                   total_claim_dependent_and_other_credits: T.nilable(Integer)
@@ -144,30 +129,43 @@ module FinchAPI
           def to_hash
           end
 
-          class FilingStatus < FinchAPI::Enum
-            abstract!
+          # The individual's filing status for tax purposes.
+          module FilingStatus
+            extend FinchAPI::Enum
 
-            HEAD_OF_HOUSEHOLD = T.let(:head_of_household, T.nilable(Symbol))
-            MARRIED_FILING_JOINTLY_OR_QUALIFYING_SURVIVING_SPOUSE = T.let(
-              :married_filing_jointly_or_qualifying_surviving_spouse, T.nilable(Symbol)
-            )
-            SINGLE_OR_MARRIED_FILING_SEPARATELY = T.let(
-              :single_or_married_filing_separately,
-              T.nilable(Symbol)
-            )
+            TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::W42020::Data::FilingStatus) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::W42020::Data::FilingStatus::TaggedSymbol) }
 
-            sig { override.returns(T::Array[Symbol]) }
+            HEAD_OF_HOUSEHOLD =
+              T.let(:head_of_household, FinchAPI::Models::HRIS::W42020::Data::FilingStatus::TaggedSymbol)
+            MARRIED_FILING_JOINTLY_OR_QUALIFYING_SURVIVING_SPOUSE =
+              T.let(
+                :married_filing_jointly_or_qualifying_surviving_spouse,
+                FinchAPI::Models::HRIS::W42020::Data::FilingStatus::TaggedSymbol
+              )
+            SINGLE_OR_MARRIED_FILING_SEPARATELY =
+              T.let(
+                :single_or_married_filing_separately,
+                FinchAPI::Models::HRIS::W42020::Data::FilingStatus::TaggedSymbol
+              )
+
+            sig { override.returns(T::Array[FinchAPI::Models::HRIS::W42020::Data::FilingStatus::TaggedSymbol]) }
             def self.values
             end
           end
         end
 
-        class Type < FinchAPI::Enum
-          abstract!
+        # Specifies the form type, indicating that this document is a 2020 W4 form.
+        module Type
+          extend FinchAPI::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::W42020::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::W42020::Type::TaggedSymbol) }
 
-          W4_2020 = :w4_2020
+          W4_2020 = T.let(:w4_2020, FinchAPI::Models::HRIS::W42020::Type::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::HRIS::W42020::Type::TaggedSymbol]) }
           def self.values
           end
         end

data/rbi/lib/finch-api/models/income.rbi

@@ -3,48 +3,36 @@
 module FinchAPI
   module Models
     class Income < FinchAPI::BaseModel
+      # The income amount in cents.
       sig { returns(T.nilable(Integer)) }
-      def amount
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def amount=(_)
-      end
+      attr_accessor :amount
 
+      # The currency code.
       sig { returns(T.nilable(String)) }
-      def currency
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def currency=(_)
-      end
+      attr_accessor :currency
 
+      # The date the income amount went into effect.
       sig { returns(T.nilable(String)) }
-      def effective_date
-      end
+      attr_accessor :effective_date
 
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def effective_date=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def unit
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def unit=(_)
-      end
+      # The income unit of payment. Options: `yearly`, `quarterly`, `monthly`,
+      #   `semi_monthly`, `bi_weekly`, `weekly`, `daily`, `hourly`, and `fixed`.
+      sig { returns(T.nilable(FinchAPI::Models::Income::Unit::OrSymbol)) }
+      attr_accessor :unit
 
+      # The employee's income as reported by the provider. This may not always be
+      #   annualized income, but may be in units of bi-weekly, semi-monthly, daily, etc,
+      #   depending on what information the provider returns.
       sig do
         params(
           amount: T.nilable(Integer),
           currency: T.nilable(String),
           effective_date: T.nilable(String),
-          unit: T.nilable(Symbol)
+          unit: T.nilable(FinchAPI::Models::Income::Unit::OrSymbol)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(amount: nil, currency: nil, effective_date: nil, unit: nil)
+      def self.new(amount: nil, currency: nil, effective_date: nil, unit: nil)
       end
 
       sig do
@@ -54,27 +42,32 @@ module FinchAPI
               amount: T.nilable(Integer),
               currency: T.nilable(String),
               effective_date: T.nilable(String),
-              unit: T.nilable(Symbol)
+              unit: T.nilable(FinchAPI::Models::Income::Unit::OrSymbol)
             }
           )
       end
       def to_hash
       end
 
-      class Unit < FinchAPI::Enum
-        abstract!
+      # The income unit of payment. Options: `yearly`, `quarterly`, `monthly`,
+      #   `semi_monthly`, `bi_weekly`, `weekly`, `daily`, `hourly`, and `fixed`.
+      module Unit
+        extend FinchAPI::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Income::Unit) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::Income::Unit::TaggedSymbol) }
 
-        YEARLY = T.let(:yearly, T.nilable(Symbol))
-        QUARTERLY = T.let(:quarterly, T.nilable(Symbol))
-        MONTHLY = T.let(:monthly, T.nilable(Symbol))
-        SEMI_MONTHLY = T.let(:semi_monthly, T.nilable(Symbol))
-        BI_WEEKLY = T.let(:bi_weekly, T.nilable(Symbol))
-        WEEKLY = T.let(:weekly, T.nilable(Symbol))
-        DAILY = T.let(:daily, T.nilable(Symbol))
-        HOURLY = T.let(:hourly, T.nilable(Symbol))
-        FIXED = T.let(:fixed, T.nilable(Symbol))
+        YEARLY = T.let(:yearly, FinchAPI::Models::Income::Unit::TaggedSymbol)
+        QUARTERLY = T.let(:quarterly, FinchAPI::Models::Income::Unit::TaggedSymbol)
+        MONTHLY = T.let(:monthly, FinchAPI::Models::Income::Unit::TaggedSymbol)
+        SEMI_MONTHLY = T.let(:semi_monthly, FinchAPI::Models::Income::Unit::TaggedSymbol)
+        BI_WEEKLY = T.let(:bi_weekly, FinchAPI::Models::Income::Unit::TaggedSymbol)
+        WEEKLY = T.let(:weekly, FinchAPI::Models::Income::Unit::TaggedSymbol)
+        DAILY = T.let(:daily, FinchAPI::Models::Income::Unit::TaggedSymbol)
+        HOURLY = T.let(:hourly, FinchAPI::Models::Income::Unit::TaggedSymbol)
+        FIXED = T.let(:fixed, FinchAPI::Models::Income::Unit::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::Income::Unit::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/finch-api/models/individual_event.rbi

@@ -4,40 +4,49 @@ module FinchAPI
   module Models
     class IndividualEvent < FinchAPI::Models::BaseWebhookEvent
       sig { returns(T.nilable(FinchAPI::Models::IndividualEvent::Data)) }
-      def data
-      end
+      attr_reader :data
 
-      sig { params(_: FinchAPI::Models::IndividualEvent::Data).returns(FinchAPI::Models::IndividualEvent::Data) }
-      def data=(_)
-      end
+      sig { params(data: T.any(FinchAPI::Models::IndividualEvent::Data, FinchAPI::Util::AnyHash)).void }
+      attr_writer :data
 
-      sig { returns(T.nilable(Symbol)) }
-      def event_type
-      end
+      sig { returns(T.nilable(FinchAPI::Models::IndividualEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def event_type=(_)
-      end
+      sig { params(event_type: FinchAPI::Models::IndividualEvent::EventType::OrSymbol).void }
+      attr_writer :event_type
 
-      sig { params(data: FinchAPI::Models::IndividualEvent::Data, event_type: Symbol).void }
-      def initialize(data: nil, event_type: nil)
+      sig do
+        params(
+          data: T.any(FinchAPI::Models::IndividualEvent::Data, FinchAPI::Util::AnyHash),
+          event_type: FinchAPI::Models::IndividualEvent::EventType::OrSymbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(data: nil, event_type: nil)
       end
 
-      sig { override.returns({data: FinchAPI::Models::IndividualEvent::Data, event_type: Symbol}) }
+      sig do
+        override
+          .returns(
+            {
+              data: FinchAPI::Models::IndividualEvent::Data,
+              event_type: FinchAPI::Models::IndividualEvent::EventType::TaggedSymbol
+            }
+          )
+      end
       def to_hash
       end
 
       class Data < FinchAPI::BaseModel
+        # The ID of the individual related to the event.
         sig { returns(T.nilable(String)) }
-        def individual_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def individual_id=(_)
-        end
+        attr_reader :individual_id
 
         sig { params(individual_id: String).void }
-        def initialize(individual_id: nil)
+        attr_writer :individual_id
+
+        sig { params(individual_id: String).returns(T.attached_class) }
+        def self.new(individual_id: nil)
         end
 
         sig { override.returns({individual_id: String}) }
@@ -45,14 +54,20 @@ module FinchAPI
         end
       end
 
-      class EventType < FinchAPI::Enum
-        abstract!
+      module EventType
+        extend FinchAPI::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::IndividualEvent::EventType) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::IndividualEvent::EventType::TaggedSymbol) }
 
-        INDIVIDUAL_CREATED = :"individual.created"
-        INDIVIDUAL_UPDATED = :"individual.updated"
-        INDIVIDUAL_DELETED = :"individual.deleted"
+        INDIVIDUAL_CREATED =
+          T.let(:"individual.created", FinchAPI::Models::IndividualEvent::EventType::TaggedSymbol)
+        INDIVIDUAL_UPDATED =
+          T.let(:"individual.updated", FinchAPI::Models::IndividualEvent::EventType::TaggedSymbol)
+        INDIVIDUAL_DELETED =
+          T.let(:"individual.deleted", FinchAPI::Models::IndividualEvent::EventType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::IndividualEvent::EventType::TaggedSymbol]) }
         def self.values
         end
       end