finch-api 0.1.0.pre.alpha.13 → 0.1.0.pre.alpha.14

data/lib/finch_api/models/base_webhook_event.rb

@@ -30,13 +30,11 @@ module FinchAPI
 
       # @!method initialize(account_id:, company_id:, connection_id: nil)
       #   Some parameter documentations has been truncated, see
-      #   {FinchAPI::Models::BaseWebhookEvent} for more details.
+      #   {FinchAPI::BaseWebhookEvent} for more details.
       #
       #   @param account_id [String] [DEPRECATED] Unique Finch ID of the employer account used to make this connectio
-      #   ...
       #
       #   @param company_id [String] [DEPRECATED] Unique Finch ID of the company for which data has been updated. Use
-      #   ...
       #
       #   @param connection_id [String] Unique Finch ID of the connection associated with the webhook event.
     end

data/lib/finch_api/models/company_event.rb

@@ -10,12 +10,12 @@ module FinchAPI
 
       # @!attribute event_type
       #
-      #   @return [Symbol, FinchAPI::Models::CompanyEvent::EventType, nil]
-      optional :event_type, enum: -> { FinchAPI::Models::CompanyEvent::EventType }
+      #   @return [Symbol, FinchAPI::CompanyEvent::EventType, nil]
+      optional :event_type, enum: -> { FinchAPI::CompanyEvent::EventType }
 
       # @!method initialize(data: nil, event_type: nil)
       #   @param data [Hash{Symbol=>Object}, nil]
-      #   @param event_type [Symbol, FinchAPI::Models::CompanyEvent::EventType]
+      #   @param event_type [Symbol, FinchAPI::CompanyEvent::EventType]
 
       module EventType
         extend FinchAPI::Internal::Type::Enum

data/lib/finch_api/models/connect/session_new_params.rb

@@ -20,9 +20,9 @@ module FinchAPI
 
         # @!attribute products
         #
-        #   @return [Array<Symbol, FinchAPI::Models::Connect::SessionNewParams::Product>]
+        #   @return [Array<Symbol, FinchAPI::Connect::SessionNewParams::Product>]
         required :products,
-                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Models::Connect::SessionNewParams::Product] }
+                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Connect::SessionNewParams::Product] }
 
         # @!attribute customer_email
         #
@@ -31,8 +31,8 @@ module FinchAPI
 
         # @!attribute integration
         #
-        #   @return [FinchAPI::Models::Connect::SessionNewParams::Integration, nil]
-        optional :integration, -> { FinchAPI::Models::Connect::SessionNewParams::Integration }, nil?: true
+        #   @return [FinchAPI::Connect::SessionNewParams::Integration, nil]
+        optional :integration, -> { FinchAPI::Connect::SessionNewParams::Integration }, nil?: true
 
         # @!attribute manual
         #
@@ -53,8 +53,8 @@ module FinchAPI
 
         # @!attribute sandbox
         #
-        #   @return [Symbol, FinchAPI::Models::Connect::SessionNewParams::Sandbox, nil]
-        optional :sandbox, enum: -> { FinchAPI::Models::Connect::SessionNewParams::Sandbox }, nil?: true
+        #   @return [Symbol, FinchAPI::Connect::SessionNewParams::Sandbox, nil]
+        optional :sandbox, enum: -> { FinchAPI::Connect::SessionNewParams::Sandbox }, nil?: true
 
         # @!method initialize(customer_id:, customer_name:, products:, customer_email: nil, integration: nil, manual: nil, minutes_to_expire: nil, redirect_uri: nil, sandbox: nil, request_options: {})
         #   Some parameter documentations has been truncated, see
@@ -64,20 +64,19 @@ module FinchAPI
         #
         #   @param customer_name [String]
         #
-        #   @param products [Array<Symbol, FinchAPI::Models::Connect::SessionNewParams::Product>]
+        #   @param products [Array<Symbol, FinchAPI::Connect::SessionNewParams::Product>]
         #
         #   @param customer_email [String, nil]
         #
-        #   @param integration [FinchAPI::Models::Connect::SessionNewParams::Integration, nil]
+        #   @param integration [FinchAPI::Connect::SessionNewParams::Integration, nil]
         #
         #   @param manual [Boolean, nil]
         #
         #   @param minutes_to_expire [Float, nil] The number of minutes until the session expires (defaults to 43,200, which is 30
-        #   ...
         #
         #   @param redirect_uri [String, nil]
         #
-        #   @param sandbox [Symbol, FinchAPI::Models::Connect::SessionNewParams::Sandbox, nil]
+        #   @param sandbox [Symbol, FinchAPI::Connect::SessionNewParams::Sandbox, nil]
         #
         #   @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
 
@@ -103,9 +102,9 @@ module FinchAPI
         class Integration < FinchAPI::Internal::Type::BaseModel
           # @!attribute auth_method
           #
-          #   @return [Symbol, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod, nil]
+          #   @return [Symbol, FinchAPI::Connect::SessionNewParams::Integration::AuthMethod, nil]
           optional :auth_method,
-                   enum: -> { FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod },
+                   enum: -> { FinchAPI::Connect::SessionNewParams::Integration::AuthMethod },
                    nil?: true
 
           # @!attribute provider
@@ -114,10 +113,10 @@ module FinchAPI
           optional :provider, String, nil?: true
 
           # @!method initialize(auth_method: nil, provider: nil)
-          #   @param auth_method [Symbol, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod, nil]
+          #   @param auth_method [Symbol, FinchAPI::Connect::SessionNewParams::Integration::AuthMethod, nil]
           #   @param provider [String, nil]
 
-          # @see FinchAPI::Models::Connect::SessionNewParams::Integration#auth_method
+          # @see FinchAPI::Connect::SessionNewParams::Integration#auth_method
           module AuthMethod
             extend FinchAPI::Internal::Type::Enum
 

data/lib/finch_api/models/connect/session_reauthenticate_params.rb

@@ -24,9 +24,11 @@ module FinchAPI
         # @!attribute products
         #   The products to request access to (optional for reauthentication)
         #
-        #   @return [Array<Symbol, FinchAPI::Models::Connect::SessionReauthenticateParams::Product>, nil]
+        #   @return [Array<Symbol, FinchAPI::Connect::SessionReauthenticateParams::Product>, nil]
         optional :products,
-                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Models::Connect::SessionReauthenticateParams::Product] },
+                 -> {
+                   FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Connect::SessionReauthenticateParams::Product]
+                 },
                  nil?: true
 
         # @!attribute redirect_uri
@@ -42,9 +44,8 @@ module FinchAPI
         #   @param connection_id [String] The ID of the existing connection to reauthenticate
         #
         #   @param minutes_to_expire [Integer, nil] The number of minutes until the session expires (defaults to 43,200, which is 30
-        #   ...
         #
-        #   @param products [Array<Symbol, FinchAPI::Models::Connect::SessionReauthenticateParams::Product>, nil] The products to request access to (optional for reauthentication)
+        #   @param products [Array<Symbol, FinchAPI::Connect::SessionReauthenticateParams::Product>, nil] The products to request access to (optional for reauthentication)
         #
         #   @param redirect_uri [String, nil] The URI to redirect to after the Connect flow is completed
         #

data/lib/finch_api/models/create_access_token_response.rb

@@ -22,8 +22,8 @@ module FinchAPI
       # @!attribute client_type
       #   The type of application associated with a token.
       #
-      #   @return [Symbol, FinchAPI::Models::CreateAccessTokenResponse::ClientType]
-      required :client_type, enum: -> { FinchAPI::Models::CreateAccessTokenResponse::ClientType }
+      #   @return [Symbol, FinchAPI::CreateAccessTokenResponse::ClientType]
+      required :client_type, enum: -> { FinchAPI::CreateAccessTokenResponse::ClientType }
 
       # @!attribute company_id
       #   @deprecated
@@ -46,8 +46,8 @@ module FinchAPI
       #   - `provider` - connection to an external provider
       #   - `finch` - finch-generated data.
       #
-      #   @return [Symbol, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType]
-      required :connection_type, enum: -> { FinchAPI::Models::CreateAccessTokenResponse::ConnectionType }
+      #   @return [Symbol, FinchAPI::CreateAccessTokenResponse::ConnectionType]
+      required :connection_type, enum: -> { FinchAPI::CreateAccessTokenResponse::ConnectionType }
 
       # @!attribute products
       #   An array of the authorized products associated with the `access_token`.
@@ -76,34 +76,31 @@ module FinchAPI
 
       # @!method initialize(access_token:, account_id:, client_type:, company_id:, connection_id:, connection_type:, products:, provider_id:, customer_id: nil, token_type: nil)
       #   Some parameter documentations has been truncated, see
-      #   {FinchAPI::Models::CreateAccessTokenResponse} for more details.
+      #   {FinchAPI::CreateAccessTokenResponse} for more details.
       #
       #   @param access_token [String] The access token for the connection.
       #
       #   @param account_id [String] [DEPRECATED] Use `connection_id` to identify the connection instead of this acco
-      #   ...
       #
-      #   @param client_type [Symbol, FinchAPI::Models::CreateAccessTokenResponse::ClientType] The type of application associated with a token.
+      #   @param client_type [Symbol, FinchAPI::CreateAccessTokenResponse::ClientType] The type of application associated with a token.
       #
       #   @param company_id [String] [DEPRECATED] Use `connection_id` to identify the connection instead of this comp
-      #   ...
       #
       #   @param connection_id [String] The Finch UUID of the connection associated with the `access_token`.
       #
-      #   @param connection_type [Symbol, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType] The type of the connection associated with the token. ...
+      #   @param connection_type [Symbol, FinchAPI::CreateAccessTokenResponse::ConnectionType] The type of the connection associated with the token.
       #
       #   @param products [Array<String>] An array of the authorized products associated with the `access_token`.
       #
       #   @param provider_id [String] The ID of the provider associated with the `access_token`.
       #
       #   @param customer_id [String, nil] The ID of your customer you provided to Finch when a connect session was created
-      #   ...
       #
       #   @param token_type [String] The RFC 8693 token type (Finch uses `bearer` tokens)
 
       # The type of application associated with a token.
       #
-      # @see FinchAPI::Models::CreateAccessTokenResponse#client_type
+      # @see FinchAPI::CreateAccessTokenResponse#client_type
       module ClientType
         extend FinchAPI::Internal::Type::Enum
 
@@ -120,7 +117,7 @@ module FinchAPI
       # - `provider` - connection to an external provider
       # - `finch` - finch-generated data.
       #
-      # @see FinchAPI::Models::CreateAccessTokenResponse#connection_type
+      # @see FinchAPI::CreateAccessTokenResponse#connection_type
       module ConnectionType
         extend FinchAPI::Internal::Type::Enum
 

data/lib/finch_api/models/directory_event.rb

@@ -5,17 +5,17 @@ module FinchAPI
     class DirectoryEvent < FinchAPI::Models::BaseWebhookEvent
       # @!attribute data
       #
-      #   @return [FinchAPI::Models::DirectoryEvent::Data, nil]
-      optional :data, -> { FinchAPI::Models::DirectoryEvent::Data }
+      #   @return [FinchAPI::DirectoryEvent::Data, nil]
+      optional :data, -> { FinchAPI::DirectoryEvent::Data }
 
       # @!attribute event_type
       #
-      #   @return [Symbol, FinchAPI::Models::DirectoryEvent::EventType, nil]
-      optional :event_type, enum: -> { FinchAPI::Models::DirectoryEvent::EventType }
+      #   @return [Symbol, FinchAPI::DirectoryEvent::EventType, nil]
+      optional :event_type, enum: -> { FinchAPI::DirectoryEvent::EventType }
 
       # @!method initialize(data: nil, event_type: nil)
-      #   @param data [FinchAPI::Models::DirectoryEvent::Data]
-      #   @param event_type [Symbol, FinchAPI::Models::DirectoryEvent::EventType]
+      #   @param data [FinchAPI::DirectoryEvent::Data]
+      #   @param event_type [Symbol, FinchAPI::DirectoryEvent::EventType]
 
       class Data < FinchAPI::Internal::Type::BaseModel
         # @!attribute individual_id

data/lib/finch_api/models/employment_event.rb

@@ -5,17 +5,17 @@ module FinchAPI
     class EmploymentEvent < FinchAPI::Models::BaseWebhookEvent
       # @!attribute data
       #
-      #   @return [FinchAPI::Models::EmploymentEvent::Data, nil]
-      optional :data, -> { FinchAPI::Models::EmploymentEvent::Data }
+      #   @return [FinchAPI::EmploymentEvent::Data, nil]
+      optional :data, -> { FinchAPI::EmploymentEvent::Data }
 
       # @!attribute event_type
       #
-      #   @return [Symbol, FinchAPI::Models::EmploymentEvent::EventType, nil]
-      optional :event_type, enum: -> { FinchAPI::Models::EmploymentEvent::EventType }
+      #   @return [Symbol, FinchAPI::EmploymentEvent::EventType, nil]
+      optional :event_type, enum: -> { FinchAPI::EmploymentEvent::EventType }
 
       # @!method initialize(data: nil, event_type: nil)
-      #   @param data [FinchAPI::Models::EmploymentEvent::Data]
-      #   @param event_type [Symbol, FinchAPI::Models::EmploymentEvent::EventType]
+      #   @param data [FinchAPI::EmploymentEvent::Data]
+      #   @param event_type [Symbol, FinchAPI::EmploymentEvent::EventType]
 
       class Data < FinchAPI::Internal::Type::BaseModel
         # @!attribute individual_id

data/lib/finch_api/models/hris/benefit_contribution.rb

@@ -13,17 +13,17 @@ module FinchAPI
         # @!attribute type
         #   Contribution type.
         #
-        #   @return [Symbol, FinchAPI::Models::HRIS::BenefitContribution::Type, nil]
-        optional :type, enum: -> { FinchAPI::Models::HRIS::BenefitContribution::Type }, nil?: true
+        #   @return [Symbol, FinchAPI::HRIS::BenefitContribution::Type, nil]
+        optional :type, enum: -> { FinchAPI::HRIS::BenefitContribution::Type }, nil?: true
 
         # @!method initialize(amount: nil, type: nil)
         #   @param amount [Integer, nil] Contribution amount in cents (if `fixed`) or basis points (if `percent`).
         #
-        #   @param type [Symbol, FinchAPI::Models::HRIS::BenefitContribution::Type, nil] Contribution type.
+        #   @param type [Symbol, FinchAPI::HRIS::BenefitContribution::Type, nil] Contribution type.
 
         # Contribution type.
         #
-        # @see FinchAPI::Models::HRIS::BenefitContribution#type
+        # @see FinchAPI::HRIS::BenefitContribution#type
         module Type
           extend FinchAPI::Internal::Type::Enum
 

data/lib/finch_api/models/hris/benefit_create_params.rb

@@ -11,9 +11,9 @@ module FinchAPI
         # @!attribute company_contribution
         #   The company match for this benefit.
         #
-        #   @return [FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution, nil]
+        #   @return [FinchAPI::HRIS::BenefitCreateParams::CompanyContribution, nil]
         optional :company_contribution,
-                 -> { FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution },
+                 -> { FinchAPI::HRIS::BenefitCreateParams::CompanyContribution },
                  nil?: true
 
         # @!attribute description
@@ -27,47 +27,48 @@ module FinchAPI
         # @!attribute frequency
         #   The frequency of the benefit deduction/contribution.
         #
-        #   @return [Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil]
-        optional :frequency, enum: -> { FinchAPI::Models::HRIS::BenefitFrequency }, nil?: true
+        #   @return [Symbol, FinchAPI::HRIS::BenefitFrequency, nil]
+        optional :frequency, enum: -> { FinchAPI::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
+        #   @return [Symbol, FinchAPI::HRIS::BenefitType, nil]
+        optional :type, enum: -> { FinchAPI::HRIS::BenefitType }, nil?: true
 
         # @!method initialize(company_contribution: nil, description: nil, frequency: nil, type: nil, request_options: {})
         #   Some parameter documentations has been truncated, see
         #   {FinchAPI::Models::HRIS::BenefitCreateParams} for more details.
         #
-        #   @param company_contribution [FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution, nil] The company match for this benefit.
+        #   @param company_contribution [FinchAPI::HRIS::BenefitCreateParams::CompanyContribution, nil] The company match for this benefit.
         #
         #   @param description [String] Name of the benefit as it appears in the provider and pay statements. Recommend
-        #   ...
         #
-        #   @param frequency [Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil] The frequency of the benefit deduction/contribution.
+        #   @param frequency [Symbol, FinchAPI::HRIS::BenefitFrequency, nil] The frequency of the benefit deduction/contribution.
         #
-        #   @param type [Symbol, FinchAPI::Models::HRIS::BenefitType, nil] Type of benefit.
+        #   @param type [Symbol, FinchAPI::HRIS::BenefitType, nil] Type of benefit.
         #
         #   @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
 
         class CompanyContribution < FinchAPI::Internal::Type::BaseModel
           # @!attribute tiers
           #
-          #   @return [Array<FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution::Tier>, nil]
+          #   @return [Array<FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Tier>, nil]
           optional :tiers,
-                   -> { FinchAPI::Internal::Type::ArrayOf[FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution::Tier] }
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Tier]
+                   }
 
           # @!attribute type
           #
-          #   @return [Symbol, FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution::Type, nil]
-          optional :type, enum: -> { FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution::Type }
+          #   @return [Symbol, FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type, nil]
+          optional :type, enum: -> { FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type }
 
           # @!method initialize(tiers: nil, type: nil)
           #   The company match for this benefit.
           #
-          #   @param tiers [Array<FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution::Tier>]
-          #   @param type [Symbol, FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution::Type]
+          #   @param tiers [Array<FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Tier>]
+          #   @param type [Symbol, FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::Type]
 
           class Tier < FinchAPI::Internal::Type::BaseModel
             # @!attribute match
@@ -85,7 +86,7 @@ module FinchAPI
             #   @param threshold [Integer]
           end
 
-          # @see FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution#type
+          # @see FinchAPI::HRIS::BenefitCreateParams::CompanyContribution#type
           module Type
             extend FinchAPI::Internal::Type::Enum
 

data/lib/finch_api/models/hris/benefit_features_and_operations.rb

@@ -6,20 +6,19 @@ module FinchAPI
       class BenefitFeaturesAndOperations < FinchAPI::Internal::Type::BaseModel
         # @!attribute supported_features
         #
-        #   @return [FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures, nil]
-        optional :supported_features,
-                 -> { FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures }
+        #   @return [FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures, nil]
+        optional :supported_features, -> { FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures }
 
         # @!attribute supported_operations
         #
-        #   @return [FinchAPI::Models::HRIS::SupportPerBenefitType, nil]
-        optional :supported_operations, -> { FinchAPI::Models::HRIS::SupportPerBenefitType }
+        #   @return [FinchAPI::HRIS::SupportPerBenefitType, nil]
+        optional :supported_operations, -> { FinchAPI::HRIS::SupportPerBenefitType }
 
         # @!method initialize(supported_features: nil, supported_operations: nil)
-        #   @param supported_features [FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures]
-        #   @param supported_operations [FinchAPI::Models::HRIS::SupportPerBenefitType]
+        #   @param supported_features [FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures]
+        #   @param supported_operations [FinchAPI::HRIS::SupportPerBenefitType]
 
-        # @see FinchAPI::Models::HRIS::BenefitFeaturesAndOperations#supported_features
+        # @see FinchAPI::HRIS::BenefitFeaturesAndOperations#supported_features
         class SupportedFeatures < FinchAPI::Internal::Type::BaseModel
           # @!attribute annual_maximum
           #   Whether the provider supports an annual maximum for this benefit.
@@ -38,14 +37,12 @@ module FinchAPI
           #   Supported contribution types. An empty array indicates contributions are not
           #   supported.
           #
-          #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution, nil>, nil]
+          #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution, nil>, nil]
           optional :company_contribution,
-                   -> do
-                     FinchAPI::Internal::Type::ArrayOf[
-                       enum: FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution,
-                       nil?: true
-                     ]
-                   end,
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution,
+                                                       nil?: true]
+                   },
                    nil?: true
 
           # @!attribute description
@@ -57,54 +54,53 @@ module FinchAPI
           #   Supported deduction types. An empty array indicates deductions are not
           #   supported.
           #
-          #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil>, nil]
+          #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil>, nil]
           optional :employee_deduction,
-                   -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil?: true] },
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction,
+                                                       nil?: true]
+                   },
                    nil?: true
 
           # @!attribute frequencies
           #   The list of frequencies supported by the provider for this benefit
           #
-          #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil>, nil]
+          #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFrequency, nil>, nil]
           optional :frequencies,
-                   -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Models::HRIS::BenefitFrequency, nil?: true] }
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFrequency, nil?: true]
+                   }
 
           # @!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]
+          #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit, nil>, nil]
           optional :hsa_contribution_limit,
-                   -> do
-                     FinchAPI::Internal::Type::ArrayOf[
-                       enum: FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit,
-                       nil?: true
-                     ]
-                   end,
+                   -> {
+                     FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit,
+                                                       nil?: true]
+                   },
                    nil?: true
 
           # @!method initialize(annual_maximum: nil, catch_up: nil, company_contribution: nil, description: nil, employee_deduction: nil, frequencies: nil, hsa_contribution_limit: nil)
           #   Some parameter documentations has been truncated, see
-          #   {FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures} for
-          #   more details.
+          #   {FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures} for more
+          #   details.
           #
           #   @param annual_maximum [Boolean, nil] Whether the provider supports an annual maximum for this benefit.
           #
           #   @param catch_up [Boolean, nil] Whether the provider supports catch up for this benefit. This field will only be
-          #   ...
           #
-          #   @param company_contribution [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution, nil>, nil] Supported contribution types. An empty array indicates contributions are not sup
-          #   ...
+          #   @param company_contribution [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::CompanyContribution, nil>, nil] Supported contribution types. An empty array indicates contributions are not sup
           #
           #   @param description [String, nil]
           #
-          #   @param employee_deduction [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil>, nil] Supported deduction types. An empty array indicates deductions are not supported
-          #   ...
+          #   @param employee_deduction [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::EmployeeDeduction, nil>, nil] Supported deduction types. An empty array indicates deductions are not supported
           #
-          #   @param frequencies [Array<Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil>] The list of frequencies supported by the provider for this benefit
+          #   @param frequencies [Array<Symbol, FinchAPI::HRIS::BenefitFrequency, nil>] The list of frequencies supported by the provider for this benefit
           #
-          #   @param hsa_contribution_limit [Array<Symbol, FinchAPI::Models::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit, nil>, nil] Whether the provider supports HSA contribution limits. Empty if this feature is
-          #   ...
+          #   @param hsa_contribution_limit [Array<Symbol, FinchAPI::HRIS::BenefitFeaturesAndOperations::SupportedFeatures::HsaContributionLimit, nil>, nil] Whether the provider supports HSA contribution limits. Empty if this feature is
 
           module CompanyContribution
             extend FinchAPI::Internal::Type::Enum

data/lib/finch_api/models/hris/benefit_list_supported_benefits_response.rb

@@ -44,9 +44,9 @@ module FinchAPI
         # @!attribute frequencies
         #   The list of frequencies supported by the provider for this benefit
         #
-        #   @return [Array<Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil>, nil]
+        #   @return [Array<Symbol, FinchAPI::HRIS::BenefitFrequency, nil>, nil]
         optional :frequencies,
-                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Models::HRIS::BenefitFrequency, nil?: true] }
+                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::HRIS::BenefitFrequency, nil?: true] }
 
         # @!attribute hsa_contribution_limit
         #   Whether the provider supports HSA contribution limits. Empty if this feature is
@@ -64,20 +64,16 @@ module FinchAPI
         #   @param annual_maximum [Boolean, nil] Whether the provider supports an annual maximum for this benefit.
         #
         #   @param catch_up [Boolean, nil] Whether the provider supports catch up for this benefit. This field will only be
-        #   ...
         #
         #   @param company_contribution [Array<Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::CompanyContribution, nil>, nil] Supported contribution types. An empty array indicates contributions are not sup
-        #   ...
         #
         #   @param description [String, nil]
         #
         #   @param employee_deduction [Array<Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::EmployeeDeduction, nil>, nil] Supported deduction types. An empty array indicates deductions are not supported
-        #   ...
         #
-        #   @param frequencies [Array<Symbol, FinchAPI::Models::HRIS::BenefitFrequency, nil>] The list of frequencies supported by the provider for this benefit
+        #   @param frequencies [Array<Symbol, FinchAPI::HRIS::BenefitFrequency, nil>] The list of frequencies supported by the provider for this benefit
         #
         #   @param hsa_contribution_limit [Array<Symbol, FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse::HsaContributionLimit, nil>, nil] Whether the provider supports HSA contribution limits. Empty if this feature is
-        #   ...
 
         module CompanyContribution
           extend FinchAPI::Internal::Type::Enum

data/lib/finch_api/models/hris/benefits/individual_benefit.rb

@@ -8,8 +8,8 @@ module FinchAPI
         class IndividualBenefit < FinchAPI::Internal::Type::BaseModel
           # @!attribute body
           #
-          #   @return [FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body, nil]
-          optional :body, -> { FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body }
+          #   @return [FinchAPI::HRIS::Benefits::IndividualBenefit::Body, nil]
+          optional :body, -> { FinchAPI::HRIS::Benefits::IndividualBenefit::Body }
 
           # @!attribute code
           #
@@ -22,11 +22,11 @@ module FinchAPI
           optional :individual_id, String
 
           # @!method initialize(body: nil, code: nil, individual_id: nil)
-          #   @param body [FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body]
+          #   @param body [FinchAPI::HRIS::Benefits::IndividualBenefit::Body]
           #   @param code [Integer]
           #   @param individual_id [String]
 
-          # @see FinchAPI::Models::HRIS::Benefits::IndividualBenefit#body
+          # @see FinchAPI::HRIS::Benefits::IndividualBenefit#body
           class Body < FinchAPI::Internal::Type::BaseModel
             # @!attribute annual_maximum
             #   If the benefit supports annual maximum, the amount in cents for this individual.
@@ -43,41 +43,39 @@ module FinchAPI
 
             # @!attribute company_contribution
             #
-            #   @return [FinchAPI::Models::HRIS::BenefitContribution, nil]
-            optional :company_contribution, -> { FinchAPI::Models::HRIS::BenefitContribution }, nil?: true
+            #   @return [FinchAPI::HRIS::BenefitContribution, nil]
+            optional :company_contribution, -> { FinchAPI::HRIS::BenefitContribution }, nil?: true
 
             # @!attribute employee_deduction
             #
-            #   @return [FinchAPI::Models::HRIS::BenefitContribution, nil]
-            optional :employee_deduction, -> { FinchAPI::Models::HRIS::BenefitContribution }, nil?: true
+            #   @return [FinchAPI::HRIS::BenefitContribution, nil]
+            optional :employee_deduction, -> { FinchAPI::HRIS::BenefitContribution }, nil?: true
 
             # @!attribute hsa_contribution_limit
             #   Type for HSA contribution limit if the benefit is a HSA.
             #
-            #   @return [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit, nil]
+            #   @return [Symbol, FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit, nil]
             optional :hsa_contribution_limit,
-                     enum: -> { FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit },
+                     enum: -> { FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit },
                      nil?: true
 
             # @!method initialize(annual_maximum: nil, catch_up: nil, company_contribution: nil, employee_deduction: nil, hsa_contribution_limit: nil)
             #   Some parameter documentations has been truncated, see
-            #   {FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body} for more details.
+            #   {FinchAPI::HRIS::Benefits::IndividualBenefit::Body} for more details.
             #
             #   @param annual_maximum [Integer, nil] If the benefit supports annual maximum, the amount in cents for this individual.
-            #   ...
             #
             #   @param catch_up [Boolean, nil] If the benefit supports catch up (401k, 403b, etc.), whether catch up is enabled
-            #   ...
             #
-            #   @param company_contribution [FinchAPI::Models::HRIS::BenefitContribution, nil]
+            #   @param company_contribution [FinchAPI::HRIS::BenefitContribution, nil]
             #
-            #   @param employee_deduction [FinchAPI::Models::HRIS::BenefitContribution, nil]
+            #   @param employee_deduction [FinchAPI::HRIS::BenefitContribution, nil]
             #
-            #   @param hsa_contribution_limit [Symbol, FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit, nil] Type for HSA contribution limit if the benefit is a HSA.
+            #   @param hsa_contribution_limit [Symbol, FinchAPI::HRIS::Benefits::IndividualBenefit::Body::HsaContributionLimit, nil] Type for HSA contribution limit if the benefit is a HSA.
 
             # Type for HSA contribution limit if the benefit is a HSA.
             #
-            # @see FinchAPI::Models::HRIS::Benefits::IndividualBenefit::Body#hsa_contribution_limit
+            # @see FinchAPI::HRIS::Benefits::IndividualBenefit::Body#hsa_contribution_limit
             module HsaContributionLimit
               extend FinchAPI::Internal::Type::Enum