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

data/rbi/lib/finch-api/models/sandbox/company_update_response.rbi

@@ -4,105 +4,63 @@ module FinchAPI
   module Models
     module Sandbox
       class CompanyUpdateResponse < FinchAPI::BaseModel
+        # An array of bank account objects associated with the payroll/HRIS system.
         sig { returns(T.nilable(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account])) }
-        def accounts
-        end
-
-        sig do
-          params(_: T.nilable(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account]))
-            .returns(T.nilable(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account]))
-        end
-        def accounts=(_)
-        end
+        attr_accessor :accounts
 
+        # The array of company departments.
         sig { returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Department)])) }
-        def departments
-        end
-
-        sig do
-          params(_: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Department)]))
-            .returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::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::Sandbox::CompanyUpdateResponse::Entity)) }
-        def entity
-        end
+        attr_reader :entity
 
         sig do
-          params(_: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity))
-            .returns(T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity))
-        end
-        def entity=(_)
+          params(
+            entity: T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity, FinchAPI::Util::AnyHash))
+          )
+            .void
         end
+        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(
-            accounts: T.nilable(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account]),
-            departments: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Department)]),
+            accounts: T.nilable(
+              T::Array[T.any(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account, FinchAPI::Util::AnyHash)]
+            ),
+            departments: T.nilable(
+              T::Array[T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Department, FinchAPI::Util::AnyHash))]
+            ),
             ein: T.nilable(String),
-            entity: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity),
+            entity: T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateResponse::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(
-          accounts:,
-          departments:,
-          ein:,
-          entity:,
-          legal_name:,
-          locations:,
-          primary_email:,
-          primary_phone_number:
-        )
+        def self.new(accounts:, departments:, ein:, entity:, legal_name:, locations:, primary_email:, primary_phone_number:)
         end
 
         sig do
@@ -124,63 +82,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::Sandbox::CompanyUpdateResponse::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::Sandbox::CompanyUpdateResponse::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
@@ -189,7 +122,7 @@ module FinchAPI
                 {
                   account_name: T.nilable(String),
                   account_number: T.nilable(String),
-                  account_type: T.nilable(Symbol),
+                  account_type: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account::AccountType::TaggedSymbol),
                   institution_name: T.nilable(String),
                   routing_number: T.nilable(String)
                 }
@@ -198,46 +131,58 @@ 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::Sandbox::CompanyUpdateResponse::Account::AccountType) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account::AccountType::TaggedSymbol) }
 
-            CHECKING = T.let(:checking, T.nilable(Symbol))
-            SAVINGS = T.let(:savings, T.nilable(Symbol))
+            CHECKING =
+              T.let(:checking, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account::AccountType::TaggedSymbol)
+            SAVINGS =
+              T.let(:savings, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account::AccountType::TaggedSymbol)
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig do
+              override
+                .returns(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateResponse::Account::AccountType::TaggedSymbol])
+            end
             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::Sandbox::CompanyUpdateResponse::Department::Parent)) }
-          def parent
-          end
+          attr_reader :parent
 
           sig do
-            params(_: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Department::Parent))
-              .returns(T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Department::Parent))
-          end
-          def parent=(_)
+            params(
+              parent: T.nilable(
+                T.any(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Department::Parent, FinchAPI::Util::AnyHash)
+              )
+            )
+              .void
           end
+          attr_writer :parent
 
           sig do
             params(
               name: T.nilable(String),
-              parent: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::Department::Parent)
+              parent: T.nilable(
+                T.any(FinchAPI::Models::Sandbox::CompanyUpdateResponse::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
@@ -253,16 +198,13 @@ module FinchAPI
           end
 
           class Parent < FinchAPI::BaseModel
+            # The parent department's name.
             sig { returns(T.nilable(String)) }
-            def name
-            end
-
-            sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-            def name=(_)
-            end
+            attr_accessor :name
 
-            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)}) }
@@ -272,54 +214,83 @@ 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::Sandbox::CompanyUpdateResponse::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::Sandbox::CompanyUpdateResponse::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::Sandbox::CompanyUpdateResponse::Entity::Subtype::OrSymbol),
+              type: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::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::Sandbox::CompanyUpdateResponse::Entity::Subtype::TaggedSymbol),
+                  type: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateResponse::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
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Subtype) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Subtype::TaggedSymbol) }
 
-            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))
+            S_CORPORATION =
+              T.let(:s_corporation, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Subtype::TaggedSymbol)
+            C_CORPORATION =
+              T.let(:c_corporation, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Subtype::TaggedSymbol)
+            B_CORPORATION =
+              T.let(:b_corporation, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Subtype::TaggedSymbol)
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig do
+              override.returns(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Subtype::TaggedSymbol])
+            end
             def self.values
             end
           end
 
-          class Type < FinchAPI::Enum
-            abstract!
-
-            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))
-
-            sig { override.returns(T::Array[Symbol]) }
+          # The tax payer type of the company.
+          module Type
+            extend FinchAPI::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type::TaggedSymbol) }
+
+            LLC = T.let(:llc, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type::TaggedSymbol)
+            LP = T.let(:lp, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type::TaggedSymbol)
+            CORPORATION =
+              T.let(:corporation, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type::TaggedSymbol)
+            SOLE_PROPRIETOR =
+              T.let(:sole_proprietor, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type::TaggedSymbol)
+            NON_PROFIT =
+              T.let(:non_profit, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type::TaggedSymbol)
+            PARTNERSHIP =
+              T.let(:partnership, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type::TaggedSymbol)
+            COOPERATIVE =
+              T.let(:cooperative, FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type::TaggedSymbol)
+
+            sig { override.returns(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateResponse::Entity::Type::TaggedSymbol]) }
             def self.values
             end
           end

data/rbi/lib/finch-api/models/sandbox/connection_create_params.rbi

@@ -7,55 +7,47 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # The provider associated with the connection
         sig { returns(String) }
-        def provider_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def provider_id=(_)
-        end
+        attr_accessor :provider_id
 
-        sig { returns(T.nilable(Symbol)) }
-        def authentication_type
-        end
+        sig { returns(T.nilable(FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::OrSymbol)) }
+        attr_reader :authentication_type
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def authentication_type=(_)
+        sig do
+          params(
+            authentication_type: FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::OrSymbol
+          )
+            .void
         end
+        attr_writer :authentication_type
 
+        # Optional: the size of the employer to be created with this connection. Defaults
+        #   to 20. Note that if this is higher than 100, historical payroll data will not be
+        #   generated, and instead only one pay period will be created.
         sig { returns(T.nilable(Integer)) }
-        def employee_size
-        end
+        attr_reader :employee_size
 
-        sig { params(_: Integer).returns(Integer) }
-        def employee_size=(_)
-        end
+        sig { params(employee_size: Integer).void }
+        attr_writer :employee_size
 
         sig { returns(T.nilable(T::Array[String])) }
-        def products
-        end
+        attr_reader :products
 
-        sig { params(_: T::Array[String]).returns(T::Array[String]) }
-        def products=(_)
-        end
+        sig { params(products: T::Array[String]).void }
+        attr_writer :products
 
         sig do
           params(
             provider_id: String,
-            authentication_type: Symbol,
+            authentication_type: FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::OrSymbol,
             employee_size: Integer,
             products: T::Array[String],
-            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(
-          provider_id:,
-          authentication_type: nil,
-          employee_size: nil,
-          products: nil,
-          request_options: {}
-        )
+        def self.new(provider_id:, authentication_type: nil, employee_size: nil, products: nil, request_options: {})
         end
 
         sig do
@@ -63,7 +55,7 @@ module FinchAPI
             .returns(
               {
                 provider_id: String,
-                authentication_type: Symbol,
+                authentication_type: FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::OrSymbol,
                 employee_size: Integer,
                 products: T::Array[String],
                 request_options: FinchAPI::RequestOptions
@@ -73,15 +65,27 @@ module FinchAPI
         def to_hash
         end
 
-        class AuthenticationType < FinchAPI::Enum
-          abstract!
+        module AuthenticationType
+          extend FinchAPI::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::TaggedSymbol) }
 
-          CREDENTIAL = :credential
-          API_TOKEN = :api_token
-          OAUTH = :oauth
-          ASSISTED = :assisted
+          CREDENTIAL =
+            T.let(:credential, FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::TaggedSymbol)
+          API_TOKEN =
+            T.let(:api_token, FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::TaggedSymbol)
+          OAUTH =
+            T.let(:oauth, FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::TaggedSymbol)
+          ASSISTED =
+            T.let(:assisted, FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig do
+            override
+              .returns(T::Array[FinchAPI::Models::Sandbox::ConnectionCreateParams::AuthenticationType::TaggedSymbol])
+          end
           def self.values
           end
         end