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

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

@@ -4,105 +4,61 @@ module FinchAPI
   module Models
     module HRIS
       class HRISCompany < FinchAPI::BaseModel
+        # A stable Finch `id` (UUID v4) for the company.
         sig { returns(String) }
-        def id
-        end
-
-        sig { params(_: String).returns(String) }
-        def id=(_)
-        end
+        attr_accessor :id
 
+        # An array of bank account objects associated with the payroll/HRIS system.
         sig { returns(T.nilable(T::Array[FinchAPI::Models::HRIS::HRISCompany::Account])) }
-        def accounts
-        end
-
-        sig do
-          params(_: T.nilable(T::Array[FinchAPI::Models::HRIS::HRISCompany::Account]))
-            .returns(T.nilable(T::Array[FinchAPI::Models::HRIS::HRISCompany::Account]))
-        end
-        def accounts=(_)
-        end
+        attr_accessor :accounts
 
+        # The array of company departments.
         sig { returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::HRISCompany::Department)])) }
-        def departments
-        end
-
-        sig do
-          params(_: T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::HRISCompany::Department)]))
-            .returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::HRISCompany::Department)]))
-        end
-        def departments=(_)
-        end
+        attr_accessor :departments
 
+        # The employer identification number.
         sig { returns(T.nilable(String)) }
-        def ein
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def ein=(_)
-        end
+        attr_accessor :ein
 
+        # The entity type object.
         sig { returns(T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity)) }
-        def entity
-        end
+        attr_reader :entity
 
-        sig do
-          params(_: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity))
-            .returns(T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity))
-        end
-        def entity=(_)
-        end
+        sig { params(entity: T.nilable(T.any(FinchAPI::Models::HRIS::HRISCompany::Entity, FinchAPI::Util::AnyHash))).void }
+        attr_writer :entity
 
+        # The legal name of the company.
         sig { returns(T.nilable(String)) }
-        def legal_name
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def legal_name=(_)
-        end
+        attr_accessor :legal_name
 
         sig { returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::Location)])) }
-        def locations
-        end
-
-        sig do
-          params(_: T.nilable(T::Array[T.nilable(FinchAPI::Models::Location)]))
-            .returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::Location)]))
-        end
-        def locations=(_)
-        end
+        attr_accessor :locations
 
+        # The email of the main administrator on the account.
         sig { returns(T.nilable(String)) }
-        def primary_email
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def primary_email=(_)
-        end
+        attr_accessor :primary_email
 
+        # The phone number of the main administrator on the account. Format: `XXXXXXXXXX`
         sig { returns(T.nilable(String)) }
-        def primary_phone_number
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def primary_phone_number=(_)
-        end
+        attr_accessor :primary_phone_number
 
         sig do
           params(
             id: String,
-            accounts: T.nilable(T::Array[FinchAPI::Models::HRIS::HRISCompany::Account]),
-            departments: T.nilable(T::Array[T.nilable(FinchAPI::Models::HRIS::HRISCompany::Department)]),
+            accounts: T.nilable(T::Array[T.any(FinchAPI::Models::HRIS::HRISCompany::Account, FinchAPI::Util::AnyHash)]),
+            departments: T.nilable(
+              T::Array[T.nilable(T.any(FinchAPI::Models::HRIS::HRISCompany::Department, FinchAPI::Util::AnyHash))]
+            ),
             ein: T.nilable(String),
-            entity: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity),
+            entity: T.nilable(T.any(FinchAPI::Models::HRIS::HRISCompany::Entity, FinchAPI::Util::AnyHash)),
             legal_name: T.nilable(String),
-            locations: T.nilable(T::Array[T.nilable(FinchAPI::Models::Location)]),
+            locations: T.nilable(T::Array[T.nilable(T.any(FinchAPI::Models::Location, FinchAPI::Util::AnyHash))]),
             primary_email: T.nilable(String),
             primary_phone_number: T.nilable(String)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           id:,
           accounts:,
           departments:,
@@ -135,63 +91,38 @@ module FinchAPI
         end
 
         class Account < FinchAPI::BaseModel
+          # The name of the bank associated in the payroll/HRIS system.
           sig { returns(T.nilable(String)) }
-          def account_name
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def account_name=(_)
-          end
+          attr_accessor :account_name
 
+          # 10-12 digit number to specify the bank account
           sig { returns(T.nilable(String)) }
-          def account_number
-          end
+          attr_accessor :account_number
 
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def account_number=(_)
-          end
-
-          sig { returns(T.nilable(Symbol)) }
-          def account_type
-          end
-
-          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-          def account_type=(_)
-          end
+          # The type of bank account.
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::HRISCompany::Account::AccountType::TaggedSymbol)) }
+          attr_accessor :account_type
 
+          # Name of the banking institution.
           sig { returns(T.nilable(String)) }
-          def institution_name
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def institution_name=(_)
-          end
+          attr_accessor :institution_name
 
+          # A nine-digit code that's based on the U.S. Bank location where your account was
+          #   opened.
           sig { returns(T.nilable(String)) }
-          def routing_number
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def routing_number=(_)
-          end
+          attr_accessor :routing_number
 
           sig do
             params(
               account_name: T.nilable(String),
               account_number: T.nilable(String),
-              account_type: T.nilable(Symbol),
+              account_type: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Account::AccountType::OrSymbol),
               institution_name: T.nilable(String),
               routing_number: T.nilable(String)
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
-            account_name: nil,
-            account_number: nil,
-            account_type: nil,
-            institution_name: nil,
-            routing_number: nil
-          )
+          def self.new(account_name: nil, account_number: nil, account_type: nil, institution_name: nil, routing_number: nil)
           end
 
           sig do
@@ -200,7 +131,7 @@ module FinchAPI
                 {
                   account_name: T.nilable(String),
                   account_number: T.nilable(String),
-                  account_type: T.nilable(Symbol),
+                  account_type: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Account::AccountType::TaggedSymbol),
                   institution_name: T.nilable(String),
                   routing_number: T.nilable(String)
                 }
@@ -209,46 +140,48 @@ module FinchAPI
           def to_hash
           end
 
-          class AccountType < FinchAPI::Enum
-            abstract!
+          # The type of bank account.
+          module AccountType
+            extend FinchAPI::Enum
+
+            TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::HRISCompany::Account::AccountType) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::HRISCompany::Account::AccountType::TaggedSymbol) }
 
-            CHECKING = T.let(:checking, T.nilable(Symbol))
-            SAVINGS = T.let(:savings, T.nilable(Symbol))
+            CHECKING = T.let(:checking, FinchAPI::Models::HRIS::HRISCompany::Account::AccountType::TaggedSymbol)
+            SAVINGS = T.let(:savings, FinchAPI::Models::HRIS::HRISCompany::Account::AccountType::TaggedSymbol)
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig { override.returns(T::Array[FinchAPI::Models::HRIS::HRISCompany::Account::AccountType::TaggedSymbol]) }
             def self.values
             end
           end
         end
 
         class Department < FinchAPI::BaseModel
+          # The department name.
           sig { returns(T.nilable(String)) }
-          def name
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def name=(_)
-          end
+          attr_accessor :name
 
+          # The parent department, if present.
           sig { returns(T.nilable(FinchAPI::Models::HRIS::HRISCompany::Department::Parent)) }
-          def parent
-          end
+          attr_reader :parent
 
           sig do
-            params(_: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Department::Parent))
-              .returns(T.nilable(FinchAPI::Models::HRIS::HRISCompany::Department::Parent))
-          end
-          def parent=(_)
+            params(
+              parent: T.nilable(T.any(FinchAPI::Models::HRIS::HRISCompany::Department::Parent, FinchAPI::Util::AnyHash))
+            )
+              .void
           end
+          attr_writer :parent
 
           sig do
             params(
               name: T.nilable(String),
-              parent: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Department::Parent)
+              parent: T.nilable(T.any(FinchAPI::Models::HRIS::HRISCompany::Department::Parent, FinchAPI::Util::AnyHash))
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(name: nil, parent: nil)
+          def self.new(name: nil, parent: nil)
           end
 
           sig do
@@ -261,16 +194,13 @@ module FinchAPI
           end
 
           class Parent < FinchAPI::BaseModel
+            # The parent department's name.
             sig { returns(T.nilable(String)) }
-            def name
-            end
+            attr_accessor :name
 
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def name=(_)
-            end
-
-            sig { params(name: T.nilable(String)).void }
-            def initialize(name: nil)
+            # The parent department, if present.
+            sig { params(name: T.nilable(String)).returns(T.attached_class) }
+            def self.new(name: nil)
             end
 
             sig { override.returns({name: T.nilable(String)}) }
@@ -280,54 +210,72 @@ module FinchAPI
         end
 
         class Entity < FinchAPI::BaseModel
-          sig { returns(T.nilable(Symbol)) }
-          def subtype
-          end
+          # The tax payer subtype of the company.
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity::Subtype::TaggedSymbol)) }
+          attr_accessor :subtype
 
-          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-          def subtype=(_)
-          end
+          # The tax payer type of the company.
+          sig { returns(T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol)) }
+          attr_accessor :type
 
-          sig { returns(T.nilable(Symbol)) }
-          def type
+          # The entity type object.
+          sig do
+            params(
+              subtype: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity::Subtype::OrSymbol),
+              type: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity::Type::OrSymbol)
+            )
+              .returns(T.attached_class)
           end
-
-          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-          def type=(_)
+          def self.new(subtype: nil, type: nil)
           end
 
-          sig { params(subtype: T.nilable(Symbol), type: T.nilable(Symbol)).void }
-          def initialize(subtype: nil, type: nil)
+          sig do
+            override
+              .returns(
+                {
+                  subtype: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity::Subtype::TaggedSymbol),
+                  type: T.nilable(FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol)
+                }
+              )
           end
-
-          sig { override.returns({subtype: T.nilable(Symbol), type: T.nilable(Symbol)}) }
           def to_hash
           end
 
-          class Subtype < FinchAPI::Enum
-            abstract!
+          # The tax payer subtype of the company.
+          module Subtype
+            extend FinchAPI::Enum
 
-            S_CORPORATION = T.let(:s_corporation, T.nilable(Symbol))
-            C_CORPORATION = T.let(:c_corporation, T.nilable(Symbol))
-            B_CORPORATION = T.let(:b_corporation, T.nilable(Symbol))
+            TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::HRISCompany::Entity::Subtype) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::HRISCompany::Entity::Subtype::TaggedSymbol) }
 
-            sig { override.returns(T::Array[Symbol]) }
+            S_CORPORATION = T.let(:s_corporation, FinchAPI::Models::HRIS::HRISCompany::Entity::Subtype::TaggedSymbol)
+            C_CORPORATION = T.let(:c_corporation, FinchAPI::Models::HRIS::HRISCompany::Entity::Subtype::TaggedSymbol)
+            B_CORPORATION = T.let(:b_corporation, FinchAPI::Models::HRIS::HRISCompany::Entity::Subtype::TaggedSymbol)
+
+            sig { override.returns(T::Array[FinchAPI::Models::HRIS::HRISCompany::Entity::Subtype::TaggedSymbol]) }
             def self.values
             end
           end
 
-          class Type < FinchAPI::Enum
-            abstract!
+          # The tax payer type of the company.
+          module Type
+            extend FinchAPI::Enum
+
+            TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::HRISCompany::Entity::Type) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol) }
 
-            LLC = T.let(:llc, T.nilable(Symbol))
-            LP = T.let(:lp, T.nilable(Symbol))
-            CORPORATION = T.let(:corporation, T.nilable(Symbol))
-            SOLE_PROPRIETOR = T.let(:sole_proprietor, T.nilable(Symbol))
-            NON_PROFIT = T.let(:non_profit, T.nilable(Symbol))
-            PARTNERSHIP = T.let(:partnership, T.nilable(Symbol))
-            COOPERATIVE = T.let(:cooperative, T.nilable(Symbol))
+            LLC = T.let(:llc, FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol)
+            LP = T.let(:lp, FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol)
+            CORPORATION = T.let(:corporation, FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol)
+            SOLE_PROPRIETOR =
+              T.let(:sole_proprietor, FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol)
+            NON_PROFIT = T.let(:non_profit, FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol)
+            PARTNERSHIP = T.let(:partnership, FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol)
+            COOPERATIVE = T.let(:cooperative, FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol)
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig { override.returns(T::Array[FinchAPI::Models::HRIS::HRISCompany::Entity::Type::TaggedSymbol]) }
             def self.values
             end
           end

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

@@ -5,47 +5,28 @@ module FinchAPI
     module HRIS
       class CompanyBenefit < FinchAPI::BaseModel
         sig { returns(String) }
-        def benefit_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def benefit_id=(_)
-        end
+        attr_accessor :benefit_id
 
         sig { returns(T.nilable(String)) }
-        def description
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def description=(_)
-        end
+        attr_accessor :description
 
-        sig { returns(T.nilable(Symbol)) }
-        def frequency
-        end
-
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def frequency=(_)
-        end
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol)) }
+        attr_accessor :frequency
 
-        sig { returns(T.nilable(Symbol)) }
-        def type
-        end
-
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def type=(_)
-        end
+        # Type of benefit.
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)) }
+        attr_accessor :type
 
         sig do
           params(
             benefit_id: String,
             description: T.nilable(String),
-            frequency: T.nilable(Symbol),
-            type: T.nilable(Symbol)
+            frequency: T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol),
+            type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(benefit_id:, description:, frequency:, type:)
+        def self.new(benefit_id:, description:, frequency:, type:)
         end
 
         sig do
@@ -54,8 +35,8 @@ module FinchAPI
               {
                 benefit_id: String,
                 description: T.nilable(String),
-                frequency: T.nilable(Symbol),
-                type: T.nilable(Symbol)
+                frequency: T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::TaggedSymbol),
+                type: T.nilable(FinchAPI::Models::HRIS::BenefitType::TaggedSymbol)
               }
             )
         end

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

@@ -7,8 +7,15 @@ module FinchAPI
         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: {})
+        sig do
+          params(
+            request_options: T.any(
+              FinchAPI::RequestOptions,
+              FinchAPI::Util::AnyHash
+            )
+          ).returns(T.attached_class)
+        end
+        def self.new(request_options: {})
         end
 
         sig { override.returns({request_options: FinchAPI::RequestOptions}) }

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

@@ -5,15 +5,10 @@ module FinchAPI
     module HRIS
       class CreateCompanyBenefitsResponse < FinchAPI::BaseModel
         sig { returns(String) }
-        def benefit_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def benefit_id=(_)
-        end
+        attr_accessor :benefit_id
 
-        sig { params(benefit_id: String).void }
-        def initialize(benefit_id:)
+        sig { params(benefit_id: String).returns(T.attached_class) }
+        def self.new(benefit_id:)
         end
 
         sig { override.returns({benefit_id: String}) }

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

@@ -7,31 +7,29 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # Number of employees to return (defaults to all)
         sig { returns(T.nilable(Integer)) }
-        def limit
-        end
+        attr_reader :limit
 
-        sig { params(_: Integer).returns(Integer) }
-        def limit=(_)
-        end
+        sig { params(limit: Integer).void }
+        attr_writer :limit
 
+        # Index to start from (defaults to 0)
         sig { returns(T.nilable(Integer)) }
-        def offset
-        end
+        attr_reader :offset
 
-        sig { params(_: Integer).returns(Integer) }
-        def offset=(_)
-        end
+        sig { params(offset: Integer).void }
+        attr_writer :offset
 
         sig do
           params(
             limit: Integer,
             offset: Integer,
-            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(limit: nil, offset: nil, request_options: {})
+        def self.new(limit: nil, offset: nil, request_options: {})
         end
 
         sig { override.returns({limit: Integer, offset: Integer, request_options: FinchAPI::RequestOptions}) }

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

@@ -7,31 +7,29 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # Number of employees to return (defaults to all)
         sig { returns(T.nilable(Integer)) }
-        def limit
-        end
+        attr_reader :limit
 
-        sig { params(_: Integer).returns(Integer) }
-        def limit=(_)
-        end
+        sig { params(limit: Integer).void }
+        attr_writer :limit
 
+        # Index to start from (defaults to 0)
         sig { returns(T.nilable(Integer)) }
-        def offset
-        end
+        attr_reader :offset
 
-        sig { params(_: Integer).returns(Integer) }
-        def offset=(_)
-        end
+        sig { params(offset: Integer).void }
+        attr_writer :offset
 
         sig do
           params(
             limit: Integer,
             offset: Integer,
-            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(limit: nil, offset: nil, request_options: {})
+        def self.new(limit: nil, offset: nil, request_options: {})
         end
 
         sig { override.returns({limit: Integer, offset: Integer, request_options: FinchAPI::RequestOptions}) }