finch-api 0.1.0.pre.alpha.1

data/lib/finch-api/models/directory_event.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    class DirectoryEvent < FinchAPI::Models::BaseWebhookEvent
+      # @!attribute [r] data
+      #
+      #   @return [FinchAPI::Models::DirectoryEvent::Data, nil]
+      optional :data, -> { FinchAPI::Models::DirectoryEvent::Data }
+
+      # @!parse
+      #   # @return [FinchAPI::Models::DirectoryEvent::Data]
+      #   attr_writer :data
+
+      # @!attribute [r] event_type
+      #
+      #   @return [Symbol, FinchAPI::Models::DirectoryEvent::EventType, nil]
+      optional :event_type, enum: -> { FinchAPI::Models::DirectoryEvent::EventType }
+
+      # @!parse
+      #   # @return [Symbol, FinchAPI::Models::DirectoryEvent::EventType]
+      #   attr_writer :event_type
+
+      # @!parse
+      #   # @param data [FinchAPI::Models::DirectoryEvent::Data]
+      #   # @param event_type [Symbol, FinchAPI::Models::DirectoryEvent::EventType]
+      #   #
+      #   def initialize(data: nil, event_type: nil, **) = super
+
+      # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+      class Data < FinchAPI::BaseModel
+        # @!attribute [r] individual_id
+        #   The ID of the individual related to the event.
+        #
+        #   @return [String, nil]
+        optional :individual_id, String
+
+        # @!parse
+        #   # @return [String]
+        #   attr_writer :individual_id
+
+        # @!parse
+        #   # @param individual_id [String]
+        #   #
+        #   def initialize(individual_id: nil, **) = super
+
+        # def initialize: (Hash | FinchAPI::BaseModel) -> void
+      end
+
+      # @abstract
+      #
+      # @example
+      # ```ruby
+      # case event_type
+      # in :"directory.created"
+      #   # ...
+      # in :"directory.updated"
+      #   # ...
+      # in :"directory.deleted"
+      #   # ...
+      # end
+      # ```
+      class EventType < FinchAPI::Enum
+        DIRECTORY_CREATED = :"directory.created"
+        DIRECTORY_UPDATED = :"directory.updated"
+        DIRECTORY_DELETED = :"directory.deleted"
+
+        finalize!
+
+        # @!parse
+        #   # @return [Array<Symbol>]
+        #   #
+        #   def self.values; end
+      end
+    end
+  end
+end

data/lib/finch-api/models/disconnect_response.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    class DisconnectResponse < FinchAPI::BaseModel
+      # @!attribute status
+      #   If the request is successful, Finch will return “success” (HTTP 200 status).
+      #
+      #   @return [String]
+      required :status, String
+
+      # @!parse
+      #   # @param status [String]
+      #   #
+      #   def initialize(status:, **) = super
+
+      # def initialize: (Hash | FinchAPI::BaseModel) -> void
+    end
+  end
+end

data/lib/finch-api/models/employment_event.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    class EmploymentEvent < FinchAPI::Models::BaseWebhookEvent
+      # @!attribute [r] data
+      #
+      #   @return [FinchAPI::Models::EmploymentEvent::Data, nil]
+      optional :data, -> { FinchAPI::Models::EmploymentEvent::Data }
+
+      # @!parse
+      #   # @return [FinchAPI::Models::EmploymentEvent::Data]
+      #   attr_writer :data
+
+      # @!attribute [r] event_type
+      #
+      #   @return [Symbol, FinchAPI::Models::EmploymentEvent::EventType, nil]
+      optional :event_type, enum: -> { FinchAPI::Models::EmploymentEvent::EventType }
+
+      # @!parse
+      #   # @return [Symbol, FinchAPI::Models::EmploymentEvent::EventType]
+      #   attr_writer :event_type
+
+      # @!parse
+      #   # @param data [FinchAPI::Models::EmploymentEvent::Data]
+      #   # @param event_type [Symbol, FinchAPI::Models::EmploymentEvent::EventType]
+      #   #
+      #   def initialize(data: nil, event_type: nil, **) = super
+
+      # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+      class Data < FinchAPI::BaseModel
+        # @!attribute [r] individual_id
+        #   The ID of the individual related to the event.
+        #
+        #   @return [String, nil]
+        optional :individual_id, String
+
+        # @!parse
+        #   # @return [String]
+        #   attr_writer :individual_id
+
+        # @!parse
+        #   # @param individual_id [String]
+        #   #
+        #   def initialize(individual_id: nil, **) = super
+
+        # def initialize: (Hash | FinchAPI::BaseModel) -> void
+      end
+
+      # @abstract
+      #
+      # @example
+      # ```ruby
+      # case event_type
+      # in :"employment.created"
+      #   # ...
+      # in :"employment.updated"
+      #   # ...
+      # in :"employment.deleted"
+      #   # ...
+      # end
+      # ```
+      class EventType < FinchAPI::Enum
+        EMPLOYMENT_CREATED = :"employment.created"
+        EMPLOYMENT_UPDATED = :"employment.updated"
+        EMPLOYMENT_DELETED = :"employment.deleted"
+
+        finalize!
+
+        # @!parse
+        #   # @return [Array<Symbol>]
+        #   #
+        #   def self.values; end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefit_contribution.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      class BenefitContribution < FinchAPI::BaseModel
+        # @!attribute amount
+        #   Contribution amount in cents (if `fixed`) or basis points (if `percent`).
+        #
+        #   @return [Integer, nil]
+        optional :amount, Integer, nil?: true
+
+        # @!attribute type
+        #   Contribution type.
+        #
+        #   @return [Symbol, FinchAPI::Models::HRIS::BenefitContribution::Type, nil]
+        optional :type, enum: -> { FinchAPI::Models::HRIS::BenefitContribution::Type }, nil?: true
+
+        # @!parse
+        #   # @param amount [Integer, nil]
+        #   # @param type [Symbol, FinchAPI::Models::HRIS::BenefitContribution::Type, nil]
+        #   #
+        #   def initialize(amount: nil, type: nil, **) = super
+
+        # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+        # @abstract
+        #
+        # Contribution type.
+        #
+        # @example
+        # ```ruby
+        # case type
+        # in :fixed
+        #   # ...
+        # in :percent
+        #   # ...
+        # end
+        # ```
+        class Type < FinchAPI::Enum
+          FIXED = :fixed
+          PERCENT = :percent
+
+          finalize!
+
+          # @!parse
+          #   # @return [Array<Symbol>]
+          #   #
+          #   def self.values; end
+        end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefit_create_params.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      class BenefitCreateParams < FinchAPI::BaseModel
+        # @!parse
+        #   extend FinchAPI::RequestParameters::Converter
+        include FinchAPI::RequestParameters
+
+        # @!attribute [r] description
+        #   Name of the benefit as it appears in the provider and pay statements. Recommend
+        #     limiting this to <30 characters due to limitations in specific providers (e.g.
+        #     Justworks).
+        #
+        #   @return [String, nil]
+        optional :description, String
+
+        # @!parse
+        #   # @return [String]
+        #   attr_writer :description
+
+        # @!attribute frequency
+        #
+        #   @return [Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil]
+        optional :frequency, enum: -> { FinchAPI::Models::HRIS::BenefitFrequency }, nil?: true
+
+        # @!attribute type
+        #   Type of benefit.
+        #
+        #   @return [Symbol, FinchAPI::Models::HRIS::BenefitType, nil]
+        optional :type, enum: -> { FinchAPI::Models::HRIS::BenefitType }, nil?: true
+
+        # @!parse
+        #   # @param description [String]
+        #   # @param frequency [Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil]
+        #   # @param type [Symbol, FinchAPI::Models::HRIS::BenefitType, nil]
+        #   # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+        #   #
+        #   def initialize(description: nil, frequency: nil, type: nil, request_options: {}, **) = super
+
+        # def initialize: (Hash | FinchAPI::BaseModel) -> void
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefit_features_and_operations.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      class BenefitFeaturesAndOperations < FinchAPI::BaseModel
+        # @!attribute [r] supported_features
+        #
+        #   @return [FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures, nil]
+        optional :supported_features,
+                 -> { FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures }
+
+        # @!parse
+        #   # @return [FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures]
+        #   attr_writer :supported_features
+
+        # @!attribute [r] supported_operations
+        #
+        #   @return [FinchAPI::Models::HRIS::SupportPerBenefitType, nil]
+        optional :supported_operations, -> { FinchAPI::Models::HRIS::SupportPerBenefitType }
+
+        # @!parse
+        #   # @return [FinchAPI::Models::HRIS::SupportPerBenefitType]
+        #   attr_writer :supported_operations
+
+        # @!parse
+        #   # @param supported_features [FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures]
+        #   # @param supported_operations [FinchAPI::Models::HRIS::SupportPerBenefitType]
+        #   #
+        #   def initialize(supported_features: nil, supported_operations: nil, **) = super
+
+        # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+        class SupportedFeatures < FinchAPI::BaseModel
+          # @!attribute annual_maximum
+          #   Whether the provider supports an annual maximum for this benefit.
+          #
+          #   @return [Boolean, nil]
+          optional :annual_maximum, FinchAPI::BooleanModel, nil?: true
+
+          # @!attribute catch_up
+          #   Whether the provider supports catch up for this benefit. This field will only be
+          #     true for retirement benefits.
+          #
+          #   @return [Boolean, nil]
+          optional :catch_up, FinchAPI::BooleanModel, nil?: true
+
+          # @!attribute company_contribution
+          #   Supported contribution types. An empty array indicates contributions are not
+          #     supported.
+          #
+          #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution, nil>, nil]
+          optional :company_contribution,
+                   -> do
+                     FinchAPI::ArrayOf[
+                     enum: FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution, nil?: true
+                     ]
+                   end,
+                   nil?: true
+
+          # @!attribute description
+          #
+          #   @return [String, nil]
+          optional :description, String, nil?: true
+
+          # @!attribute employee_deduction
+          #   Supported deduction types. An empty array indicates deductions are not
+          #     supported.
+          #
+          #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil>, nil]
+          optional :employee_deduction,
+                   -> do
+                     FinchAPI::ArrayOf[
+                     enum: FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil?: true
+                     ]
+                   end,
+                   nil?: true
+
+          # @!attribute [r] frequencies
+          #   The list of frequencies supported by the provider for this benefit
+          #
+          #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil>, nil]
+          optional :frequencies,
+                   -> { FinchAPI::ArrayOf[enum: FinchAPI::Models::HRIS::BenefitFrequency, nil?: true] }
+
+          # @!parse
+          #   # @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil>]
+          #   attr_writer :frequencies
+
+          # @!attribute hsa_contribution_limit
+          #   Whether the provider supports HSA contribution limits. Empty if this feature is
+          #     not supported for the benefit. This array only has values for HSA benefits.
+          #
+          #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit, nil>, nil]
+          optional :hsa_contribution_limit,
+                   -> do
+                     FinchAPI::ArrayOf[
+                     enum: FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit, nil?: true
+                     ]
+                   end,
+                   nil?: true
+
+          # @!parse
+          #   # @param annual_maximum [Boolean, nil]
+          #   # @param catch_up [Boolean, nil]
+          #   # @param company_contribution [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution, nil>, nil]
+          #   # @param description [String, nil]
+          #   # @param employee_deduction [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil>, nil]
+          #   # @param frequencies [Array<Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil>]
+          #   # @param hsa_contribution_limit [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit, nil>, nil]
+          #   #
+          #   def initialize(
+          #     annual_maximum: nil,
+          #     catch_up: nil,
+          #     company_contribution: nil,
+          #     description: nil,
+          #     employee_deduction: nil,
+          #     frequencies: nil,
+          #     hsa_contribution_limit: nil,
+          #     **
+          #   )
+          #     super
+          #   end
+
+          # def initialize: (Hash | FinchAPI::BaseModel) -> void
+
+          # @abstract
+          #
+          # @example
+          # ```ruby
+          # case company_contribution
+          # in :fixed
+          #   # ...
+          # in :percent
+          #   # ...
+          # end
+          # ```
+          class CompanyContribution < FinchAPI::Enum
+            FIXED = :fixed
+            PERCENT = :percent
+
+            finalize!
+
+            # @!parse
+            #   # @return [Array<Symbol>]
+            #   #
+            #   def self.values; end
+          end
+
+          # @abstract
+          #
+          # @example
+          # ```ruby
+          # case employee_deduction
+          # in :fixed
+          #   # ...
+          # in :percent
+          #   # ...
+          # end
+          # ```
+          class EmployeeDeduction < FinchAPI::Enum
+            FIXED = :fixed
+            PERCENT = :percent
+
+            finalize!
+
+            # @!parse
+            #   # @return [Array<Symbol>]
+            #   #
+            #   def self.values; end
+          end
+
+          # @abstract
+          #
+          # @example
+          # ```ruby
+          # case hsa_contribution_limit
+          # in :individual
+          #   # ...
+          # in :family
+          #   # ...
+          # end
+          # ```
+          class HsaContributionLimit < FinchAPI::Enum
+            INDIVIDUAL = :individual
+            FAMILY = :family
+
+            finalize!
+
+            # @!parse
+            #   # @return [Array<Symbol>]
+            #   #
+            #   def self.values; end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefit_frequency.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # @abstract
+      #
+      # @example
+      # ```ruby
+      # case benefit_frequency
+      # in :one_time
+      #   # ...
+      # in :every_paycheck
+      #   # ...
+      # in :monthly
+      #   # ...
+      # end
+      # ```
+      class BenefitFrequency < FinchAPI::Enum
+        ONE_TIME = :one_time
+        EVERY_PAYCHECK = :every_paycheck
+        MONTHLY = :monthly
+
+        finalize!
+
+        # @!parse
+        #   # @return [Array<Symbol>]
+        #   #
+        #   def self.values; end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefit_list_params.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      class BenefitListParams < FinchAPI::BaseModel
+        # @!parse
+        #   extend FinchAPI::RequestParameters::Converter
+        include FinchAPI::RequestParameters
+
+        # @!parse
+        #   # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+        #   #
+        #   def initialize(request_options: {}, **) = super
+
+        # def initialize: (Hash | FinchAPI::BaseModel) -> void
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefit_list_supported_benefits_params.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      class BenefitListSupportedBenefitsParams < FinchAPI::BaseModel
+        # @!parse
+        #   extend FinchAPI::RequestParameters::Converter
+        include FinchAPI::RequestParameters
+
+        # @!parse
+        #   # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+        #   #
+        #   def initialize(request_options: {}, **) = super
+
+        # def initialize: (Hash | FinchAPI::BaseModel) -> void
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefit_retrieve_params.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      class BenefitRetrieveParams < FinchAPI::BaseModel
+        # @!parse
+        #   extend FinchAPI::RequestParameters::Converter
+        include FinchAPI::RequestParameters
+
+        # @!parse
+        #   # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+        #   #
+        #   def initialize(request_options: {}, **) = super
+
+        # def initialize: (Hash | FinchAPI::BaseModel) -> void
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefit_type.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      # @abstract
+      #
+      # Type of benefit.
+      #
+      # @example
+      # ```ruby
+      # case benefit_type
+      # in :"401k"
+      #   # ...
+      # in :"401k_roth"
+      #   # ...
+      # in :"401k_loan"
+      #   # ...
+      # in :"403b"
+      #   # ...
+      # in :"403b_roth"
+      #   # ...
+      # in ...
+      #   #...
+      # end
+      # ```
+      class BenefitType < FinchAPI::Enum
+        NUMBER_401K = :"401k"
+        NUMBER_401K_ROTH = :"401k_roth"
+        NUMBER_401K_LOAN = :"401k_loan"
+        NUMBER_403B = :"403b"
+        NUMBER_403B_ROTH = :"403b_roth"
+        NUMBER_457 = :"457"
+        NUMBER_457_ROTH = :"457_roth"
+        S125_MEDICAL = :s125_medical
+        S125_DENTAL = :s125_dental
+        S125_VISION = :s125_vision
+        HSA_PRE = :hsa_pre
+        HSA_POST = :hsa_post
+        FSA_MEDICAL = :fsa_medical
+        FSA_DEPENDENT_CARE = :fsa_dependent_care
+        SIMPLE_IRA = :simple_ira
+        SIMPLE = :simple
+        COMMUTER = :commuter
+        CUSTOM_POST_TAX = :custom_post_tax
+        CUSTOM_PRE_TAX = :custom_pre_tax
+
+        finalize!
+
+        # @!parse
+        #   # @return [Array<Symbol>]
+        #   #
+        #   def self.values; end
+      end
+    end
+  end
+end

data/lib/finch-api/models/hris/benefit_update_params.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  module Models
+    module HRIS
+      class BenefitUpdateParams < FinchAPI::BaseModel
+        # @!parse
+        #   extend FinchAPI::RequestParameters::Converter
+        include FinchAPI::RequestParameters
+
+        # @!attribute [r] description
+        #   Updated name or description.
+        #
+        #   @return [String, nil]
+        optional :description, String
+
+        # @!parse
+        #   # @return [String]
+        #   attr_writer :description
+
+        # @!parse
+        #   # @param description [String]
+        #   # @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
+        #   #
+        #   def initialize(description: nil, request_options: {}, **) = super
+
+        # def initialize: (Hash | FinchAPI::BaseModel) -> void
+      end
+    end
+  end
+end