finch-api 0.1.0.pre.alpha.1

data/rbi/lib/finch-api/models/hris/benefits/individual_benefit.rbi

@@ -0,0 +1,153 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      IndividualBenefit = T.type_alias { Benefits::IndividualBenefit }
+
+      module Benefits
+        class IndividualBenefit < FinchAPI::BaseModel
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body)) }
+          def body
+          end
+
+          sig do
+            params(_: FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body)
+              .returns(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body)
+          end
+          def body=(_)
+          end
+
+          sig { returns(T.nilable(Integer)) }
+          def code
+          end
+
+          sig { params(_: Integer).returns(Integer) }
+          def code=(_)
+          end
+
+          sig { returns(T.nilable(String)) }
+          def individual_id
+          end
+
+          sig { params(_: String).returns(String) }
+          def individual_id=(_)
+          end
+
+          sig do
+            params(
+              body: FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body,
+              code: Integer,
+              individual_id: String
+            )
+              .void
+          end
+          def initialize(body: nil, code: nil, individual_id: nil)
+          end
+
+          sig do
+            override
+              .returns(
+                {body: FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body, code: Integer, individual_id: String}
+              )
+          end
+          def to_hash
+          end
+
+          class Body < FinchAPI::BaseModel
+            sig { returns(T.nilable(Integer)) }
+            def annual_maximum
+            end
+
+            sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+            def annual_maximum=(_)
+            end
+
+            sig { returns(T.nilable(T::Boolean)) }
+            def catch_up
+            end
+
+            sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+            def catch_up=(_)
+            end
+
+            sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution)) }
+            def company_contribution
+            end
+
+            sig do
+              params(_: T.nilable(FinchAPI::Models::HRIS::BenefitContribution))
+                .returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution))
+            end
+            def company_contribution=(_)
+            end
+
+            sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution)) }
+            def employee_deduction
+            end
+
+            sig do
+              params(_: T.nilable(FinchAPI::Models::HRIS::BenefitContribution))
+                .returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution))
+            end
+            def employee_deduction=(_)
+            end
+
+            sig { returns(T.nilable(Symbol)) }
+            def hsa_contribution_limit
+            end
+
+            sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
+            def hsa_contribution_limit=(_)
+            end
+
+            sig do
+              params(
+                annual_maximum: T.nilable(Integer),
+                catch_up: T.nilable(T::Boolean),
+                company_contribution: T.nilable(FinchAPI::Models::HRIS::BenefitContribution),
+                employee_deduction: T.nilable(FinchAPI::Models::HRIS::BenefitContribution),
+                hsa_contribution_limit: T.nilable(Symbol)
+              )
+                .void
+            end
+            def initialize(
+              annual_maximum: nil,
+              catch_up: nil,
+              company_contribution: nil,
+              employee_deduction: nil,
+              hsa_contribution_limit: nil
+            )
+            end
+
+            sig do
+              override
+                .returns(
+                  {
+                    annual_maximum: T.nilable(Integer),
+                    catch_up: T.nilable(T::Boolean),
+                    company_contribution: T.nilable(FinchAPI::Models::HRIS::BenefitContribution),
+                    employee_deduction: T.nilable(FinchAPI::Models::HRIS::BenefitContribution),
+                    hsa_contribution_limit: T.nilable(Symbol)
+                  }
+                )
+            end
+            def to_hash
+            end
+
+            class HsaContributionLimit < FinchAPI::Enum
+              abstract!
+
+              INDIVIDUAL = T.let(:individual, T.nilable(Symbol))
+              FAMILY = T.let(:family, T.nilable(Symbol))
+
+              sig { override.returns(T::Array[Symbol]) }
+              def self.values
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/hris/benefits/individual_enroll_many_params.rbi

@@ -0,0 +1,281 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualEnrollManyParams < FinchAPI::BaseModel
+          extend FinchAPI::RequestParameters::Converter
+          include FinchAPI::RequestParameters
+
+          sig { returns(T.nilable(T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual])) }
+          def individuals
+          end
+
+          sig do
+            params(_: T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual])
+              .returns(T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual])
+          end
+          def individuals=(_)
+          end
+
+          sig do
+            params(
+              individuals: T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual],
+              request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            )
+              .void
+          end
+          def initialize(individuals: nil, request_options: {})
+          end
+
+          sig do
+            override
+              .returns(
+                {
+                  individuals: T::Array[FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual],
+                  request_options: FinchAPI::RequestOptions
+                }
+              )
+          end
+          def to_hash
+          end
+
+          class Individual < FinchAPI::BaseModel
+            sig do
+              returns(
+                T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration)
+              )
+            end
+            def configuration
+            end
+
+            sig do
+              params(_: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration)
+                .returns(FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration)
+            end
+            def configuration=(_)
+            end
+
+            sig { returns(T.nilable(String)) }
+            def individual_id
+            end
+
+            sig { params(_: String).returns(String) }
+            def individual_id=(_)
+            end
+
+            sig do
+              params(
+                configuration: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration,
+                individual_id: String
+              )
+                .void
+            end
+            def initialize(configuration: nil, individual_id: nil)
+            end
+
+            sig do
+              override
+                .returns(
+                  {
+                    configuration: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration,
+                    individual_id: String
+                  }
+                )
+            end
+            def to_hash
+            end
+
+            class Configuration < FinchAPI::BaseModel
+              sig { returns(T.nilable(Symbol)) }
+              def annual_contribution_limit
+              end
+
+              sig { params(_: Symbol).returns(Symbol) }
+              def annual_contribution_limit=(_)
+              end
+
+              sig { returns(T.nilable(Integer)) }
+              def annual_maximum
+              end
+
+              sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+              def annual_maximum=(_)
+              end
+
+              sig { returns(T.nilable(T::Boolean)) }
+              def catch_up
+              end
+
+              sig { params(_: T::Boolean).returns(T::Boolean) }
+              def catch_up=(_)
+              end
+
+              sig do
+                returns(
+                  T.nilable(
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution
+                  )
+                )
+              end
+              def company_contribution
+              end
+
+              sig do
+                params(
+                  _: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution
+                )
+                  .returns(
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution
+                  )
+              end
+              def company_contribution=(_)
+              end
+
+              sig do
+                returns(
+                  T.nilable(
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction
+                  )
+                )
+              end
+              def employee_deduction
+              end
+
+              sig do
+                params(
+                  _: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction
+                )
+                  .returns(
+                    FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction
+                  )
+              end
+              def employee_deduction=(_)
+              end
+
+              sig do
+                params(
+                  annual_contribution_limit: Symbol,
+                  annual_maximum: T.nilable(Integer),
+                  catch_up: T::Boolean,
+                  company_contribution: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution,
+                  employee_deduction: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction
+                )
+                  .void
+              end
+              def initialize(
+                annual_contribution_limit: nil,
+                annual_maximum: nil,
+                catch_up: nil,
+                company_contribution: nil,
+                employee_deduction: nil
+              )
+              end
+
+              sig do
+                override
+                  .returns(
+                    {
+                      annual_contribution_limit: Symbol,
+                      annual_maximum: T.nilable(Integer),
+                      catch_up: T::Boolean,
+                      company_contribution: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::CompanyContribution,
+                      employee_deduction: FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual::Configuration::EmployeeDeduction
+                    }
+                  )
+              end
+              def to_hash
+              end
+
+              class AnnualContributionLimit < FinchAPI::Enum
+                abstract!
+
+                INDIVIDUAL = :individual
+                FAMILY = :family
+
+                sig { override.returns(T::Array[Symbol]) }
+                def self.values
+                end
+              end
+
+              class CompanyContribution < FinchAPI::BaseModel
+                sig { returns(T.nilable(Integer)) }
+                def amount
+                end
+
+                sig { params(_: Integer).returns(Integer) }
+                def amount=(_)
+                end
+
+                sig { returns(T.nilable(Symbol)) }
+                def type
+                end
+
+                sig { params(_: Symbol).returns(Symbol) }
+                def type=(_)
+                end
+
+                sig { params(amount: Integer, type: Symbol).void }
+                def initialize(amount: nil, type: nil)
+                end
+
+                sig { override.returns({amount: Integer, type: Symbol}) }
+                def to_hash
+                end
+
+                class Type < FinchAPI::Enum
+                  abstract!
+
+                  FIXED = :fixed
+                  PERCENT = :percent
+
+                  sig { override.returns(T::Array[Symbol]) }
+                  def self.values
+                  end
+                end
+              end
+
+              class EmployeeDeduction < FinchAPI::BaseModel
+                sig { returns(T.nilable(Integer)) }
+                def amount
+                end
+
+                sig { params(_: Integer).returns(Integer) }
+                def amount=(_)
+                end
+
+                sig { returns(T.nilable(Symbol)) }
+                def type
+                end
+
+                sig { params(_: Symbol).returns(Symbol) }
+                def type=(_)
+                end
+
+                sig { params(amount: Integer, type: Symbol).void }
+                def initialize(amount: nil, type: nil)
+                end
+
+                sig { override.returns({amount: Integer, type: Symbol}) }
+                def to_hash
+                end
+
+                class Type < FinchAPI::Enum
+                  abstract!
+
+                  FIXED = :fixed
+                  PERCENT = :percent
+
+                  sig { override.returns(T::Array[Symbol]) }
+                  def self.values
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/hris/benefits/individual_enrolled_ids_params.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualEnrolledIDsParams < FinchAPI::BaseModel
+          extend FinchAPI::RequestParameters::Converter
+          include FinchAPI::RequestParameters
+
+          sig { params(request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])).void }
+          def initialize(request_options: {})
+          end
+
+          sig { override.returns({request_options: FinchAPI::RequestOptions}) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/hris/benefits/individual_enrolled_ids_response.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualEnrolledIDsResponse < FinchAPI::BaseModel
+          sig { returns(String) }
+          def benefit_id
+          end
+
+          sig { params(_: String).returns(String) }
+          def benefit_id=(_)
+          end
+
+          sig { returns(T::Array[String]) }
+          def individual_ids
+          end
+
+          sig { params(_: T::Array[String]).returns(T::Array[String]) }
+          def individual_ids=(_)
+          end
+
+          sig { params(benefit_id: String, individual_ids: T::Array[String]).void }
+          def initialize(benefit_id:, individual_ids:)
+          end
+
+          sig { override.returns({benefit_id: String, individual_ids: T::Array[String]}) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/hris/benefits/individual_retrieve_many_benefits_params.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualRetrieveManyBenefitsParams < FinchAPI::BaseModel
+          extend FinchAPI::RequestParameters::Converter
+          include FinchAPI::RequestParameters
+
+          sig { returns(T.nilable(String)) }
+          def individual_ids
+          end
+
+          sig { params(_: String).returns(String) }
+          def individual_ids=(_)
+          end
+
+          sig do
+            params(
+              individual_ids: String,
+              request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            )
+              .void
+          end
+          def initialize(individual_ids: nil, request_options: {})
+          end
+
+          sig { override.returns({individual_ids: String, request_options: FinchAPI::RequestOptions}) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/hris/benefits/individual_unenroll_many_params.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class IndividualUnenrollManyParams < FinchAPI::BaseModel
+          extend FinchAPI::RequestParameters::Converter
+          include FinchAPI::RequestParameters
+
+          sig { returns(T.nilable(T::Array[String])) }
+          def individual_ids
+          end
+
+          sig { params(_: T::Array[String]).returns(T::Array[String]) }
+          def individual_ids=(_)
+          end
+
+          sig do
+            params(
+              individual_ids: T::Array[String],
+              request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            )
+              .void
+          end
+          def initialize(individual_ids: nil, request_options: {})
+          end
+
+          sig do
+            override.returns({individual_ids: T::Array[String], request_options: FinchAPI::RequestOptions})
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/hris/benefits/unenrolled_individual.rbi

@@ -0,0 +1,102 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module HRIS
+      module Benefits
+        class UnenrolledIndividual < FinchAPI::BaseModel
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::Benefits::UnenrolledIndividual::Body)) }
+          def body
+          end
+
+          sig do
+            params(_: FinchAPI::Models::HRIS::Benefits::UnenrolledIndividual::Body)
+              .returns(FinchAPI::Models::HRIS::Benefits::UnenrolledIndividual::Body)
+          end
+          def body=(_)
+          end
+
+          sig { returns(T.nilable(Integer)) }
+          def code
+          end
+
+          sig { params(_: Integer).returns(Integer) }
+          def code=(_)
+          end
+
+          sig { returns(T.nilable(String)) }
+          def individual_id
+          end
+
+          sig { params(_: String).returns(String) }
+          def individual_id=(_)
+          end
+
+          sig do
+            params(
+              body: FinchAPI::Models::HRIS::Benefits::UnenrolledIndividual::Body,
+              code: Integer,
+              individual_id: String
+            )
+              .void
+          end
+          def initialize(body: nil, code: nil, individual_id: nil)
+          end
+
+          sig do
+            override
+              .returns(
+                {body: FinchAPI::Models::HRIS::Benefits::UnenrolledIndividual::Body, code: Integer, individual_id: String}
+              )
+          end
+          def to_hash
+          end
+
+          class Body < FinchAPI::BaseModel
+            sig { returns(T.nilable(String)) }
+            def finch_code
+            end
+
+            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+            def finch_code=(_)
+            end
+
+            sig { returns(T.nilable(String)) }
+            def message
+            end
+
+            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+            def message=(_)
+            end
+
+            sig { returns(T.nilable(String)) }
+            def name
+            end
+
+            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+            def name=(_)
+            end
+
+            sig do
+              params(finch_code: T.nilable(String), message: T.nilable(String), name: T.nilable(String)).void
+            end
+            def initialize(finch_code: nil, message: nil, name: nil)
+            end
+
+            sig do
+              override.returns(
+                {
+                  finch_code: T.nilable(String),
+                  message: T.nilable(String),
+                  name: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end