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

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

@@ -3,102 +3,71 @@
 module FinchAPI
   module Models
     class CreateAccessTokenResponse < FinchAPI::BaseModel
+      # The access token for the connection.
       sig { returns(String) }
-      def access_token
-      end
-
-      sig { params(_: String).returns(String) }
-      def access_token=(_)
-      end
+      attr_accessor :access_token
 
+      # [DEPRECATED] Use `connection_id` to identify the connection instead of this
+      #   account ID.
       sig { returns(String) }
-      def account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def account_id=(_)
-      end
-
-      sig { returns(Symbol) }
-      def client_type
-      end
+      attr_accessor :account_id
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def client_type=(_)
-      end
+      # 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) }
-      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(Symbol) }
-      def connection_type
-      end
-
-      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::CreateAccessTokenResponse::ConnectionType::TaggedSymbol) }
+      attr_accessor :connection_type
 
+      # 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 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 RFC 8693 token type (Finch uses `bearer` tokens)
       sig { returns(T.nilable(String)) }
-      def token_type
-      end
+      attr_reader :token_type
 
-      sig { params(_: String).returns(String) }
-      def token_type=(_)
-      end
+      sig { params(token_type: String).void }
+      attr_writer :token_type
 
       sig do
         params(
           access_token: String,
           account_id: String,
-          client_type: Symbol,
+          client_type: FinchAPI::Models::CreateAccessTokenResponse::ClientType::OrSymbol,
           company_id: String,
           connection_id: String,
-          connection_type: Symbol,
+          connection_type: FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::OrSymbol,
           products: T::Array[String],
           provider_id: String,
           customer_id: T.nilable(String),
           token_type: String
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         access_token:,
         account_id:,
         client_type:,
@@ -118,10 +87,10 @@ module FinchAPI
             {
               access_token: String,
               account_id: String,
-              client_type: Symbol,
+              client_type: FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol,
               company_id: String,
               connection_id: String,
-              connection_type: Symbol,
+              connection_type: FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol,
               products: T::Array[String],
               provider_id: String,
               customer_id: T.nilable(String),
@@ -132,25 +101,39 @@ module FinchAPI
       def to_hash
       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::CreateAccessTokenResponse::ClientType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol) }
 
-        PRODUCTION = :production
-        DEVELOPMENT = :development
-        SANDBOX = :sandbox
+        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[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::CreateAccessTokenResponse::ClientType::TaggedSymbol]) }
         def self.values
         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::CreateAccessTokenResponse::ConnectionType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol) }
 
-        PROVIDER = :provider
-        FINCH = :finch
+        PROVIDER = T.let(:provider, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol)
+        FINCH = T.let(:finch, FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::CreateAccessTokenResponse::ConnectionType::TaggedSymbol]) }
         def self.values
         end
       end

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

@@ -4,40 +4,49 @@ module FinchAPI
   module Models
     class DirectoryEvent < FinchAPI::Models::BaseWebhookEvent
       sig { returns(T.nilable(FinchAPI::Models::DirectoryEvent::Data)) }
-      def data
-      end
+      attr_reader :data
 
-      sig { params(_: FinchAPI::Models::DirectoryEvent::Data).returns(FinchAPI::Models::DirectoryEvent::Data) }
-      def data=(_)
-      end
+      sig { params(data: T.any(FinchAPI::Models::DirectoryEvent::Data, FinchAPI::Util::AnyHash)).void }
+      attr_writer :data
 
-      sig { returns(T.nilable(Symbol)) }
-      def event_type
-      end
+      sig { returns(T.nilable(FinchAPI::Models::DirectoryEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def event_type=(_)
-      end
+      sig { params(event_type: FinchAPI::Models::DirectoryEvent::EventType::OrSymbol).void }
+      attr_writer :event_type
 
-      sig { params(data: FinchAPI::Models::DirectoryEvent::Data, event_type: Symbol).void }
-      def initialize(data: nil, event_type: nil)
+      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 { override.returns({data: FinchAPI::Models::DirectoryEvent::Data, event_type: Symbol}) }
+      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)) }
-        def individual_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def individual_id=(_)
-        end
+        attr_reader :individual_id
 
         sig { params(individual_id: String).void }
-        def initialize(individual_id: nil)
+        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}) }
@@ -45,14 +54,20 @@ module FinchAPI
         end
       end
 
-      class EventType < FinchAPI::Enum
-        abstract!
+      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 = :"directory.created"
-        DIRECTORY_UPDATED = :"directory.updated"
-        DIRECTORY_DELETED = :"directory.deleted"
+        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[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::DirectoryEvent::EventType::TaggedSymbol]) }
         def self.values
         end
       end

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

@@ -3,16 +3,12 @@
 module FinchAPI
   module Models
     class DisconnectResponse < FinchAPI::BaseModel
+      # If the request is successful, Finch will return “success” (HTTP 200 status).
       sig { returns(String) }
-      def status
-      end
-
-      sig { params(_: String).returns(String) }
-      def status=(_)
-      end
+      attr_accessor :status
 
-      sig { params(status: String).void }
-      def initialize(status:)
+      sig { params(status: String).returns(T.attached_class) }
+      def self.new(status:)
       end
 
       sig { override.returns({status: String}) }

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

@@ -4,40 +4,49 @@ module FinchAPI
   module Models
     class EmploymentEvent < FinchAPI::Models::BaseWebhookEvent
       sig { returns(T.nilable(FinchAPI::Models::EmploymentEvent::Data)) }
-      def data
-      end
+      attr_reader :data
 
-      sig { params(_: FinchAPI::Models::EmploymentEvent::Data).returns(FinchAPI::Models::EmploymentEvent::Data) }
-      def data=(_)
-      end
+      sig { params(data: T.any(FinchAPI::Models::EmploymentEvent::Data, FinchAPI::Util::AnyHash)).void }
+      attr_writer :data
 
-      sig { returns(T.nilable(Symbol)) }
-      def event_type
-      end
+      sig { returns(T.nilable(FinchAPI::Models::EmploymentEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def event_type=(_)
-      end
+      sig { params(event_type: FinchAPI::Models::EmploymentEvent::EventType::OrSymbol).void }
+      attr_writer :event_type
 
-      sig { params(data: FinchAPI::Models::EmploymentEvent::Data, event_type: Symbol).void }
-      def initialize(data: nil, event_type: nil)
+      sig do
+        params(
+          data: T.any(FinchAPI::Models::EmploymentEvent::Data, FinchAPI::Util::AnyHash),
+          event_type: FinchAPI::Models::EmploymentEvent::EventType::OrSymbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(data: nil, event_type: nil)
       end
 
-      sig { override.returns({data: FinchAPI::Models::EmploymentEvent::Data, event_type: Symbol}) }
+      sig do
+        override
+          .returns(
+            {
+              data: FinchAPI::Models::EmploymentEvent::Data,
+              event_type: FinchAPI::Models::EmploymentEvent::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)) }
-        def individual_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def individual_id=(_)
-        end
+        attr_reader :individual_id
 
         sig { params(individual_id: String).void }
-        def initialize(individual_id: nil)
+        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}) }
@@ -45,14 +54,20 @@ module FinchAPI
         end
       end
 
-      class EventType < FinchAPI::Enum
-        abstract!
+      module EventType
+        extend FinchAPI::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::EmploymentEvent::EventType) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::EmploymentEvent::EventType::TaggedSymbol) }
 
-        EMPLOYMENT_CREATED = :"employment.created"
-        EMPLOYMENT_UPDATED = :"employment.updated"
-        EMPLOYMENT_DELETED = :"employment.deleted"
+        EMPLOYMENT_CREATED =
+          T.let(:"employment.created", FinchAPI::Models::EmploymentEvent::EventType::TaggedSymbol)
+        EMPLOYMENT_UPDATED =
+          T.let(:"employment.updated", FinchAPI::Models::EmploymentEvent::EventType::TaggedSymbol)
+        EMPLOYMENT_DELETED =
+          T.let(:"employment.deleted", FinchAPI::Models::EmploymentEvent::EventType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::EmploymentEvent::EventType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/finch-api/models/hris/benefit_contribution.rbi

@@ -4,37 +4,45 @@ module FinchAPI
   module Models
     module HRIS
       class BenefitContribution < FinchAPI::BaseModel
+        # Contribution amount in cents (if `fixed`) or basis points (if `percent`).
         sig { returns(T.nilable(Integer)) }
-        def amount
+        attr_accessor :amount
+
+        # Contribution type.
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitContribution::Type::TaggedSymbol)) }
+        attr_accessor :type
+
+        sig do
+          params(
+            amount: T.nilable(Integer),
+            type: T.nilable(FinchAPI::Models::HRIS::BenefitContribution::Type::OrSymbol)
+          )
+            .returns(T.attached_class)
         end
-
-        sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-        def amount=(_)
-        end
-
-        sig { returns(T.nilable(Symbol)) }
-        def type
+        def self.new(amount: nil, type: nil)
         end
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def type=(_)
+        sig do
+          override
+            .returns(
+              {amount: T.nilable(Integer), type: T.nilable(FinchAPI::Models::HRIS::BenefitContribution::Type::TaggedSymbol)}
+            )
         end
-
-        sig { params(amount: T.nilable(Integer), type: T.nilable(Symbol)).void }
-        def initialize(amount: nil, type: nil)
-        end
-
-        sig { override.returns({amount: T.nilable(Integer), type: T.nilable(Symbol)}) }
         def to_hash
         end
 
-        class Type < FinchAPI::Enum
-          abstract!
+        # Contribution type.
+        module Type
+          extend FinchAPI::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::HRIS::BenefitContribution::Type) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::HRIS::BenefitContribution::Type::TaggedSymbol) }
 
-          FIXED = T.let(:fixed, T.nilable(Symbol))
-          PERCENT = T.let(:percent, T.nilable(Symbol))
+          FIXED = T.let(:fixed, FinchAPI::Models::HRIS::BenefitContribution::Type::TaggedSymbol)
+          PERCENT = T.let(:percent, FinchAPI::Models::HRIS::BenefitContribution::Type::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::HRIS::BenefitContribution::Type::TaggedSymbol]) }
           def self.values
           end
         end

data/rbi/lib/finch-api/models/hris/benefit_create_params.rbi

@@ -7,40 +7,32 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # Name of the benefit as it appears in the provider and pay statements. Recommend
+        #   limiting this to <30 characters due to limitations in specific providers (e.g.
+        #   Justworks).
         sig { returns(T.nilable(String)) }
-        def description
-        end
-
-        sig { params(_: String).returns(String) }
-        def description=(_)
-        end
-
-        sig { returns(T.nilable(Symbol)) }
-        def frequency
-        end
+        attr_reader :description
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def frequency=(_)
-        end
+        sig { params(description: String).void }
+        attr_writer :description
 
-        sig { returns(T.nilable(Symbol)) }
-        def type
-        end
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol)) }
+        attr_accessor :frequency
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def type=(_)
-        end
+        # Type of benefit.
+        sig { returns(T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol)) }
+        attr_accessor :type
 
         sig do
           params(
             description: String,
-            frequency: T.nilable(Symbol),
-            type: T.nilable(Symbol),
-            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            frequency: T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol),
+            type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol),
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(description: nil, frequency: nil, type: nil, request_options: {})
+        def self.new(description: nil, frequency: nil, type: nil, request_options: {})
         end
 
         sig do
@@ -48,8 +40,8 @@ module FinchAPI
             .returns(
               {
                 description: String,
-                frequency: T.nilable(Symbol),
-                type: T.nilable(Symbol),
+                frequency: T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol),
+                type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol),
                 request_options: FinchAPI::RequestOptions
               }
             )