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

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

@@ -3,32 +3,26 @@
 module FinchAPI
   module Models
     class BaseWebhookEvent < FinchAPI::BaseModel
+      # [DEPRECATED] Unique Finch ID of the employer account used to make this
+      #   connection. Use `connection_id` instead to identify the connection associated
+      #   with this event.
       sig { returns(String) }
-      def account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def account_id=(_)
-      end
+      attr_accessor :account_id
 
+      # [DEPRECATED] Unique Finch ID of the company for which data has been updated. Use
+      #   `connection_id` instead to identify the connection associated with this event.
       sig { returns(String) }
-      def company_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def company_id=(_)
-      end
+      attr_accessor :company_id
 
+      # Unique Finch ID of the connection associated with the webhook event.
       sig { returns(T.nilable(String)) }
-      def connection_id
-      end
+      attr_reader :connection_id
 
-      sig { params(_: String).returns(String) }
-      def connection_id=(_)
-      end
+      sig { params(connection_id: String).void }
+      attr_writer :connection_id
 
-      sig { params(account_id: String, company_id: String, connection_id: String).void }
-      def initialize(account_id:, company_id:, connection_id: nil)
+      sig { params(account_id: String, company_id: String, connection_id: String).returns(T.attached_class) }
+      def self.new(account_id:, company_id:, connection_id: nil)
       end
 
       sig { override.returns({account_id: String, company_id: String, connection_id: String}) }

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

@@ -4,37 +4,45 @@ module FinchAPI
   module Models
     class CompanyEvent < FinchAPI::Models::BaseWebhookEvent
       sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-      def data
-      end
+      attr_accessor :data
 
-      sig do
-        params(_: T.nilable(T::Hash[Symbol, T.anything])).returns(T.nilable(T::Hash[Symbol, T.anything]))
-      end
-      def data=(_)
-      end
+      sig { returns(T.nilable(FinchAPI::Models::CompanyEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
 
-      sig { returns(T.nilable(Symbol)) }
-      def event_type
-      end
+      sig { params(event_type: FinchAPI::Models::CompanyEvent::EventType::OrSymbol).void }
+      attr_writer :event_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def event_type=(_)
+      sig do
+        params(
+          data: T.nilable(T::Hash[Symbol, T.anything]),
+          event_type: FinchAPI::Models::CompanyEvent::EventType::OrSymbol
+        )
+          .returns(T.attached_class)
       end
-
-      sig { params(data: T.nilable(T::Hash[Symbol, T.anything]), event_type: Symbol).void }
-      def initialize(data: nil, event_type: nil)
+      def self.new(data: nil, event_type: nil)
       end
 
-      sig { override.returns({data: T.nilable(T::Hash[Symbol, T.anything]), event_type: Symbol}) }
+      sig do
+        override
+          .returns(
+            {
+              data: T.nilable(T::Hash[Symbol, T.anything]),
+              event_type: FinchAPI::Models::CompanyEvent::EventType::TaggedSymbol
+            }
+          )
+      end
       def to_hash
       end
 
-      class EventType < FinchAPI::Enum
-        abstract!
+      module EventType
+        extend FinchAPI::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::CompanyEvent::EventType) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::CompanyEvent::EventType::TaggedSymbol) }
 
-        COMPANY_UPDATED = :"company.updated"
+        COMPANY_UPDATED = T.let(:"company.updated", FinchAPI::Models::CompanyEvent::EventType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::CompanyEvent::EventType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/finch-api/models/connect/session_new_params.rbi

@@ -8,96 +8,58 @@ module FinchAPI
         include FinchAPI::RequestParameters
 
         sig { returns(String) }
-        def customer_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def customer_id=(_)
-        end
+        attr_accessor :customer_id
 
         sig { returns(String) }
-        def customer_name
-        end
+        attr_accessor :customer_name
 
-        sig { params(_: String).returns(String) }
-        def customer_name=(_)
-        end
-
-        sig { returns(T::Array[Symbol]) }
-        def products
-        end
-
-        sig { params(_: T::Array[Symbol]).returns(T::Array[Symbol]) }
-        def products=(_)
-        end
+        sig { returns(T::Array[FinchAPI::Models::Connect::SessionNewParams::Product::OrSymbol]) }
+        attr_accessor :products
 
         sig { returns(T.nilable(String)) }
-        def customer_email
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def customer_email=(_)
-        end
+        attr_accessor :customer_email
 
         sig { returns(T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration)) }
-        def integration
-        end
+        attr_reader :integration
 
         sig do
-          params(_: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration))
-            .returns(T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration))
-        end
-        def integration=(_)
+          params(
+            integration: T.nilable(T.any(FinchAPI::Models::Connect::SessionNewParams::Integration, FinchAPI::Util::AnyHash))
+          )
+            .void
         end
+        attr_writer :integration
 
         sig { returns(T.nilable(T::Boolean)) }
-        def manual
-        end
-
-        sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-        def manual=(_)
-        end
+        attr_accessor :manual
 
+        # The number of minutes until the session expires (defaults to 43,200, which is 30
+        #   days)
         sig { returns(T.nilable(Float)) }
-        def minutes_to_expire
-        end
-
-        sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
-        def minutes_to_expire=(_)
-        end
+        attr_accessor :minutes_to_expire
 
         sig { returns(T.nilable(String)) }
-        def redirect_uri
-        end
+        attr_accessor :redirect_uri
 
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def redirect_uri=(_)
-        end
-
-        sig { returns(T.nilable(Symbol)) }
-        def sandbox
-        end
-
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def sandbox=(_)
-        end
+        sig { returns(T.nilable(FinchAPI::Models::Connect::SessionNewParams::Sandbox::OrSymbol)) }
+        attr_accessor :sandbox
 
         sig do
           params(
             customer_id: String,
             customer_name: String,
-            products: T::Array[Symbol],
+            products: T::Array[FinchAPI::Models::Connect::SessionNewParams::Product::OrSymbol],
             customer_email: T.nilable(String),
-            integration: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration),
+            integration: T.nilable(T.any(FinchAPI::Models::Connect::SessionNewParams::Integration, FinchAPI::Util::AnyHash)),
             manual: T.nilable(T::Boolean),
             minutes_to_expire: T.nilable(Float),
             redirect_uri: T.nilable(String),
-            sandbox: T.nilable(Symbol),
-            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            sandbox: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Sandbox::OrSymbol),
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           customer_id:,
           customer_name:,
           products:,
@@ -117,13 +79,13 @@ module FinchAPI
               {
                 customer_id: String,
                 customer_name: String,
-                products: T::Array[Symbol],
+                products: T::Array[FinchAPI::Models::Connect::SessionNewParams::Product::OrSymbol],
                 customer_email: T.nilable(String),
                 integration: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration),
                 manual: T.nilable(T::Boolean),
                 minutes_to_expire: T.nilable(Float),
                 redirect_uri: T.nilable(String),
-                sandbox: T.nilable(Symbol),
+                sandbox: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Sandbox::OrSymbol),
                 request_options: FinchAPI::RequestOptions
               }
             )
@@ -131,69 +93,93 @@ module FinchAPI
         def to_hash
         end
 
-        class Product < FinchAPI::Enum
-          abstract!
+        # The Finch products that can be requested during the Connect flow.
+        module Product
+          extend FinchAPI::Enum
 
-          COMPANY = :company
-          DIRECTORY = :directory
-          INDIVIDUAL = :individual
-          EMPLOYMENT = :employment
-          PAYMENT = :payment
-          PAY_STATEMENT = :pay_statement
-          BENEFITS = :benefits
-          SSN = :ssn
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Connect::SessionNewParams::Product) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol) }
 
-          sig { override.returns(T::Array[Symbol]) }
+          COMPANY = T.let(:company, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol)
+          DIRECTORY = T.let(:directory, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol)
+          INDIVIDUAL = T.let(:individual, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol)
+          EMPLOYMENT = T.let(:employment, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol)
+          PAYMENT = T.let(:payment, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol)
+          PAY_STATEMENT = T.let(:pay_statement, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol)
+          BENEFITS = T.let(:benefits, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol)
+          SSN = T.let(:ssn, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol]) }
           def self.values
           end
         end
 
         class Integration < FinchAPI::BaseModel
-          sig { returns(T.nilable(Symbol)) }
-          def auth_method
-          end
-
-          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-          def auth_method=(_)
-          end
+          sig { returns(T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::OrSymbol)) }
+          attr_accessor :auth_method
 
           sig { returns(T.nilable(String)) }
-          def provider
-          end
+          attr_accessor :provider
 
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def provider=(_)
+          sig do
+            params(
+              auth_method: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::OrSymbol),
+              provider: T.nilable(String)
+            )
+              .returns(T.attached_class)
           end
-
-          sig { params(auth_method: T.nilable(Symbol), provider: T.nilable(String)).void }
-          def initialize(auth_method: nil, provider: nil)
+          def self.new(auth_method: nil, provider: nil)
           end
 
-          sig { override.returns({auth_method: T.nilable(Symbol), provider: T.nilable(String)}) }
+          sig do
+            override
+              .returns(
+                {
+                  auth_method: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::OrSymbol),
+                  provider: T.nilable(String)
+                }
+              )
+          end
           def to_hash
           end
 
-          class AuthMethod < FinchAPI::Enum
-            abstract!
-
-            ASSISTED = T.let(:assisted, T.nilable(Symbol))
-            CREDENTIAL = T.let(:credential, T.nilable(Symbol))
-            OAUTH = T.let(:oauth, T.nilable(Symbol))
-            API_TOKEN = T.let(:api_token, T.nilable(Symbol))
-
-            sig { override.returns(T::Array[Symbol]) }
+          module AuthMethod
+            extend FinchAPI::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::TaggedSymbol) }
+
+            ASSISTED =
+              T.let(:assisted, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::TaggedSymbol)
+            CREDENTIAL =
+              T.let(:credential, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::TaggedSymbol)
+            OAUTH = T.let(:oauth, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::TaggedSymbol)
+            API_TOKEN =
+              T.let(:api_token, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::TaggedSymbol)
+
+            sig do
+              override
+                .returns(T::Array[FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::TaggedSymbol])
+            end
             def self.values
             end
           end
         end
 
-        class Sandbox < FinchAPI::Enum
-          abstract!
+        module Sandbox
+          extend FinchAPI::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Connect::SessionNewParams::Sandbox) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::Connect::SessionNewParams::Sandbox::TaggedSymbol) }
 
-          FINCH = T.let(:finch, T.nilable(Symbol))
-          PROVIDER = T.let(:provider, T.nilable(Symbol))
+          FINCH = T.let(:finch, FinchAPI::Models::Connect::SessionNewParams::Sandbox::TaggedSymbol)
+          PROVIDER = T.let(:provider, FinchAPI::Models::Connect::SessionNewParams::Sandbox::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::Connect::SessionNewParams::Sandbox::TaggedSymbol]) }
           def self.values
           end
         end

data/rbi/lib/finch-api/models/connect/session_new_response.rbi

@@ -4,24 +4,16 @@ module FinchAPI
   module Models
     module Connect
       class SessionNewResponse < FinchAPI::BaseModel
+        # The Connect URL to redirect the user to for authentication
         sig { returns(String) }
-        def connect_url
-        end
-
-        sig { params(_: String).returns(String) }
-        def connect_url=(_)
-        end
+        attr_accessor :connect_url
 
+        # The unique identifier for the created connect session
         sig { returns(String) }
-        def session_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def session_id=(_)
-        end
+        attr_accessor :session_id
 
-        sig { params(connect_url: String, session_id: String).void }
-        def initialize(connect_url:, session_id:)
+        sig { params(connect_url: String, session_id: String).returns(T.attached_class) }
+        def self.new(connect_url:, session_id:)
         end
 
         sig { override.returns({connect_url: String, session_id: String}) }

data/rbi/lib/finch-api/models/connect/session_reauthenticate_params.rbi

@@ -7,55 +7,34 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # The ID of the existing connection to reauthenticate
         sig { returns(String) }
-        def connection_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def connection_id=(_)
-        end
+        attr_accessor :connection_id
 
+        # The number of minutes until the session expires (defaults to 43,200, which is 30
+        #   days)
         sig { returns(T.nilable(Integer)) }
-        def minutes_to_expire
-        end
+        attr_accessor :minutes_to_expire
 
-        sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-        def minutes_to_expire=(_)
-        end
-
-        sig { returns(T.nilable(T::Array[Symbol])) }
-        def products
-        end
-
-        sig { params(_: T.nilable(T::Array[Symbol])).returns(T.nilable(T::Array[Symbol])) }
-        def products=(_)
-        end
+        # The products to request access to (optional for reauthentication)
+        sig { returns(T.nilable(T::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::OrSymbol])) }
+        attr_accessor :products
 
+        # The URI to redirect to after the Connect flow is completed
         sig { returns(T.nilable(String)) }
-        def redirect_uri
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def redirect_uri=(_)
-        end
+        attr_accessor :redirect_uri
 
         sig do
           params(
             connection_id: String,
             minutes_to_expire: T.nilable(Integer),
-            products: T.nilable(T::Array[Symbol]),
+            products: T.nilable(T::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::OrSymbol]),
             redirect_uri: 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(
-          connection_id:,
-          minutes_to_expire: nil,
-          products: nil,
-          redirect_uri: nil,
-          request_options: {}
-        )
+        def self.new(connection_id:, minutes_to_expire: nil, products: nil, redirect_uri: nil, request_options: {})
         end
 
         sig do
@@ -64,7 +43,7 @@ module FinchAPI
               {
                 connection_id: String,
                 minutes_to_expire: T.nilable(Integer),
-                products: T.nilable(T::Array[Symbol]),
+                products: T.nilable(T::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::OrSymbol]),
                 redirect_uri: T.nilable(String),
                 request_options: FinchAPI::RequestOptions
               }
@@ -73,19 +52,30 @@ module FinchAPI
         def to_hash
         end
 
-        class Product < FinchAPI::Enum
-          abstract!
+        # The Finch products that can be requested during the Connect flow.
+        module Product
+          extend FinchAPI::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, FinchAPI::Models::Connect::SessionReauthenticateParams::Product) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol) }
 
-          COMPANY = :company
-          DIRECTORY = :directory
-          INDIVIDUAL = :individual
-          EMPLOYMENT = :employment
-          PAYMENT = :payment
-          PAY_STATEMENT = :pay_statement
-          BENEFITS = :benefits
-          SSN = :ssn
+          COMPANY = T.let(:company, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
+          DIRECTORY =
+            T.let(:directory, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
+          INDIVIDUAL =
+            T.let(:individual, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
+          EMPLOYMENT =
+            T.let(:employment, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
+          PAYMENT = T.let(:payment, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
+          PAY_STATEMENT =
+            T.let(:pay_statement, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
+          BENEFITS =
+            T.let(:benefits, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
+          SSN = T.let(:ssn, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol]) }
           def self.values
           end
         end

data/rbi/lib/finch-api/models/connect/session_reauthenticate_response.rbi

@@ -4,24 +4,16 @@ module FinchAPI
   module Models
     module Connect
       class SessionReauthenticateResponse < FinchAPI::BaseModel
+        # The Connect URL to redirect the user to for reauthentication
         sig { returns(String) }
-        def connect_url
-        end
-
-        sig { params(_: String).returns(String) }
-        def connect_url=(_)
-        end
+        attr_accessor :connect_url
 
+        # The unique identifier for the created connect session
         sig { returns(String) }
-        def session_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def session_id=(_)
-        end
+        attr_accessor :session_id
 
-        sig { params(connect_url: String, session_id: String).void }
-        def initialize(connect_url:, session_id:)
+        sig { params(connect_url: String, session_id: String).returns(T.attached_class) }
+        def self.new(connect_url:, session_id:)
         end
 
         sig { override.returns({connect_url: String, session_id: String}) }

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

@@ -2,17 +2,21 @@
 
 module FinchAPI
   module Models
-    class ConnectionStatusType < FinchAPI::Enum
-      abstract!
+    module ConnectionStatusType
+      extend FinchAPI::Enum
 
-      PENDING = :pending
-      PROCESSING = :processing
-      CONNECTED = :connected
-      ERROR_NO_ACCOUNT_SETUP = :error_no_account_setup
-      ERROR_PERMISSIONS = :error_permissions
-      REAUTH = :reauth
+      TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::ConnectionStatusType) }
+      OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::ConnectionStatusType::TaggedSymbol) }
 
-      sig { override.returns(T::Array[Symbol]) }
+      PENDING = T.let(:pending, FinchAPI::Models::ConnectionStatusType::TaggedSymbol)
+      PROCESSING = T.let(:processing, FinchAPI::Models::ConnectionStatusType::TaggedSymbol)
+      CONNECTED = T.let(:connected, FinchAPI::Models::ConnectionStatusType::TaggedSymbol)
+      ERROR_NO_ACCOUNT_SETUP =
+        T.let(:error_no_account_setup, FinchAPI::Models::ConnectionStatusType::TaggedSymbol)
+      ERROR_PERMISSIONS = T.let(:error_permissions, FinchAPI::Models::ConnectionStatusType::TaggedSymbol)
+      REAUTH = T.let(:reauth, FinchAPI::Models::ConnectionStatusType::TaggedSymbol)
+
+      sig { override.returns(T::Array[FinchAPI::Models::ConnectionStatusType::TaggedSymbol]) }
       def self.values
       end
     end