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

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

@@ -6,81 +6,69 @@ module FinchAPI
       module Benefits
         class EnrolledIndividual < FinchAPI::BaseModel
           sig { returns(T.nilable(FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body)) }
-          def body
-          end
+          attr_reader :body
 
           sig do
-            params(_: FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body)
-              .returns(FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body)
-          end
-          def body=(_)
+            params(body: T.any(FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body, FinchAPI::Util::AnyHash))
+              .void
           end
+          attr_writer :body
 
-          sig { returns(T.nilable(Integer)) }
-          def code
-          end
+          # HTTP status code. Either 201 or 200
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::TaggedInteger)) }
+          attr_reader :code
 
-          sig { params(_: Integer).returns(Integer) }
-          def code=(_)
-          end
+          sig { params(code: FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::OrInteger).void }
+          attr_writer :code
 
           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
 
           sig do
             params(
-              body: FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body,
-              code: Integer,
+              body: T.any(FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body, FinchAPI::Util::AnyHash),
+              code: FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::OrInteger,
               individual_id: String
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(body: nil, code: nil, individual_id: nil)
+          def self.new(body: nil, code: nil, individual_id: nil)
           end
 
           sig do
             override
               .returns(
-                {body: FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body, code: Integer, individual_id: String}
+                {
+                  body: FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Body,
+                  code: FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::TaggedInteger,
+                  individual_id: String
+                }
               )
           end
           def to_hash
           end
 
           class Body < FinchAPI::BaseModel
+            # A descriptive identifier for the response
             sig { returns(T.nilable(String)) }
-            def finch_code
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def finch_code=(_)
-            end
+            attr_accessor :finch_code
 
+            # Short description in English that provides more information about the response.
             sig { returns(T.nilable(String)) }
-            def message
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def message=(_)
-            end
+            attr_accessor :message
 
+            # Identifier indicating whether the benefit was newly enrolled or updated.
             sig { returns(T.nilable(String)) }
-            def name
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def name=(_)
-            end
+            attr_accessor :name
 
             sig do
-              params(finch_code: T.nilable(String), message: T.nilable(String), name: T.nilable(String)).void
+              params(finch_code: T.nilable(String), message: T.nilable(String), name: T.nilable(String))
+                .returns(T.attached_class)
             end
-            def initialize(finch_code: nil, message: nil, name: nil)
+            def self.new(finch_code: nil, message: nil, name: nil)
             end
 
             sig do
@@ -96,15 +84,21 @@ module FinchAPI
             end
           end
 
-          class Code < FinchAPI::Enum
-            abstract!
+          # HTTP status code. Either 201 or 200
+          module Code
+            extend FinchAPI::Enum
+
+            TaggedInteger =
+              T.type_alias { T.all(Integer, FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code) }
+            OrInteger =
+              T.type_alias { T.any(Integer, FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::TaggedInteger) }
 
-            OK = 200
-            CREATED = 201
-            NOT_FOUND = 404
-            FORBIDDEN = 403
+            OK = T.let(200, FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::TaggedInteger)
+            CREATED = T.let(201, FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::TaggedInteger)
+            NOT_FOUND = T.let(404, FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::TaggedInteger)
+            FORBIDDEN = T.let(403, FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::TaggedInteger)
 
-            sig { override.returns(T::Array[Integer]) }
+            sig { override.returns(T::Array[FinchAPI::Models::HRIS::Benefits::EnrolledIndividual::Code::TaggedInteger]) }
             def self.values
             end
           end

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

@@ -3,46 +3,38 @@
 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
+          attr_reader :body
 
           sig do
-            params(_: FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body)
-              .returns(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body)
-          end
-          def body=(_)
+            params(body: T.any(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body, FinchAPI::Util::AnyHash))
+              .void
           end
+          attr_writer :body
 
           sig { returns(T.nilable(Integer)) }
-          def code
-          end
+          attr_reader :code
 
-          sig { params(_: Integer).returns(Integer) }
-          def code=(_)
-          end
+          sig { params(code: Integer).void }
+          attr_writer :code
 
           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
 
           sig do
             params(
-              body: FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body,
+              body: T.any(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body, FinchAPI::Util::AnyHash),
               code: Integer,
               individual_id: String
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(body: nil, code: nil, individual_id: nil)
+          def self.new(body: nil, code: nil, individual_id: nil)
           end
 
           sig do
@@ -55,63 +47,56 @@ module FinchAPI
           end
 
           class Body < FinchAPI::BaseModel
+            # If the benefit supports annual maximum, the amount in cents for this individual.
             sig { returns(T.nilable(Integer)) }
-            def annual_maximum
-            end
-
-            sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-            def annual_maximum=(_)
-            end
+            attr_accessor :annual_maximum
 
+            # If the benefit supports catch up (401k, 403b, etc.), whether catch up is enabled
+            #   for this individual.
             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
+            attr_accessor :catch_up
 
             sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution)) }
-            def company_contribution
-            end
+            attr_reader :company_contribution
 
             sig do
-              params(_: T.nilable(FinchAPI::Models::HRIS::BenefitContribution))
-                .returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution))
-            end
-            def company_contribution=(_)
+              params(
+                company_contribution: T.nilable(T.any(FinchAPI::Models::HRIS::BenefitContribution, FinchAPI::Util::AnyHash))
+              )
+                .void
             end
+            attr_writer :company_contribution
 
             sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution)) }
-            def employee_deduction
-            end
+            attr_reader :employee_deduction
 
             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
+              params(
+                employee_deduction: T.nilable(T.any(FinchAPI::Models::HRIS::BenefitContribution, FinchAPI::Util::AnyHash))
+              )
+                .void
             end
+            attr_writer :employee_deduction
 
-            sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-            def hsa_contribution_limit=(_)
+            # Type for HSA contribution limit if the benefit is a HSA.
+            sig do
+              returns(
+                T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol)
+              )
             end
+            attr_accessor :hsa_contribution_limit
 
             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)
+                company_contribution: T.nilable(T.any(FinchAPI::Models::HRIS::BenefitContribution, FinchAPI::Util::AnyHash)),
+                employee_deduction: T.nilable(T.any(FinchAPI::Models::HRIS::BenefitContribution, FinchAPI::Util::AnyHash)),
+                hsa_contribution_limit: T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::OrSymbol)
               )
-                .void
+                .returns(T.attached_class)
             end
-            def initialize(
+            def self.new(
               annual_maximum: nil,
               catch_up: nil,
               company_contribution: nil,
@@ -128,26 +113,52 @@ module FinchAPI
                     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)
+                    hsa_contribution_limit: T.nilable(FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol)
                   }
                 )
             end
             def to_hash
             end
 
-            class HsaContributionLimit < FinchAPI::Enum
-              abstract!
-
-              INDIVIDUAL = T.let(:individual, T.nilable(Symbol))
-              FAMILY = T.let(:family, T.nilable(Symbol))
+            # Type for HSA contribution limit if the benefit is a HSA.
+            module HsaContributionLimit
+              extend FinchAPI::Enum
+
+              TaggedSymbol =
+                T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit) }
+              OrSymbol =
+                T.type_alias do
+                  T.any(
+                    Symbol,
+                    FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
+                  )
+                end
+
+              INDIVIDUAL =
+                T.let(
+                  :individual,
+                  FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
+                )
+              FAMILY =
+                T.let(
+                  :family,
+                  FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol
+                )
 
-              sig { override.returns(T::Array[Symbol]) }
+              sig do
+                override
+                  .returns(
+                    T::Array[FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit::TaggedSymbol]
+                  )
+              end
               def self.values
               end
             end
           end
         end
       end
+
+      IndividualBenefit = Benefits::IndividualBenefit
     end
   end
 end