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

data/rbi/lib/finch-api/models/provider_list_params.rbi

@@ -6,8 +6,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/request_forwarding_forward_params.rbi

@@ -6,45 +6,32 @@ module FinchAPI
       extend FinchAPI::RequestParameters::Converter
       include FinchAPI::RequestParameters
 
+      # The HTTP method for the forwarded request. Valid values include: `GET` , `POST`
+      #   , `PUT` , `DELETE` , and `PATCH`.
       sig { returns(String) }
-      def method_
-      end
-
-      sig { params(_: String).returns(String) }
-      def method_=(_)
-      end
+      attr_accessor :method_
 
+      # The URL route path for the forwarded request. This value must begin with a
+      #   forward-slash ( / ) and may only contain alphanumeric characters, hyphens, and
+      #   underscores.
       sig { returns(String) }
-      def route
-      end
-
-      sig { params(_: String).returns(String) }
-      def route=(_)
-      end
+      attr_accessor :route
 
+      # The body for the forwarded request. This value must be specified as either a
+      #   string or a valid JSON object.
       sig { returns(T.nilable(String)) }
-      def data
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def data=(_)
-      end
+      attr_accessor :data
 
+      # The HTTP headers to include on the forwarded request. This value must be
+      #   specified as an object of key-value pairs. Example:
+      #   `{"Content-Type": "application/xml", "X-API-Version": "v1" }`
       sig { returns(T.nilable(T.anything)) }
-      def headers
-      end
-
-      sig { params(_: T.nilable(T.anything)).returns(T.nilable(T.anything)) }
-      def headers=(_)
-      end
+      attr_accessor :headers
 
+      # The query parameters for the forwarded request. This value must be specified as
+      #   a valid JSON object rather than a query string.
       sig { returns(T.nilable(T.anything)) }
-      def params
-      end
-
-      sig { params(_: T.nilable(T.anything)).returns(T.nilable(T.anything)) }
-      def params=(_)
-      end
+      attr_accessor :params
 
       sig do
         params(
@@ -53,11 +40,11 @@ module FinchAPI
           data: T.nilable(String),
           headers: T.nilable(T.anything),
           params: T.nilable(T.anything),
-          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(method_:, route:, data: nil, headers: nil, params: nil, request_options: {})
+      def self.new(method_:, route:, data: nil, headers: nil, params: nil, request_options: {})
       end
 
       sig do

data/rbi/lib/finch-api/models/request_forwarding_forward_response.rbi

@@ -3,51 +3,45 @@
 module FinchAPI
   module Models
     class RequestForwardingForwardResponse < FinchAPI::BaseModel
+      # A string representation of the HTTP response body of the forwarded request’s
+      #   response received from the underlying integration’s API. This field may be null
+      #   in the case where the upstream system’s response is empty.
       sig { returns(T.nilable(String)) }
-      def data
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def data=(_)
-      end
+      attr_accessor :data
 
+      # The HTTP headers of the forwarded request’s response, exactly as received from
+      #   the underlying integration’s API.
       sig { returns(T.nilable(T.anything)) }
-      def headers
-      end
-
-      sig { params(_: T.nilable(T.anything)).returns(T.nilable(T.anything)) }
-      def headers=(_)
-      end
+      attr_accessor :headers
 
+      # An object containing details of your original forwarded request, for your ease
+      #   of reference.
       sig { returns(FinchAPI::Models::RequestForwardingForwardResponse::Request) }
-      def request
-      end
+      attr_reader :request
 
       sig do
-        params(_: FinchAPI::Models::RequestForwardingForwardResponse::Request)
-          .returns(FinchAPI::Models::RequestForwardingForwardResponse::Request)
-      end
-      def request=(_)
+        params(
+          request: T.any(FinchAPI::Models::RequestForwardingForwardResponse::Request, FinchAPI::Util::AnyHash)
+        )
+          .void
       end
+      attr_writer :request
 
+      # The HTTP status code of the forwarded request’s response, exactly received from
+      #   the underlying integration’s API. This value will be returned as an integer.
       sig { returns(Integer) }
-      def status_code
-      end
-
-      sig { params(_: Integer).returns(Integer) }
-      def status_code=(_)
-      end
+      attr_accessor :status_code
 
       sig do
         params(
           data: T.nilable(String),
           headers: T.nilable(T.anything),
-          request: FinchAPI::Models::RequestForwardingForwardResponse::Request,
+          request: T.any(FinchAPI::Models::RequestForwardingForwardResponse::Request, FinchAPI::Util::AnyHash),
           status_code: Integer
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(data:, headers:, request:, status_code:)
+      def self.new(data:, headers:, request:, status_code:)
       end
 
       sig do
@@ -65,46 +59,33 @@ module FinchAPI
       end
 
       class Request < FinchAPI::BaseModel
+        # The body that was specified for the forwarded request. If a value was not
+        #   specified in the original request, this value will be returned as null ;
+        #   otherwise, this value will always be returned as a string.
         sig { returns(T.nilable(String)) }
-        def data
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def data=(_)
-        end
+        attr_accessor :data
 
+        # The specified HTTP headers that were included in the forwarded request. If no
+        #   headers were specified, this will be returned as `null`.
         sig { returns(T.nilable(T.anything)) }
-        def headers
-        end
-
-        sig { params(_: T.nilable(T.anything)).returns(T.nilable(T.anything)) }
-        def headers=(_)
-        end
+        attr_accessor :headers
 
+        # The HTTP method that was specified for the forwarded request. Valid values
+        #   include: `GET` , `POST` , `PUT` , `DELETE` , and `PATCH`.
         sig { returns(String) }
-        def method_
-        end
-
-        sig { params(_: String).returns(String) }
-        def method_=(_)
-        end
+        attr_accessor :method_
 
+        # The query parameters that were included in the forwarded request. If no query
+        #   parameters were specified, this will be returned as `null`.
         sig { returns(T.nilable(T.anything)) }
-        def params
-        end
-
-        sig { params(_: T.nilable(T.anything)).returns(T.nilable(T.anything)) }
-        def params=(_)
-        end
+        attr_accessor :params
 
+        # The URL route path that was specified for the forwarded request.
         sig { returns(String) }
-        def route
-        end
-
-        sig { params(_: String).returns(String) }
-        def route=(_)
-        end
+        attr_accessor :route
 
+        # An object containing details of your original forwarded request, for your ease
+        #   of reference.
         sig do
           params(
             data: T.nilable(String),
@@ -113,9 +94,9 @@ module FinchAPI
             params: T.nilable(T.anything),
             route: String
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(data:, headers:, method_:, params:, route:)
+        def self.new(data:, headers:, method_:, params:, route:)
         end
 
         sig do

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

@@ -7,97 +7,64 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # An array of bank account objects associated with the payroll/HRIS system.
         sig { returns(T.nilable(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateParams::Account])) }
-        def accounts
-        end
-
-        sig do
-          params(_: T.nilable(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateParams::Account]))
-            .returns(T.nilable(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateParams::Account]))
-        end
-        def accounts=(_)
-        end
+        attr_accessor :accounts
 
+        # The array of company departments.
         sig { returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department)])) }
-        def departments
-        end
-
-        sig do
-          params(_: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department)]))
-            .returns(T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::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::CompanyUpdateParams::Entity)) }
-        def entity
-        end
+        attr_reader :entity
 
         sig do
-          params(_: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity))
-            .returns(T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity))
-        end
-        def entity=(_)
+          params(
+            entity: T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::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::CompanyUpdateParams::Account]),
-            departments: T.nilable(T::Array[T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department)]),
+            accounts: T.nilable(
+              T::Array[T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::Account, FinchAPI::Util::AnyHash)]
+            ),
+            departments: T.nilable(
+              T::Array[T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department, FinchAPI::Util::AnyHash))]
+            ),
             ein: T.nilable(String),
-            entity: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity),
+            entity: T.nilable(T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::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),
-            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(
+        def self.new(
           accounts:,
           departments:,
           ein:,
@@ -130,63 +97,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
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def account_number=(_)
-          end
-
-          sig { returns(T.nilable(Symbol)) }
-          def account_type
-          end
+          attr_accessor :account_number
 
-          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::CompanyUpdateParams::Account::AccountType::OrSymbol)) }
+          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::CompanyUpdateParams::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
@@ -195,7 +137,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::CompanyUpdateParams::Account::AccountType::OrSymbol),
                   institution_name: T.nilable(String),
                   routing_number: T.nilable(String)
                 }
@@ -204,46 +146,58 @@ module FinchAPI
           def to_hash
           end
 
-          class AccountType < FinchAPI::Enum
-            abstract!
+          # The type of bank account.
+          module AccountType
+            extend FinchAPI::Enum
 
-            CHECKING = T.let(:checking, T.nilable(Symbol))
-            SAVINGS = T.let(:savings, T.nilable(Symbol))
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::CompanyUpdateParams::Account::AccountType) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::CompanyUpdateParams::Account::AccountType::TaggedSymbol) }
 
-            sig { override.returns(T::Array[Symbol]) }
+            CHECKING =
+              T.let(:checking, FinchAPI::Models::Sandbox::CompanyUpdateParams::Account::AccountType::TaggedSymbol)
+            SAVINGS =
+              T.let(:savings, FinchAPI::Models::Sandbox::CompanyUpdateParams::Account::AccountType::TaggedSymbol)
+
+            sig do
+              override
+                .returns(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateParams::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::CompanyUpdateParams::Department::Parent)) }
-          def parent
-          end
+          attr_reader :parent
 
           sig do
-            params(_: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department::Parent))
-              .returns(T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department::Parent))
-          end
-          def parent=(_)
+            params(
+              parent: T.nilable(
+                T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department::Parent, FinchAPI::Util::AnyHash)
+              )
+            )
+              .void
           end
+          attr_writer :parent
 
           sig do
             params(
               name: T.nilable(String),
-              parent: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Department::Parent)
+              parent: T.nilable(
+                T.any(FinchAPI::Models::Sandbox::CompanyUpdateParams::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
@@ -259,16 +213,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)}) }
@@ -278,54 +229,81 @@ 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::CompanyUpdateParams::Entity::Subtype::OrSymbol)) }
+          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::CompanyUpdateParams::Entity::Type::OrSymbol)) }
+          attr_accessor :type
 
-          sig { returns(T.nilable(Symbol)) }
-          def type
+          # The entity type object.
+          sig do
+            params(
+              subtype: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Subtype::OrSymbol),
+              type: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::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::CompanyUpdateParams::Entity::Subtype::OrSymbol),
+                  type: T.nilable(FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::OrSymbol)
+                }
+              )
           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::CompanyUpdateParams::Entity::Subtype) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::CompanyUpdateParams::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::CompanyUpdateParams::Entity::Subtype::TaggedSymbol)
+            C_CORPORATION =
+              T.let(:c_corporation, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Subtype::TaggedSymbol)
+            B_CORPORATION =
+              T.let(:b_corporation, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Subtype::TaggedSymbol)
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig { override.returns(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Subtype::TaggedSymbol]) }
             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::CompanyUpdateParams::Entity::Type) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::TaggedSymbol) }
+
+            LLC = T.let(:llc, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::TaggedSymbol)
+            LP = T.let(:lp, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::TaggedSymbol)
+            CORPORATION =
+              T.let(:corporation, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::TaggedSymbol)
+            SOLE_PROPRIETOR =
+              T.let(:sole_proprietor, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::TaggedSymbol)
+            NON_PROFIT =
+              T.let(:non_profit, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::TaggedSymbol)
+            PARTNERSHIP =
+              T.let(:partnership, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::TaggedSymbol)
+            COOPERATIVE =
+              T.let(:cooperative, FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::TaggedSymbol)
+
+            sig { override.returns(T::Array[FinchAPI::Models::Sandbox::CompanyUpdateParams::Entity::Type::TaggedSymbol]) }
             def self.values
             end
           end