finch-api 0.1.0.pre.alpha.1

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

@@ -0,0 +1,150 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      class W42005 < FinchAPI::BaseModel
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::W42005::Data)) }
+        def data
+        end
+
+        sig { params(_: FinchAPI::Models::HRIS::W42005::Data).returns(FinchAPI::Models::HRIS::W42005::Data) }
+        def data=(_)
+        end
+
+        sig { returns(T.nilable(Symbol)) }
+        def type
+        end
+
+        sig { params(_: Symbol).returns(Symbol) }
+        def type=(_)
+        end
+
+        sig { returns(T.nilable(Float)) }
+        def year
+        end
+
+        sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
+        def year=(_)
+        end
+
+        sig { params(data: FinchAPI::Models::HRIS::W42005::Data, type: Symbol, year: T.nilable(Float)).void }
+        def initialize(data: nil, type: nil, year: nil)
+        end
+
+        sig { override.returns({data: FinchAPI::Models::HRIS::W42005::Data, type: Symbol, year: T.nilable(Float)}) }
+        def to_hash
+        end
+
+        class Data < FinchAPI::BaseModel
+          sig { returns(T.nilable(Integer)) }
+          def additional_withholding
+          end
+
+          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+          def additional_withholding=(_)
+          end
+
+          sig { returns(T.nilable(Symbol)) }
+          def exemption
+          end
+
+          sig { params(_: Symbol).returns(Symbol) }
+          def exemption=(_)
+          end
+
+          sig { returns(T.nilable(Symbol)) }
+          def filing_status
+          end
+
+          sig { params(_: Symbol).returns(Symbol) }
+          def filing_status=(_)
+          end
+
+          sig { returns(T.nilable(String)) }
+          def individual_id
+          end
+
+          sig { params(_: String).returns(String) }
+          def individual_id=(_)
+          end
+
+          sig { returns(T.nilable(Integer)) }
+          def total_number_of_allowances
+          end
+
+          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+          def total_number_of_allowances=(_)
+          end
+
+          sig do
+            params(
+              additional_withholding: T.nilable(Integer),
+              exemption: Symbol,
+              filing_status: Symbol,
+              individual_id: String,
+              total_number_of_allowances: T.nilable(Integer)
+            )
+              .void
+          end
+          def initialize(
+            additional_withholding: nil,
+            exemption: nil,
+            filing_status: nil,
+            individual_id: nil,
+            total_number_of_allowances: nil
+          )
+          end
+
+          sig do
+            override
+              .returns(
+                {
+                  additional_withholding: T.nilable(Integer),
+                  exemption: Symbol,
+                  filing_status: Symbol,
+                  individual_id: String,
+                  total_number_of_allowances: T.nilable(Integer)
+                }
+              )
+          end
+          def to_hash
+          end
+
+          class Exemption < FinchAPI::Enum
+            abstract!
+
+            EXEMPT = :exempt
+            NON_EXEMPT = :non_exempt
+
+            sig { override.returns(T::Array[Symbol]) }
+            def self.values
+            end
+          end
+
+          class FilingStatus < FinchAPI::Enum
+            abstract!
+
+            MARRIED = :married
+            MARRIED_BUT_WITHHOLD_AT_HIGHER_SINGLE_RATE = :married_but_withhold_at_higher_single_rate
+            SINGLE = :single
+
+            sig { override.returns(T::Array[Symbol]) }
+            def self.values
+            end
+          end
+        end
+
+        class Type < FinchAPI::Enum
+          abstract!
+
+          W4_2005 = :w4_2005
+
+          sig { override.returns(T::Array[Symbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      class W42020 < FinchAPI::BaseModel
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::W42020::Data)) }
+        def data
+        end
+
+        sig { params(_: FinchAPI::Models::HRIS::W42020::Data).returns(FinchAPI::Models::HRIS::W42020::Data) }
+        def data=(_)
+        end
+
+        sig { returns(T.nilable(Symbol)) }
+        def type
+        end
+
+        sig { params(_: Symbol).returns(Symbol) }
+        def type=(_)
+        end
+
+        sig { returns(T.nilable(Float)) }
+        def year
+        end
+
+        sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
+        def year=(_)
+        end
+
+        sig { params(data: FinchAPI::Models::HRIS::W42020::Data, type: Symbol, year: T.nilable(Float)).void }
+        def initialize(data: nil, type: nil, year: nil)
+        end
+
+        sig { override.returns({data: FinchAPI::Models::HRIS::W42020::Data, type: Symbol, year: T.nilable(Float)}) }
+        def to_hash
+        end
+
+        class Data < FinchAPI::BaseModel
+          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
+
+          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
+
+          sig { returns(T.nilable(Integer)) }
+          def deductions
+          end
+
+          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+          def deductions=(_)
+          end
+
+          sig { returns(T.nilable(Integer)) }
+          def extra_withholding
+          end
+
+          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
+
+          sig { returns(T.nilable(String)) }
+          def individual_id
+          end
+
+          sig { params(_: String).returns(String) }
+          def individual_id=(_)
+          end
+
+          sig { returns(T.nilable(Integer)) }
+          def other_income
+          end
+
+          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+          def other_income=(_)
+          end
+
+          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
+
+          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),
+              individual_id: String,
+              other_income: T.nilable(Integer),
+              total_claim_dependent_and_other_credits: T.nilable(Integer)
+            )
+              .void
+          end
+          def initialize(
+            amount_for_other_dependents: nil,
+            amount_for_qualifying_children_under_17: nil,
+            deductions: nil,
+            extra_withholding: nil,
+            filing_status: nil,
+            individual_id: nil,
+            other_income: nil,
+            total_claim_dependent_and_other_credits: nil
+          )
+          end
+
+          sig do
+            override
+              .returns(
+                {
+                  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),
+                  individual_id: String,
+                  other_income: T.nilable(Integer),
+                  total_claim_dependent_and_other_credits: T.nilable(Integer)
+                }
+              )
+          end
+          def to_hash
+          end
+
+          class FilingStatus < FinchAPI::Enum
+            abstract!
+
+            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)
+            )
+
+            sig { override.returns(T::Array[Symbol]) }
+            def self.values
+            end
+          end
+        end
+
+        class Type < FinchAPI::Enum
+          abstract!
+
+          W4_2020 = :w4_2020
+
+          sig { override.returns(T::Array[Symbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class Income < FinchAPI::BaseModel
+      sig { returns(T.nilable(Integer)) }
+      def amount
+      end
+
+      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+      def amount=(_)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def currency
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def currency=(_)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def effective_date
+      end
+
+      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
+
+      sig do
+        params(
+          amount: T.nilable(Integer),
+          currency: T.nilable(String),
+          effective_date: T.nilable(String),
+          unit: T.nilable(Symbol)
+        )
+          .void
+      end
+      def initialize(amount: nil, currency: nil, effective_date: nil, unit: nil)
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              amount: T.nilable(Integer),
+              currency: T.nilable(String),
+              effective_date: T.nilable(String),
+              unit: T.nilable(Symbol)
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class Unit < FinchAPI::Enum
+        abstract!
+
+        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))
+
+        sig { override.returns(T::Array[Symbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class IndividualEvent < FinchAPI::Models::BaseWebhookEvent
+      sig { returns(T.nilable(FinchAPI::Models::IndividualEvent::Data)) }
+      def data
+      end
+
+      sig { params(_: FinchAPI::Models::IndividualEvent::Data).returns(FinchAPI::Models::IndividualEvent::Data) }
+      def data=(_)
+      end
+
+      sig { returns(T.nilable(Symbol)) }
+      def event_type
+      end
+
+      sig { params(_: Symbol).returns(Symbol) }
+      def event_type=(_)
+      end
+
+      sig { params(data: FinchAPI::Models::IndividualEvent::Data, event_type: Symbol).void }
+      def initialize(data: nil, event_type: nil)
+      end
+
+      sig { override.returns({data: FinchAPI::Models::IndividualEvent::Data, event_type: Symbol}) }
+      def to_hash
+      end
+
+      class Data < FinchAPI::BaseModel
+        sig { returns(T.nilable(String)) }
+        def individual_id
+        end
+
+        sig { params(_: String).returns(String) }
+        def individual_id=(_)
+        end
+
+        sig { params(individual_id: String).void }
+        def initialize(individual_id: nil)
+        end
+
+        sig { override.returns({individual_id: String}) }
+        def to_hash
+        end
+      end
+
+      class EventType < FinchAPI::Enum
+        abstract!
+
+        INDIVIDUAL_CREATED = :"individual.created"
+        INDIVIDUAL_UPDATED = :"individual.updated"
+        INDIVIDUAL_DELETED = :"individual.deleted"
+
+        sig { override.returns(T::Array[Symbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end