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

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

@@ -1,33 +0,0 @@
-# typed: strong
-
-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) }
-      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(account_id:, company_id:, 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/lib/finch-api/models/company_event.rbi

@@ -1,51 +0,0 @@
-# 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::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 = 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/lib/finch-api/models/connect/session_new_params.rbi

@@ -1,189 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    module Connect
-      class SessionNewParams < FinchAPI::BaseModel
-        extend FinchAPI::Type::RequestParameters::Converter
-        include FinchAPI::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::Util::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::Util::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::Util::AnyHash)
-          )
-            .returns(T.attached_class)
-        end
-        def self.new(
-          customer_id:,
-          customer_name:,
-          products:,
-          customer_email: nil,
-          integration: nil,
-          manual: nil,
-          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::Enum
-
-          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) }
-
-          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(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::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
-
-        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, 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/lib/finch-api/models/connect/session_new_response.rbi

@@ -1,25 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    module Connect
-      class SessionNewResponse < FinchAPI::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(connect_url:, session_id:)
-        end
-
-        sig { override.returns({connect_url: String, session_id: String}) }
-        def to_hash
-        end
-      end
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    module Connect
-      class SessionReauthenticateParams < FinchAPI::BaseModel
-        extend FinchAPI::Type::RequestParameters::Converter
-        include FinchAPI::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::Util::AnyHash)
-          )
-            .returns(T.attached_class)
-        end
-        def self.new(connection_id:, minutes_to_expire: nil, products: nil, 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::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 = 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[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::TaggedSymbol]) }
-          def self.values
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    module Connect
-      class SessionReauthenticateResponse < FinchAPI::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(connect_url:, session_id:)
-        end
-
-        sig { override.returns({connect_url: String, session_id: String}) }
-        def to_hash
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    module ConnectionStatusType
-      extend FinchAPI::Enum
-
-      TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::ConnectionStatusType) }
-      OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::ConnectionStatusType::TaggedSymbol) }
-
-      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/lib/finch-api/models/create_access_token_response.rbi

@@ -1,142 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    class CreateAccessTokenResponse < FinchAPI::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(
-        access_token:,
-        account_id:,
-        client_type:,
-        company_id:,
-        connection_id:,
-        connection_type:,
-        products:,
-        provider_id:,
-        customer_id: nil,
-        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::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::CreateAccessTokenResponse::ClientType) }
-        OrSymbol =
-          T.type_alias { T.any(Symbol, FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol) }
-
-        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::Enum
-
-        TaggedSymbol =
-          T.type_alias { T.all(Symbol, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType) }
-        OrSymbol =
-          T.type_alias { T.any(Symbol, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol) }
-
-        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/lib/finch-api/models/directory_event.rbi

@@ -1,76 +0,0 @@
-# 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::Util::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::Util::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::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(individual_id: nil)
-        end
-
-        sig { override.returns({individual_id: String}) }
-        def to_hash
-        end
-      end
-
-      module EventType
-        extend FinchAPI::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::DirectoryEvent::EventType) }
-        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::DirectoryEvent::EventType::TaggedSymbol) }
-
-        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/lib/finch-api/models/disconnect_response.rbi

@@ -1,19 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    class DisconnectResponse < FinchAPI::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(status:)
-      end
-
-      sig { override.returns({status: String}) }
-      def to_hash
-      end
-    end
-  end
-end