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

data/rbi/finch_api/models/base_webhook_event.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class BaseWebhookEvent < FinchAPI::Internal::Type::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) }
+      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) }
+      attr_accessor :company_id
+
+      # Unique Finch ID of the connection associated with the webhook event.
+      sig { returns(T.nilable(String)) }
+      attr_reader :connection_id
+
+      sig { params(connection_id: String).void }
+      attr_writer :connection_id
+
+      sig { params(account_id: String, company_id: String, connection_id: String).returns(T.attached_class) }
+      def self.new(
+        # [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.
+        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.
+        company_id:,
+        # Unique Finch ID of the connection associated with the webhook event.
+        connection_id: nil
+      ); end
+      sig { override.returns({account_id: String, company_id: String, connection_id: String}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/finch_api/models/company_event.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class CompanyEvent < FinchAPI::Models::BaseWebhookEvent
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :data
+
+      sig { returns(T.nilable(FinchAPI::Models::CompanyEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
+
+      sig { params(event_type: FinchAPI::Models::CompanyEvent::EventType::OrSymbol).void }
+      attr_writer :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
+      def self.new(data: nil, event_type: nil); end
+
+      sig do
+        override
+          .returns(
+            {
+              data: T.nilable(T::Hash[Symbol, T.anything]),
+              event_type: FinchAPI::Models::CompanyEvent::EventType::TaggedSymbol
+            }
+          )
+      end
+      def to_hash; end
+
+      module EventType
+        extend FinchAPI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::CompanyEvent::EventType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        COMPANY_UPDATED = T.let(:"company.updated", FinchAPI::Models::CompanyEvent::EventType::TaggedSymbol)
+
+        sig { override.returns(T::Array[FinchAPI::Models::CompanyEvent::EventType::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/connect/session_new_params.rbi

@@ -0,0 +1,182 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Connect
+      class SessionNewParams < FinchAPI::Internal::Type::BaseModel
+        extend FinchAPI::Internal::Type::RequestParameters::Converter
+        include FinchAPI::Internal::Type::RequestParameters
+
+        sig { returns(String) }
+        attr_accessor :customer_id
+
+        sig { returns(String) }
+        attr_accessor :customer_name
+
+        sig { returns(T::Array[FinchAPI::Models::Connect::SessionNewParams::Product::OrSymbol]) }
+        attr_accessor :products
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :customer_email
+
+        sig { returns(T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration)) }
+        attr_reader :integration
+
+        sig do
+          params(
+            integration: T.nilable(T.any(FinchAPI::Models::Connect::SessionNewParams::Integration, FinchAPI::Internal::AnyHash))
+          )
+            .void
+        end
+        attr_writer :integration
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :manual
+
+        # The number of minutes until the session expires (defaults to 43,200, which is 30
+        # days)
+        sig { returns(T.nilable(Float)) }
+        attr_accessor :minutes_to_expire
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :redirect_uri
+
+        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[FinchAPI::Models::Connect::SessionNewParams::Product::OrSymbol],
+            customer_email: T.nilable(String),
+            integration: T.nilable(T.any(FinchAPI::Models::Connect::SessionNewParams::Integration, FinchAPI::Internal::AnyHash)),
+            manual: T.nilable(T::Boolean),
+            minutes_to_expire: T.nilable(Float),
+            redirect_uri: T.nilable(String),
+            sandbox: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Sandbox::OrSymbol),
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          customer_id:,
+          customer_name:,
+          products:,
+          customer_email: nil,
+          integration: nil,
+          manual: nil,
+          # The number of minutes until the session expires (defaults to 43,200, which is 30
+          # days)
+          minutes_to_expire: nil,
+          redirect_uri: nil,
+          sandbox: nil,
+          request_options: {}
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                customer_id: String,
+                customer_name: String,
+                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(FinchAPI::Models::Connect::SessionNewParams::Sandbox::OrSymbol),
+                request_options: FinchAPI::RequestOptions
+              }
+            )
+        end
+        def to_hash; end
+
+        # The Finch products that can be requested during the Connect flow.
+        module Product
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Connect::SessionNewParams::Product) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          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)
+          DEDUCTION = T.let(:deduction, FinchAPI::Models::Connect::SessionNewParams::Product::TaggedSymbol)
+          DOCUMENTS = T.let(:documents, 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::Internal::Type::BaseModel
+          sig { returns(T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::OrSymbol)) }
+          attr_accessor :auth_method
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :provider
+
+          sig do
+            params(
+              auth_method: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::OrSymbol),
+              provider: T.nilable(String)
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(auth_method: nil, provider: nil); end
+
+          sig do
+            override
+              .returns(
+                {
+                  auth_method: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod::OrSymbol),
+                  provider: T.nilable(String)
+                }
+              )
+          end
+          def to_hash; end
+
+          module AuthMethod
+            extend FinchAPI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod) }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            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
+
+        module Sandbox
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Connect::SessionNewParams::Sandbox) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          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[FinchAPI::Models::Connect::SessionNewParams::Sandbox::TaggedSymbol]) }
+          def self.values; end
+        end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/connect/session_new_response.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Connect
+      class SessionNewResponse < FinchAPI::Internal::Type::BaseModel
+        # The Connect URL to redirect the user to for authentication
+        sig { returns(String) }
+        attr_accessor :connect_url
+
+        # The unique identifier for the created connect session
+        sig { returns(String) }
+        attr_accessor :session_id
+
+        sig { params(connect_url: String, session_id: String).returns(T.attached_class) }
+        def self.new(
+          # The Connect URL to redirect the user to for authentication
+          connect_url:,
+          # The unique identifier for the created connect session
+          session_id:
+        ); end
+        sig { override.returns({connect_url: String, session_id: String}) }
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/connect/session_reauthenticate_params.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Connect
+      class SessionReauthenticateParams < FinchAPI::Internal::Type::BaseModel
+        extend FinchAPI::Internal::Type::RequestParameters::Converter
+        include FinchAPI::Internal::Type::RequestParameters
+
+        # The ID of the existing connection to reauthenticate
+        sig { returns(String) }
+        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)) }
+        attr_accessor :minutes_to_expire
+
+        # 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)) }
+        attr_accessor :redirect_uri
+
+        sig do
+          params(
+            connection_id: String,
+            minutes_to_expire: T.nilable(Integer),
+            products: T.nilable(T::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::OrSymbol]),
+            redirect_uri: T.nilable(String),
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # The ID of the existing connection to reauthenticate
+          connection_id:,
+          # The number of minutes until the session expires (defaults to 43,200, which is 30
+          # days)
+          minutes_to_expire: nil,
+          # The products to request access to (optional for reauthentication)
+          products: nil,
+          # The URI to redirect to after the Connect flow is completed
+          redirect_uri: nil,
+          request_options: {}
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                connection_id: String,
+                minutes_to_expire: T.nilable(Integer),
+                products: T.nilable(T::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::OrSymbol]),
+                redirect_uri: T.nilable(String),
+                request_options: FinchAPI::RequestOptions
+              }
+            )
+        end
+        def to_hash; end
+
+        # The Finch products that can be requested during the Connect flow.
+        module Product
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, FinchAPI::Models::Connect::SessionReauthenticateParams::Product) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          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)
+          DEDUCTION =
+            T.let(:deduction, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
+          DOCUMENTS =
+            T.let(:documents, FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol]) }
+          def self.values; end
+        end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/connect/session_reauthenticate_response.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Connect
+      class SessionReauthenticateResponse < FinchAPI::Internal::Type::BaseModel
+        # The Connect URL to redirect the user to for reauthentication
+        sig { returns(String) }
+        attr_accessor :connect_url
+
+        # The unique identifier for the created connect session
+        sig { returns(String) }
+        attr_accessor :session_id
+
+        sig { params(connect_url: String, session_id: String).returns(T.attached_class) }
+        def self.new(
+          # The Connect URL to redirect the user to for reauthentication
+          connect_url:,
+          # The unique identifier for the created connect session
+          session_id:
+        ); end
+        sig { override.returns({connect_url: String, session_id: String}) }
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/connection_status_type.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module ConnectionStatusType
+      extend FinchAPI::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::ConnectionStatusType) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      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
+  end
+end

data/rbi/finch_api/models/create_access_token_response.rbi

@@ -0,0 +1,151 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class CreateAccessTokenResponse < FinchAPI::Internal::Type::BaseModel
+      # The access token for the connection.
+      sig { returns(String) }
+      attr_accessor :access_token
+
+      # [DEPRECATED] Use `connection_id` to identify the connection instead of this
+      # account ID.
+      sig { returns(String) }
+      attr_accessor :account_id
+
+      # The type of application associated with a token.
+      sig { returns(FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol) }
+      attr_accessor :client_type
+
+      # [DEPRECATED] Use `connection_id` to identify the connection instead of this
+      # company ID.
+      sig { returns(String) }
+      attr_accessor :company_id
+
+      # The Finch UUID of the connection associated with the `access_token`.
+      sig { returns(String) }
+      attr_accessor :connection_id
+
+      # The type of the connection associated with the token.
+      #
+      # - `provider` - connection to an external provider
+      # - `finch` - finch-generated data.
+      sig { returns(FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol) }
+      attr_accessor :connection_type
+
+      # An array of the authorized products associated with the `access_token`.
+      sig { returns(T::Array[String]) }
+      attr_accessor :products
+
+      # The ID of the provider associated with the `access_token`.
+      sig { returns(String) }
+      attr_accessor :provider_id
+
+      # The ID of your customer you provided to Finch when a connect session was created
+      # for this connection.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_id
+
+      # The RFC 8693 token type (Finch uses `bearer` tokens)
+      sig { returns(T.nilable(String)) }
+      attr_reader :token_type
+
+      sig { params(token_type: String).void }
+      attr_writer :token_type
+
+      sig do
+        params(
+          access_token: String,
+          account_id: String,
+          client_type: FinchAPI::Models::CreateAccessTokenResponse::ClientType::OrSymbol,
+          company_id: String,
+          connection_id: String,
+          connection_type: FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::OrSymbol,
+          products: T::Array[String],
+          provider_id: String,
+          customer_id: T.nilable(String),
+          token_type: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # The access token for the connection.
+        access_token:,
+        # [DEPRECATED] Use `connection_id` to identify the connection instead of this
+        # account ID.
+        account_id:,
+        # The type of application associated with a token.
+        client_type:,
+        # [DEPRECATED] Use `connection_id` to identify the connection instead of this
+        # company ID.
+        company_id:,
+        # The Finch UUID of the connection associated with the `access_token`.
+        connection_id:,
+        # The type of the connection associated with the token.
+        #
+        # - `provider` - connection to an external provider
+        # - `finch` - finch-generated data.
+        connection_type:,
+        # An array of the authorized products associated with the `access_token`.
+        products:,
+        # The ID of the provider associated with the `access_token`.
+        provider_id:,
+        # The ID of your customer you provided to Finch when a connect session was created
+        # for this connection.
+        customer_id: nil,
+        # The RFC 8693 token type (Finch uses `bearer` tokens)
+        token_type: nil
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              access_token: String,
+              account_id: String,
+              client_type: FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol,
+              company_id: String,
+              connection_id: String,
+              connection_type: FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol,
+              products: T::Array[String],
+              provider_id: String,
+              customer_id: T.nilable(String),
+              token_type: String
+            }
+          )
+      end
+      def to_hash; end
+
+      # The type of application associated with a token.
+      module ClientType
+        extend FinchAPI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::CreateAccessTokenResponse::ClientType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PRODUCTION = T.let(:production, FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol)
+        DEVELOPMENT = T.let(:development, FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol)
+        SANDBOX = T.let(:sandbox, FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol)
+
+        sig { override.returns(T::Array[FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol]) }
+        def self.values; end
+      end
+
+      # The type of the connection associated with the token.
+      #
+      # - `provider` - connection to an external provider
+      # - `finch` - finch-generated data.
+      module ConnectionType
+        extend FinchAPI::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PROVIDER = T.let(:provider, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol)
+        FINCH = T.let(:finch, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol)
+
+        sig { override.returns(T::Array[FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/directory_event.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class DirectoryEvent < FinchAPI::Models::BaseWebhookEvent
+      sig { returns(T.nilable(FinchAPI::Models::DirectoryEvent::Data)) }
+      attr_reader :data
+
+      sig { params(data: T.any(FinchAPI::Models::DirectoryEvent::Data, FinchAPI::Internal::AnyHash)).void }
+      attr_writer :data
+
+      sig { returns(T.nilable(FinchAPI::Models::DirectoryEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
+
+      sig { params(event_type: FinchAPI::Models::DirectoryEvent::EventType::OrSymbol).void }
+      attr_writer :event_type
+
+      sig do
+        params(
+          data: T.any(FinchAPI::Models::DirectoryEvent::Data, FinchAPI::Internal::AnyHash),
+          event_type: FinchAPI::Models::DirectoryEvent::EventType::OrSymbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(data: nil, event_type: nil); end
+
+      sig do
+        override
+          .returns(
+            {
+              data: FinchAPI::Models::DirectoryEvent::Data,
+              event_type: FinchAPI::Models::DirectoryEvent::EventType::TaggedSymbol
+            }
+          )
+      end
+      def to_hash; end
+
+      class Data < FinchAPI::Internal::Type::BaseModel
+        # The ID of the individual related to the event.
+        sig { returns(T.nilable(String)) }
+        attr_reader :individual_id
+
+        sig { params(individual_id: String).void }
+        attr_writer :individual_id
+
+        sig { params(individual_id: String).returns(T.attached_class) }
+        def self.new(
+          # The ID of the individual related to the event.
+          individual_id: nil
+        ); end
+        sig { override.returns({individual_id: String}) }
+        def to_hash; end
+      end
+
+      module EventType
+        extend FinchAPI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::DirectoryEvent::EventType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DIRECTORY_CREATED =
+          T.let(:"directory.created", FinchAPI::Models::DirectoryEvent::EventType::TaggedSymbol)
+        DIRECTORY_UPDATED =
+          T.let(:"directory.updated", FinchAPI::Models::DirectoryEvent::EventType::TaggedSymbol)
+        DIRECTORY_DELETED =
+          T.let(:"directory.deleted", FinchAPI::Models::DirectoryEvent::EventType::TaggedSymbol)
+
+        sig { override.returns(T::Array[FinchAPI::Models::DirectoryEvent::EventType::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/disconnect_response.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class DisconnectResponse < FinchAPI::Internal::Type::BaseModel
+      # If the request is successful, Finch will return “success” (HTTP 200 status).
+      sig { returns(String) }
+      attr_accessor :status
+
+      sig { params(status: String).returns(T.attached_class) }
+      def self.new(
+        # If the request is successful, Finch will return “success” (HTTP 200 status).
+        status:
+      ); end
+      sig { override.returns({status: String}) }
+      def to_hash; end
+    end
+  end
+end