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

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

@@ -3,150 +3,97 @@
 module FinchAPI
   module Models
     class Introspection < FinchAPI::BaseModel
+      # [DEPRECATED] Use `connection_id` to associate tokens with a Finch connection
+      #   instead of this account ID.
       sig { returns(String) }
-      def account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def account_id=(_)
-      end
+      attr_accessor :account_id
 
       sig { returns(T::Array[FinchAPI::Models::Introspection::AuthenticationMethod]) }
-      def authentication_methods
-      end
-
-      sig do
-        params(_: T::Array[FinchAPI::Models::Introspection::AuthenticationMethod])
-          .returns(T::Array[FinchAPI::Models::Introspection::AuthenticationMethod])
-      end
-      def authentication_methods=(_)
-      end
+      attr_accessor :authentication_methods
 
+      # The client ID of the application associated with the `access_token`.
       sig { returns(String) }
-      def client_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def client_id=(_)
-      end
+      attr_accessor :client_id
 
-      sig { returns(Symbol) }
-      def client_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def client_type=(_)
-      end
+      # The type of application associated with a token.
+      sig { returns(FinchAPI::Models::Introspection::ClientType::TaggedSymbol) }
+      attr_accessor :client_type
 
+      # [DEPRECATED] Use `connection_id` to associate tokens with a Finch connection
+      #   instead of this company ID.
       sig { returns(String) }
-      def company_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def company_id=(_)
-      end
+      attr_accessor :company_id
 
+      # The Finch UUID of the connection associated with the `access_token`.
       sig { returns(String) }
-      def connection_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def connection_id=(_)
-      end
+      attr_accessor :connection_id
 
       sig { returns(FinchAPI::Models::Introspection::ConnectionStatus) }
-      def connection_status
-      end
+      attr_reader :connection_status
 
       sig do
-        params(_: FinchAPI::Models::Introspection::ConnectionStatus)
-          .returns(FinchAPI::Models::Introspection::ConnectionStatus)
-      end
-      def connection_status=(_)
-      end
-
-      sig { returns(Symbol) }
-      def connection_type
+        params(
+          connection_status: T.any(FinchAPI::Models::Introspection::ConnectionStatus, FinchAPI::Util::AnyHash)
+        )
+          .void
       end
+      attr_writer :connection_status
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def connection_type=(_)
-      end
+      # The type of the connection associated with the token.
+      #
+      #   - `provider` - connection to an external provider
+      #   - `finch` - finch-generated data.
+      sig { returns(FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol) }
+      attr_accessor :connection_type
 
+      # The email of your customer you provided to Finch when a connect session was
+      #   created for this connection.
       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
 
+      # The ID of your customer you provided to Finch when a connect session was created
+      #   for this connection.
       sig { returns(T.nilable(String)) }
-      def customer_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def customer_id=(_)
-      end
+      attr_accessor :customer_id
 
+      # The name of your customer you provided to Finch when a connect session was
+      #   created for this connection.
       sig { returns(T.nilable(String)) }
-      def customer_name
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def customer_name=(_)
-      end
+      attr_accessor :customer_name
 
+      # Whether the connection associated with the `access_token` uses the Assisted
+      #   Connect Flow. (`true` if using Assisted Connect, `false` if connection is
+      #   automated)
       sig { returns(T::Boolean) }
-      def manual
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def manual=(_)
-      end
+      attr_accessor :manual
 
+      # [DEPRECATED] Use `provider_id` to identify the provider instead of this payroll
+      #   provider ID.
       sig { returns(String) }
-      def payroll_provider_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def payroll_provider_id=(_)
-      end
+      attr_accessor :payroll_provider_id
 
+      # An array of the authorized products associated with the `access_token`.
       sig { returns(T::Array[String]) }
-      def products
-      end
-
-      sig { params(_: T::Array[String]).returns(T::Array[String]) }
-      def products=(_)
-      end
+      attr_accessor :products
 
+      # The ID of the provider associated with the `access_token`.
       sig { returns(String) }
-      def provider_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def provider_id=(_)
-      end
+      attr_accessor :provider_id
 
+      # The account username used for login associated with the `access_token`.
       sig { returns(String) }
-      def username
-      end
-
-      sig { params(_: String).returns(String) }
-      def username=(_)
-      end
+      attr_accessor :username
 
       sig do
         params(
           account_id: String,
-          authentication_methods: T::Array[FinchAPI::Models::Introspection::AuthenticationMethod],
+          authentication_methods: T::Array[T.any(FinchAPI::Models::Introspection::AuthenticationMethod, FinchAPI::Util::AnyHash)],
           client_id: String,
-          client_type: Symbol,
+          client_type: FinchAPI::Models::Introspection::ClientType::OrSymbol,
           company_id: String,
           connection_id: String,
-          connection_status: FinchAPI::Models::Introspection::ConnectionStatus,
-          connection_type: Symbol,
+          connection_status: T.any(FinchAPI::Models::Introspection::ConnectionStatus, FinchAPI::Util::AnyHash),
+          connection_type: FinchAPI::Models::Introspection::ConnectionType::OrSymbol,
           customer_email: T.nilable(String),
           customer_id: T.nilable(String),
           customer_name: T.nilable(String),
@@ -156,9 +103,9 @@ module FinchAPI
           provider_id: String,
           username: String
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         account_id:,
         authentication_methods:,
         client_id:,
@@ -185,11 +132,11 @@ module FinchAPI
               account_id: String,
               authentication_methods: T::Array[FinchAPI::Models::Introspection::AuthenticationMethod],
               client_id: String,
-              client_type: Symbol,
+              client_type: FinchAPI::Models::Introspection::ClientType::TaggedSymbol,
               company_id: String,
               connection_id: String,
               connection_status: FinchAPI::Models::Introspection::ConnectionStatus,
-              connection_type: Symbol,
+              connection_type: FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol,
               customer_email: T.nilable(String),
               customer_id: T.nilable(String),
               customer_name: T.nilable(String),
@@ -206,41 +153,39 @@ module FinchAPI
 
       class AuthenticationMethod < FinchAPI::BaseModel
         sig { returns(T.nilable(FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus)) }
-        def connection_status
-        end
+        attr_reader :connection_status
 
         sig do
-          params(_: FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus)
-            .returns(FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus)
-        end
-        def connection_status=(_)
+          params(
+            connection_status: T.any(FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus, FinchAPI::Util::AnyHash)
+          )
+            .void
         end
+        attr_writer :connection_status
 
+        # An array of the authorized products associated with the `access_token`.
         sig { returns(T.nilable(T::Array[String])) }
-        def products
-        end
+        attr_reader :products
 
-        sig { params(_: T::Array[String]).returns(T::Array[String]) }
-        def products=(_)
-        end
+        sig { params(products: T::Array[String]).void }
+        attr_writer :products
 
-        sig { returns(T.nilable(Symbol)) }
-        def type
-        end
+        # The type of authentication method.
+        sig { returns(T.nilable(FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)) }
+        attr_reader :type
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def type=(_)
-        end
+        sig { params(type: FinchAPI::Models::Introspection::AuthenticationMethod::Type::OrSymbol).void }
+        attr_writer :type
 
         sig do
           params(
-            connection_status: FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus,
+            connection_status: T.any(FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus, FinchAPI::Util::AnyHash),
             products: T::Array[String],
-            type: Symbol
+            type: FinchAPI::Models::Introspection::AuthenticationMethod::Type::OrSymbol
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(connection_status: nil, products: nil, type: nil)
+        def self.new(connection_status: nil, products: nil, type: nil)
         end
 
         sig do
@@ -249,7 +194,7 @@ module FinchAPI
               {
                 connection_status: FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus,
                 products: T::Array[String],
-                type: Symbol
+                type: FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol
               }
             )
         end
@@ -258,90 +203,105 @@ module FinchAPI
 
         class ConnectionStatus < FinchAPI::BaseModel
           sig { returns(T.nilable(String)) }
-          def message
-          end
+          attr_reader :message
 
-          sig { params(_: String).returns(String) }
-          def message=(_)
-          end
+          sig { params(message: String).void }
+          attr_writer :message
 
-          sig { returns(T.nilable(Symbol)) }
-          def status
-          end
+          sig { returns(T.nilable(FinchAPI::Models::ConnectionStatusType::TaggedSymbol)) }
+          attr_reader :status
 
-          sig { params(_: Symbol).returns(Symbol) }
-          def status=(_)
-          end
+          sig { params(status: FinchAPI::Models::ConnectionStatusType::OrSymbol).void }
+          attr_writer :status
 
-          sig { params(message: String, status: Symbol).void }
-          def initialize(message: nil, status: nil)
+          sig do
+            params(message: String, status: FinchAPI::Models::ConnectionStatusType::OrSymbol).returns(T.attached_class)
+          end
+          def self.new(message: nil, status: nil)
           end
 
-          sig { override.returns({message: String, status: Symbol}) }
+          sig { override.returns({message: String, status: FinchAPI::Models::ConnectionStatusType::TaggedSymbol}) }
           def to_hash
           end
         end
 
-        class Type < FinchAPI::Enum
-          abstract!
+        # The type of authentication method.
+        module Type
+          extend FinchAPI::Enum
 
-          ASSISTED = :assisted
-          CREDENTIAL = :credential
-          API_TOKEN = :api_token
-          API_CREDENTIAL = :api_credential
-          OAUTH = :oauth
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, FinchAPI::Models::Introspection::AuthenticationMethod::Type) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol) }
 
-          sig { override.returns(T::Array[Symbol]) }
+          ASSISTED = T.let(:assisted, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+          CREDENTIAL =
+            T.let(:credential, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+          API_TOKEN = T.let(:api_token, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+          API_CREDENTIAL =
+            T.let(:api_credential, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+          OAUTH = T.let(:oauth, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol]) }
           def self.values
           end
         end
       end
 
-      class ClientType < FinchAPI::Enum
-        abstract!
+      # The type of application associated with a token.
+      module ClientType
+        extend FinchAPI::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Introspection::ClientType) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::Introspection::ClientType::TaggedSymbol) }
 
-        PRODUCTION = :production
-        DEVELOPMENT = :development
-        SANDBOX = :sandbox
+        PRODUCTION = T.let(:production, FinchAPI::Models::Introspection::ClientType::TaggedSymbol)
+        DEVELOPMENT = T.let(:development, FinchAPI::Models::Introspection::ClientType::TaggedSymbol)
+        SANDBOX = T.let(:sandbox, FinchAPI::Models::Introspection::ClientType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::Introspection::ClientType::TaggedSymbol]) }
         def self.values
         end
       end
 
       class ConnectionStatus < FinchAPI::BaseModel
         sig { returns(T.nilable(String)) }
-        def message
-        end
+        attr_reader :message
 
-        sig { params(_: String).returns(String) }
-        def message=(_)
-        end
+        sig { params(message: String).void }
+        attr_writer :message
 
-        sig { returns(T.nilable(Symbol)) }
-        def status
-        end
+        sig { returns(T.nilable(FinchAPI::Models::ConnectionStatusType::TaggedSymbol)) }
+        attr_reader :status
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def status=(_)
-        end
+        sig { params(status: FinchAPI::Models::ConnectionStatusType::OrSymbol).void }
+        attr_writer :status
 
-        sig { params(message: String, status: Symbol).void }
-        def initialize(message: nil, status: nil)
+        sig do
+          params(message: String, status: FinchAPI::Models::ConnectionStatusType::OrSymbol).returns(T.attached_class)
+        end
+        def self.new(message: nil, status: nil)
         end
 
-        sig { override.returns({message: String, status: Symbol}) }
+        sig { override.returns({message: String, status: FinchAPI::Models::ConnectionStatusType::TaggedSymbol}) }
         def to_hash
         end
       end
 
-      class ConnectionType < FinchAPI::Enum
-        abstract!
+      # 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::Introspection::ConnectionType) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol) }
 
-        PROVIDER = :provider
-        FINCH = :finch
+        PROVIDER = T.let(:provider, FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol)
+        FINCH = T.let(:finch, FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol]) }
         def self.values
         end
       end

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

@@ -4,48 +4,50 @@ module FinchAPI
   module Models
     class JobCompletionEvent < FinchAPI::Models::BaseWebhookEvent
       sig { returns(T.nilable(FinchAPI::Models::JobCompletionEvent::Data)) }
-      def data
-      end
+      attr_reader :data
 
-      sig { params(_: FinchAPI::Models::JobCompletionEvent::Data).returns(FinchAPI::Models::JobCompletionEvent::Data) }
-      def data=(_)
-      end
+      sig { params(data: T.any(FinchAPI::Models::JobCompletionEvent::Data, FinchAPI::Util::AnyHash)).void }
+      attr_writer :data
 
-      sig { returns(T.nilable(Symbol)) }
-      def event_type
-      end
+      sig { returns(T.nilable(FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def event_type=(_)
-      end
+      sig { params(event_type: FinchAPI::Models::JobCompletionEvent::EventType::OrSymbol).void }
+      attr_writer :event_type
 
-      sig { params(data: FinchAPI::Models::JobCompletionEvent::Data, event_type: Symbol).void }
-      def initialize(data: nil, event_type: nil)
+      sig do
+        params(
+          data: T.any(FinchAPI::Models::JobCompletionEvent::Data, FinchAPI::Util::AnyHash),
+          event_type: FinchAPI::Models::JobCompletionEvent::EventType::OrSymbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(data: nil, event_type: nil)
       end
 
-      sig { override.returns({data: FinchAPI::Models::JobCompletionEvent::Data, event_type: Symbol}) }
+      sig do
+        override
+          .returns(
+            {
+              data: FinchAPI::Models::JobCompletionEvent::Data,
+              event_type: FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol
+            }
+          )
+      end
       def to_hash
       end
 
       class Data < FinchAPI::BaseModel
+        # The id of the job which has completed.
         sig { returns(String) }
-        def job_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def job_id=(_)
-        end
+        attr_accessor :job_id
 
+        # The url to query the result of the job.
         sig { returns(String) }
-        def job_url
-        end
+        attr_accessor :job_url
 
-        sig { params(_: String).returns(String) }
-        def job_url=(_)
-        end
-
-        sig { params(job_id: String, job_url: String).void }
-        def initialize(job_id:, job_url:)
+        sig { params(job_id: String, job_url: String).returns(T.attached_class) }
+        def self.new(job_id:, job_url:)
         end
 
         sig { override.returns({job_id: String, job_url: String}) }
@@ -53,17 +55,26 @@ module FinchAPI
         end
       end
 
-      class EventType < FinchAPI::Enum
-        abstract!
+      module EventType
+        extend FinchAPI::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::JobCompletionEvent::EventType) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol) }
 
-        JOB_BENEFIT_CREATE_COMPLETED = :"job.benefit_create.completed"
-        JOB_BENEFIT_ENROLL_COMPLETED = :"job.benefit_enroll.completed"
-        JOB_BENEFIT_REGISTER_COMPLETED = :"job.benefit_register.completed"
-        JOB_BENEFIT_UNENROLL_COMPLETED = :"job.benefit_unenroll.completed"
-        JOB_BENEFIT_UPDATE_COMPLETED = :"job.benefit_update.completed"
-        JOB_DATA_SYNC_ALL_COMPLETED = :"job.data_sync_all.completed"
+        JOB_BENEFIT_CREATE_COMPLETED =
+          T.let(:"job.benefit_create.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_BENEFIT_ENROLL_COMPLETED =
+          T.let(:"job.benefit_enroll.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_BENEFIT_REGISTER_COMPLETED =
+          T.let(:"job.benefit_register.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_BENEFIT_UNENROLL_COMPLETED =
+          T.let(:"job.benefit_unenroll.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_BENEFIT_UPDATE_COMPLETED =
+          T.let(:"job.benefit_update.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_DATA_SYNC_ALL_COMPLETED =
+          T.let(:"job.data_sync_all.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol]) }
         def self.values
         end
       end