finch-api 0.1.0.pre.alpha.32 → 0.1.0.pre.alpha.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fbfa323b400fae895840756ee4bc6fe3df67a06c5ceae9911869b92c8a3cb38
-  data.tar.gz: ad43f7d7accae26963aaf39a32c4e79165e88cc32c5c1173e5b623d7a64d78f5
+  metadata.gz: ede02583d2b0c445b277a885b7fd9618866a4d8507cf77fc55d22315bb738474
+  data.tar.gz: f2a3ea53b6308dfcdf758c8adc92ce32f97fbbe6833069da6e332a7927a185e7
 SHA512:
-  metadata.gz: 527cfbb535eb068c6314d9c2373360a8a2b975f8a2cd7ada538bb5787f261be1bdb9aa1c2c64a055e7542c0f11da3a4c86778900125c1cdeb424ad35eb2760e9
-  data.tar.gz: 7f7c577058e88294e8e9cbbe9352b5abe9bf0fe1f9dd22508995a752b06825a6aa4d4de8f995f3fee51a476b6bb981200afbb8fac97c23c073afd0098c50ebe8
+  metadata.gz: c597ba4db22f2703c89d7abbfa8abba5f5b777a0cd27006ac51dba6f8bc1e03fbbd1fa5865d2a85cad45402671d76fc1c88fb57e4e3a8141d13a79e8290b4260
+  data.tar.gz: 05fa8f40fe7583702b86c013419ef743f87f05f0f08a97a35a342d0e7363148b830a4370a8e6716eea654be5449dbf6c97927cfc18b6ca4425e119acf286cce8

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.1.0-alpha.34 (2025-11-04)
+
+Full Changelog: [v0.1.0-alpha.33...v0.1.0-alpha.34](https://github.com/Finch-API/finch-api-ruby/compare/v0.1.0-alpha.33...v0.1.0-alpha.34)
+
+### Features
+
+* **api:** update automated code reviewer selection ([783db04](https://github.com/Finch-API/finch-api-ruby/commit/783db04dbf3f2175cedd3b4e2aae34aa48977784))
+
+## 0.1.0-alpha.33 (2025-11-03)
+
+Full Changelog: [v0.1.0-alpha.32...v0.1.0-alpha.33](https://github.com/Finch-API/finch-api-ruby/compare/v0.1.0-alpha.32...v0.1.0-alpha.33)
+
+### Features
+
+* **api:** api update ([e2215da](https://github.com/Finch-API/finch-api-ruby/commit/e2215daac58922a19f110eb71249f5b0480bcfd4))
+
+
+### Chores
+
+* bump dependency version and update sorbet types ([82af149](https://github.com/Finch-API/finch-api-ruby/commit/82af1496618cbd69a049591e5fcaca45907f3fa4))
+* **client:** send user-agent header ([a1bdc99](https://github.com/Finch-API/finch-api-ruby/commit/a1bdc99fe97c31fcff475e4e46d9cba65893c4f3))
+
 ## 0.1.0-alpha.32 (2025-10-31)
 
 Full Changelog: [v0.1.0-alpha.31...v0.1.0-alpha.32](https://github.com/Finch-API/finch-api-ruby/compare/v0.1.0-alpha.31...v0.1.0-alpha.32)

data/README.md

@@ -17,7 +17,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "finch-api", "~> 0.1.0.pre.alpha.32"
+gem "finch-api", "~> 0.1.0.pre.alpha.34"
 ```
 
 <!-- x-release-please-end -->

data/lib/finch_api/internal/transport/base_client.rb

@@ -201,7 +201,8 @@ module FinchAPI
             self.class::PLATFORM_HEADERS,
             {
               "accept" => "application/json",
-              "content-type" => "application/json"
+              "content-type" => "application/json",
+              "user-agent" => user_agent
             },
             headers
           )
@@ -219,6 +220,11 @@ module FinchAPI
         # @return [Hash{String=>String}]
         private def auth_headers = {}
 
+        # @api private
+        #
+        # @return [String]
+        private def user_agent = "#{self.class.name}/Ruby #{FinchAPI::VERSION}"
+
         # @api private
         #
         # @return [String]

data/lib/finch_api/models/connect/session_new_params.rb

@@ -8,12 +8,6 @@ module FinchAPI
         extend FinchAPI::Internal::Type::RequestParameters::Converter
         include FinchAPI::Internal::Type::RequestParameters
 
-        # @!attribute customer_email
-        #   Email address of the customer
-        #
-        #   @return [String, nil]
-        required :customer_email, String, nil?: true
-
         # @!attribute customer_id
         #   Unique identifier for the customer
         #
@@ -26,89 +20,114 @@ module FinchAPI
         #   @return [String]
         required :customer_name, String
 
+        # @!attribute products
+        #   The Finch products to request access to
+        #
+        #   @return [Array<Symbol, FinchAPI::Models::Connect::SessionNewParams::Product>]
+        required :products,
+                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Connect::SessionNewParams::Product] }
+
+        # @!attribute customer_email
+        #   Email address of the customer
+        #
+        #   @return [String, nil]
+        optional :customer_email, String, nil?: true
+
         # @!attribute integration
         #   Integration configuration for the connect session
         #
         #   @return [FinchAPI::Models::Connect::SessionNewParams::Integration, nil]
-        required :integration, -> { FinchAPI::Connect::SessionNewParams::Integration }, nil?: true
+        optional :integration, -> { FinchAPI::Connect::SessionNewParams::Integration }, nil?: true
 
         # @!attribute manual
         #   Enable manual authentication mode
         #
         #   @return [Boolean, nil]
-        required :manual, FinchAPI::Internal::Type::Boolean, nil?: true
+        optional :manual, FinchAPI::Internal::Type::Boolean, nil?: true
 
         # @!attribute minutes_to_expire
         #   The number of minutes until the session expires (defaults to 129,600, which is
         #   90 days)
         #
         #   @return [Float, nil]
-        required :minutes_to_expire, Float, nil?: true
-
-        # @!attribute products
-        #   The Finch products to request access to
-        #
-        #   @return [Array<Symbol, FinchAPI::Models::Connect::SessionNewParams::Product>]
-        required :products,
-                 -> { FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Connect::SessionNewParams::Product] }
+        optional :minutes_to_expire, Float, nil?: true
 
         # @!attribute redirect_uri
         #   The URI to redirect to after the Connect flow is completed
         #
         #   @return [String, nil]
-        required :redirect_uri, String, nil?: true
+        optional :redirect_uri, String, nil?: true
 
         # @!attribute sandbox
         #   Sandbox mode for testing
         #
         #   @return [Symbol, FinchAPI::Models::Connect::SessionNewParams::Sandbox, nil]
-        required :sandbox, enum: -> { FinchAPI::Connect::SessionNewParams::Sandbox }, nil?: true
+        optional :sandbox, enum: -> { FinchAPI::Connect::SessionNewParams::Sandbox }, nil?: true
 
-        # @!method initialize(customer_email:, customer_id:, customer_name:, integration:, manual:, minutes_to_expire:, products:, redirect_uri:, sandbox:, request_options: {})
+        # @!method initialize(customer_id:, customer_name:, products:, customer_email: nil, integration: nil, manual: nil, minutes_to_expire: nil, redirect_uri: nil, sandbox: nil, request_options: {})
         #   Some parameter documentations has been truncated, see
         #   {FinchAPI::Models::Connect::SessionNewParams} for more details.
         #
-        #   @param customer_email [String, nil] Email address of the customer
-        #
         #   @param customer_id [String] Unique identifier for the customer
         #
         #   @param customer_name [String] Name of the customer
         #
+        #   @param products [Array<Symbol, FinchAPI::Models::Connect::SessionNewParams::Product>] The Finch products to request access to
+        #
+        #   @param customer_email [String, nil] Email address of the customer
+        #
         #   @param integration [FinchAPI::Models::Connect::SessionNewParams::Integration, nil] Integration configuration for the connect session
         #
         #   @param manual [Boolean, nil] Enable manual authentication mode
         #
         #   @param minutes_to_expire [Float, nil] The number of minutes until the session expires (defaults to 129,600, which is 9
         #
-        #   @param products [Array<Symbol, FinchAPI::Models::Connect::SessionNewParams::Product>] The Finch products to request access to
-        #
         #   @param redirect_uri [String, nil] The URI to redirect to after the Connect flow is completed
         #
         #   @param sandbox [Symbol, FinchAPI::Models::Connect::SessionNewParams::Sandbox, nil] Sandbox mode for testing
         #
         #   @param request_options [FinchAPI::RequestOptions, Hash{Symbol=>Object}]
 
+        # The Finch products that can be requested during the Connect flow.
+        module Product
+          extend FinchAPI::Internal::Type::Enum
+
+          BENEFITS = :benefits
+          COMPANY = :company
+          DEDUCTION = :deduction
+          DIRECTORY = :directory
+          DOCUMENTS = :documents
+          EMPLOYMENT = :employment
+          INDIVIDUAL = :individual
+          PAYMENT = :payment
+          PAY_STATEMENT = :pay_statement
+          SSN = :ssn
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+
         class Integration < FinchAPI::Internal::Type::BaseModel
+          # @!attribute provider
+          #   The provider to integrate with
+          #
+          #   @return [String]
+          required :provider, String
+
           # @!attribute auth_method
           #   The authentication method to use
           #
           #   @return [Symbol, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod, nil]
-          required :auth_method,
+          optional :auth_method,
                    enum: -> { FinchAPI::Connect::SessionNewParams::Integration::AuthMethod },
                    nil?: true
 
-          # @!attribute provider
-          #   The provider to integrate with
-          #
-          #   @return [String, nil]
-          required :provider, String, nil?: true
-
-          # @!method initialize(auth_method:, provider:)
+          # @!method initialize(provider:, auth_method: nil)
           #   Integration configuration for the connect session
           #
-          #   @param auth_method [Symbol, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod, nil] The authentication method to use
+          #   @param provider [String] The provider to integrate with
           #
-          #   @param provider [String, nil] The provider to integrate with
+          #   @param auth_method [Symbol, FinchAPI::Models::Connect::SessionNewParams::Integration::AuthMethod, nil] The authentication method to use
 
           # The authentication method to use
           #
@@ -126,25 +145,6 @@ module FinchAPI
           end
         end
 
-        # The Finch products that can be requested during the Connect flow.
-        module Product
-          extend FinchAPI::Internal::Type::Enum
-
-          BENEFITS = :benefits
-          COMPANY = :company
-          DEDUCTION = :deduction
-          DIRECTORY = :directory
-          DOCUMENTS = :documents
-          EMPLOYMENT = :employment
-          INDIVIDUAL = :individual
-          PAYMENT = :payment
-          PAY_STATEMENT = :pay_statement
-          SSN = :ssn
-
-          # @!method self.values
-          #   @return [Array<Symbol>]
-        end
-
         # Sandbox mode for testing
         module Sandbox
           extend FinchAPI::Internal::Type::Enum

data/lib/finch_api/models/connect/session_reauthenticate_params.rb

@@ -18,14 +18,14 @@ module FinchAPI
         #   The number of minutes until the session expires (defaults to 43,200, which is 30
         #   days)
         #
-        #   @return [Integer]
-        required :minutes_to_expire, Integer
+        #   @return [Integer, nil]
+        optional :minutes_to_expire, Integer
 
         # @!attribute products
         #   The products to request access to (optional for reauthentication)
         #
         #   @return [Array<Symbol, FinchAPI::Models::Connect::SessionReauthenticateParams::Product>, nil]
-        required :products,
+        optional :products,
                  -> {
                    FinchAPI::Internal::Type::ArrayOf[enum: FinchAPI::Connect::SessionReauthenticateParams::Product]
                  },
@@ -35,9 +35,9 @@ module FinchAPI
         #   The URI to redirect to after the Connect flow is completed
         #
         #   @return [String, nil]
-        required :redirect_uri, String, nil?: true
+        optional :redirect_uri, String, nil?: true
 
-        # @!method initialize(connection_id:, minutes_to_expire:, products:, redirect_uri:, request_options: {})
+        # @!method initialize(connection_id:, minutes_to_expire: nil, products: nil, redirect_uri: nil, request_options: {})
         #   Some parameter documentations has been truncated, see
         #   {FinchAPI::Models::Connect::SessionReauthenticateParams} for more details.
         #

data/lib/finch_api/resources/connect/sessions.rb

@@ -9,22 +9,22 @@ module FinchAPI
         #
         # Create a new connect session for an employer
         #
-        # @overload new(customer_email:, customer_id:, customer_name:, integration:, manual:, minutes_to_expire:, products:, redirect_uri:, sandbox:, request_options: {})
-        #
-        # @param customer_email [String, nil] Email address of the customer
+        # @overload new(customer_id:, customer_name:, products:, customer_email: nil, integration: nil, manual: nil, minutes_to_expire: nil, redirect_uri: nil, sandbox: nil, request_options: {})
         #
         # @param customer_id [String] Unique identifier for the customer
         #
         # @param customer_name [String] Name of the customer
         #
+        # @param products [Array<Symbol, FinchAPI::Models::Connect::SessionNewParams::Product>] The Finch products to request access to
+        #
+        # @param customer_email [String, nil] Email address of the customer
+        #
         # @param integration [FinchAPI::Models::Connect::SessionNewParams::Integration, nil] Integration configuration for the connect session
         #
         # @param manual [Boolean, nil] Enable manual authentication mode
         #
         # @param minutes_to_expire [Float, nil] The number of minutes until the session expires (defaults to 129,600, which is 9
         #
-        # @param products [Array<Symbol, FinchAPI::Models::Connect::SessionNewParams::Product>] The Finch products to request access to
-        #
         # @param redirect_uri [String, nil] The URI to redirect to after the Connect flow is completed
         #
         # @param sandbox [Symbol, FinchAPI::Models::Connect::SessionNewParams::Sandbox, nil] Sandbox mode for testing
@@ -50,7 +50,7 @@ module FinchAPI
         #
         # Create a new Connect session for reauthenticating an existing connection
         #
-        # @overload reauthenticate(connection_id:, minutes_to_expire:, products:, redirect_uri:, request_options: {})
+        # @overload reauthenticate(connection_id:, minutes_to_expire: nil, products: nil, redirect_uri: nil, request_options: {})
         #
         # @param connection_id [String] The ID of the existing connection to reauthenticate
         #

data/lib/finch_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FinchAPI
-  VERSION = "0.1.0.pre.alpha.32"
+  VERSION = "0.1.0.pre.alpha.34"
 end

data/rbi/finch_api/internal/transport/base_client.rbi

@@ -176,6 +176,11 @@ module FinchAPI
         private def auth_headers
         end
 
+        # @api private
+        sig { returns(String) }
+        private def user_agent
+        end
+
         # @api private
         sig { returns(String) }
         private def generate_idempotency_key

data/rbi/finch_api/internal/type/base_model.rbi

@@ -31,7 +31,7 @@ module FinchAPI
           #
           # Assumes superclass fields are totally defined before fields are accessed /
           # defined on subclasses.
-          sig { params(child: T.self_type).void }
+          sig { params(child: FinchAPI::Internal::Type::BaseModel).void }
           def inherited(child)
           end
 
@@ -274,9 +274,13 @@ module FinchAPI
 
         # Create a new instance of a model.
         sig do
-          params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).returns(
-            T.attached_class
-          )
+          params(
+            data:
+              T.any(
+                T::Hash[Symbol, T.anything],
+                FinchAPI::Internal::Type::BaseModel
+              )
+          ).returns(T.attached_class)
         end
         def self.new(data = {})
         end

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

@@ -15,10 +15,6 @@ module FinchAPI
             )
           end
 
-        # Email address of the customer
-        sig { returns(T.nilable(String)) }
-        attr_accessor :customer_email
-
         # Unique identifier for the customer
         sig { returns(String) }
         attr_accessor :customer_id
@@ -27,6 +23,18 @@ module FinchAPI
         sig { returns(String) }
         attr_accessor :customer_name
 
+        # The Finch products to request access to
+        sig do
+          returns(
+            T::Array[FinchAPI::Connect::SessionNewParams::Product::OrSymbol]
+          )
+        end
+        attr_accessor :products
+
+        # Email address of the customer
+        sig { returns(T.nilable(String)) }
+        attr_accessor :customer_email
+
         # Integration configuration for the connect session
         sig do
           returns(T.nilable(FinchAPI::Connect::SessionNewParams::Integration))
@@ -52,14 +60,6 @@ module FinchAPI
         sig { returns(T.nilable(Float)) }
         attr_accessor :minutes_to_expire
 
-        # The Finch products to request access to
-        sig do
-          returns(
-            T::Array[FinchAPI::Connect::SessionNewParams::Product::OrSymbol]
-          )
-        end
-        attr_accessor :products
-
         # The URI to redirect to after the Connect flow is completed
         sig { returns(T.nilable(String)) }
         attr_accessor :redirect_uri
@@ -74,17 +74,17 @@ module FinchAPI
 
         sig do
           params(
-            customer_email: T.nilable(String),
             customer_id: String,
             customer_name: String,
+            products:
+              T::Array[FinchAPI::Connect::SessionNewParams::Product::OrSymbol],
+            customer_email: T.nilable(String),
             integration:
               T.nilable(
                 FinchAPI::Connect::SessionNewParams::Integration::OrHash
               ),
             manual: T.nilable(T::Boolean),
             minutes_to_expire: T.nilable(Float),
-            products:
-              T::Array[FinchAPI::Connect::SessionNewParams::Product::OrSymbol],
             redirect_uri: T.nilable(String),
             sandbox:
               T.nilable(FinchAPI::Connect::SessionNewParams::Sandbox::OrSymbol),
@@ -92,25 +92,25 @@ module FinchAPI
           ).returns(T.attached_class)
         end
         def self.new(
-          # Email address of the customer
-          customer_email:,
           # Unique identifier for the customer
           customer_id:,
           # Name of the customer
           customer_name:,
+          # The Finch products to request access to
+          products:,
+          # Email address of the customer
+          customer_email: nil,
           # Integration configuration for the connect session
-          integration:,
+          integration: nil,
           # Enable manual authentication mode
-          manual:,
+          manual: nil,
           # The number of minutes until the session expires (defaults to 129,600, which is
           # 90 days)
-          minutes_to_expire:,
-          # The Finch products to request access to
-          products:,
+          minutes_to_expire: nil,
           # The URI to redirect to after the Connect flow is completed
-          redirect_uri:,
+          redirect_uri: nil,
           # Sandbox mode for testing
-          sandbox:,
+          sandbox: nil,
           request_options: {}
         )
         end
@@ -118,17 +118,17 @@ module FinchAPI
         sig do
           override.returns(
             {
-              customer_email: T.nilable(String),
               customer_id: String,
               customer_name: String,
-              integration:
-                T.nilable(FinchAPI::Connect::SessionNewParams::Integration),
-              manual: T.nilable(T::Boolean),
-              minutes_to_expire: T.nilable(Float),
               products:
                 T::Array[
                   FinchAPI::Connect::SessionNewParams::Product::OrSymbol
                 ],
+              customer_email: T.nilable(String),
+              integration:
+                T.nilable(FinchAPI::Connect::SessionNewParams::Integration),
+              manual: T.nilable(T::Boolean),
+              minutes_to_expire: T.nilable(Float),
               redirect_uri: T.nilable(String),
               sandbox:
                 T.nilable(
@@ -141,6 +141,78 @@ module FinchAPI
         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 do
+              T.all(Symbol, FinchAPI::Connect::SessionNewParams::Product)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          BENEFITS =
+            T.let(
+              :benefits,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+          COMPANY =
+            T.let(
+              :company,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+          DEDUCTION =
+            T.let(
+              :deduction,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+          DIRECTORY =
+            T.let(
+              :directory,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+          DOCUMENTS =
+            T.let(
+              :documents,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+          EMPLOYMENT =
+            T.let(
+              :employment,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+          INDIVIDUAL =
+            T.let(
+              :individual,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+          PAYMENT =
+            T.let(
+              :payment,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+          PAY_STATEMENT =
+            T.let(
+              :pay_statement,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+          SSN =
+            T.let(
+              :ssn,
+              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
         class Integration < FinchAPI::Internal::Type::BaseModel
           OrHash =
             T.type_alias do
@@ -150,6 +222,10 @@ module FinchAPI
               )
             end
 
+          # The provider to integrate with
+          sig { returns(String) }
+          attr_accessor :provider
+
           # The authentication method to use
           sig do
             returns(
@@ -160,36 +236,32 @@ module FinchAPI
           end
           attr_accessor :auth_method
 
-          # The provider to integrate with
-          sig { returns(T.nilable(String)) }
-          attr_accessor :provider
-
           # Integration configuration for the connect session
           sig do
             params(
+              provider: String,
               auth_method:
                 T.nilable(
                   FinchAPI::Connect::SessionNewParams::Integration::AuthMethod::OrSymbol
-                ),
-              provider: T.nilable(String)
+                )
             ).returns(T.attached_class)
           end
           def self.new(
-            # The authentication method to use
-            auth_method:,
             # The provider to integrate with
-            provider:
+            provider:,
+            # The authentication method to use
+            auth_method: nil
           )
           end
 
           sig do
             override.returns(
               {
+                provider: String,
                 auth_method:
                   T.nilable(
                     FinchAPI::Connect::SessionNewParams::Integration::AuthMethod::OrSymbol
-                  ),
-                provider: T.nilable(String)
+                  )
               }
             )
           end
@@ -242,78 +314,6 @@ module FinchAPI
           end
         end
 
-        # The Finch products that can be requested during the Connect flow.
-        module Product
-          extend FinchAPI::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, FinchAPI::Connect::SessionNewParams::Product)
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          BENEFITS =
-            T.let(
-              :benefits,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-          COMPANY =
-            T.let(
-              :company,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-          DEDUCTION =
-            T.let(
-              :deduction,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-          DIRECTORY =
-            T.let(
-              :directory,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-          DOCUMENTS =
-            T.let(
-              :documents,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-          EMPLOYMENT =
-            T.let(
-              :employment,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-          INDIVIDUAL =
-            T.let(
-              :individual,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-          PAYMENT =
-            T.let(
-              :payment,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-          PAY_STATEMENT =
-            T.let(
-              :pay_statement,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-          SSN =
-            T.let(
-              :ssn,
-              FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                FinchAPI::Connect::SessionNewParams::Product::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-
         # Sandbox mode for testing
         module Sandbox
           extend FinchAPI::Internal::Type::Enum

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

@@ -21,8 +21,11 @@ module FinchAPI
 
         # The number of minutes until the session expires (defaults to 43,200, which is 30
         # days)
-        sig { returns(Integer) }
-        attr_accessor :minutes_to_expire
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :minutes_to_expire
+
+        sig { params(minutes_to_expire: Integer).void }
+        attr_writer :minutes_to_expire
 
         # The products to request access to (optional for reauthentication)
         sig do
@@ -59,11 +62,11 @@ module FinchAPI
           connection_id:,
           # The number of minutes until the session expires (defaults to 43,200, which is 30
           # days)
-          minutes_to_expire:,
+          minutes_to_expire: nil,
           # The products to request access to (optional for reauthentication)
-          products:,
+          products: nil,
           # The URI to redirect to after the Connect flow is completed
-          redirect_uri:,
+          redirect_uri: nil,
           request_options: {}
         )
         end

data/rbi/finch_api/resources/connect/sessions.rbi

@@ -7,17 +7,17 @@ module FinchAPI
         # Create a new connect session for an employer
         sig do
           params(
-            customer_email: T.nilable(String),
             customer_id: String,
             customer_name: String,
+            products:
+              T::Array[FinchAPI::Connect::SessionNewParams::Product::OrSymbol],
+            customer_email: T.nilable(String),
             integration:
               T.nilable(
                 FinchAPI::Connect::SessionNewParams::Integration::OrHash
               ),
             manual: T.nilable(T::Boolean),
             minutes_to_expire: T.nilable(Float),
-            products:
-              T::Array[FinchAPI::Connect::SessionNewParams::Product::OrSymbol],
             redirect_uri: T.nilable(String),
             sandbox:
               T.nilable(FinchAPI::Connect::SessionNewParams::Sandbox::OrSymbol),
@@ -25,25 +25,25 @@ module FinchAPI
           ).returns(FinchAPI::Models::Connect::SessionNewResponse)
         end
         def new(
-          # Email address of the customer
-          customer_email:,
           # Unique identifier for the customer
           customer_id:,
           # Name of the customer
           customer_name:,
+          # The Finch products to request access to
+          products:,
+          # Email address of the customer
+          customer_email: nil,
           # Integration configuration for the connect session
-          integration:,
+          integration: nil,
           # Enable manual authentication mode
-          manual:,
+          manual: nil,
           # The number of minutes until the session expires (defaults to 129,600, which is
           # 90 days)
-          minutes_to_expire:,
-          # The Finch products to request access to
-          products:,
+          minutes_to_expire: nil,
           # The URI to redirect to after the Connect flow is completed
-          redirect_uri:,
+          redirect_uri: nil,
           # Sandbox mode for testing
-          sandbox:,
+          sandbox: nil,
           request_options: {}
         )
         end
@@ -68,11 +68,11 @@ module FinchAPI
           connection_id:,
           # The number of minutes until the session expires (defaults to 43,200, which is 30
           # days)
-          minutes_to_expire:,
+          minutes_to_expire: nil,
           # The products to request access to (optional for reauthentication)
-          products:,
+          products: nil,
           # The URI to redirect to after the Connect flow is completed
-          redirect_uri:,
+          redirect_uri: nil,
           request_options: {}
         )
         end

data/sig/finch_api/internal/transport/base_client.rbs

@@ -87,6 +87,8 @@ module FinchAPI
 
         private def auth_headers: -> ::Hash[String, String]
 
+        private def user_agent: -> String
+
         private def generate_idempotency_key: -> String
 
         private def build_request: (

data/sig/finch_api/models/connect/session_new_params.rbs

@@ -3,13 +3,13 @@ module FinchAPI
     module Connect
       type session_new_params =
         {
-          customer_email: String?,
           customer_id: String,
           customer_name: String,
+          products: ::Array[FinchAPI::Models::Connect::SessionNewParams::product],
+          customer_email: String?,
           integration: FinchAPI::Connect::SessionNewParams::Integration?,
           manual: bool?,
           minutes_to_expire: Float?,
-          products: ::Array[FinchAPI::Models::Connect::SessionNewParams::product],
           redirect_uri: String?,
           sandbox: FinchAPI::Models::Connect::SessionNewParams::sandbox?
         }
@@ -19,85 +19,50 @@ module FinchAPI
         extend FinchAPI::Internal::Type::RequestParameters::Converter
         include FinchAPI::Internal::Type::RequestParameters
 
-        attr_accessor customer_email: String?
-
         attr_accessor customer_id: String
 
         attr_accessor customer_name: String
 
+        attr_accessor products: ::Array[FinchAPI::Models::Connect::SessionNewParams::product]
+
+        attr_accessor customer_email: String?
+
         attr_accessor integration: FinchAPI::Connect::SessionNewParams::Integration?
 
         attr_accessor manual: bool?
 
         attr_accessor minutes_to_expire: Float?
 
-        attr_accessor products: ::Array[FinchAPI::Models::Connect::SessionNewParams::product]
-
         attr_accessor redirect_uri: String?
 
         attr_accessor sandbox: FinchAPI::Models::Connect::SessionNewParams::sandbox?
 
         def initialize: (
-          customer_email: String?,
           customer_id: String,
           customer_name: String,
-          integration: FinchAPI::Connect::SessionNewParams::Integration?,
-          manual: bool?,
-          minutes_to_expire: Float?,
           products: ::Array[FinchAPI::Models::Connect::SessionNewParams::product],
-          redirect_uri: String?,
-          sandbox: FinchAPI::Models::Connect::SessionNewParams::sandbox?,
+          ?customer_email: String?,
+          ?integration: FinchAPI::Connect::SessionNewParams::Integration?,
+          ?manual: bool?,
+          ?minutes_to_expire: Float?,
+          ?redirect_uri: String?,
+          ?sandbox: FinchAPI::Models::Connect::SessionNewParams::sandbox?,
           ?request_options: FinchAPI::request_opts
         ) -> void
 
         def to_hash: -> {
-          customer_email: String?,
           customer_id: String,
           customer_name: String,
+          products: ::Array[FinchAPI::Models::Connect::SessionNewParams::product],
+          customer_email: String?,
           integration: FinchAPI::Connect::SessionNewParams::Integration?,
           manual: bool?,
           minutes_to_expire: Float?,
-          products: ::Array[FinchAPI::Models::Connect::SessionNewParams::product],
           redirect_uri: String?,
           sandbox: FinchAPI::Models::Connect::SessionNewParams::sandbox?,
           request_options: FinchAPI::RequestOptions
         }
 
-        type integration =
-          {
-            auth_method: FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method?,
-            provider: String?
-          }
-
-        class Integration < FinchAPI::Internal::Type::BaseModel
-          attr_accessor auth_method: FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method?
-
-          attr_accessor provider: String?
-
-          def initialize: (
-            auth_method: FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method?,
-            provider: String?
-          ) -> void
-
-          def to_hash: -> {
-            auth_method: FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method?,
-            provider: String?
-          }
-
-          type auth_method = :assisted | :credential | :oauth | :api_token
-
-          module AuthMethod
-            extend FinchAPI::Internal::Type::Enum
-
-            ASSISTED: :assisted
-            CREDENTIAL: :credential
-            OAUTH: :oauth
-            API_TOKEN: :api_token
-
-            def self?.values: -> ::Array[FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method]
-          end
-        end
-
         type product =
           :benefits
           | :company
@@ -127,6 +92,41 @@ module FinchAPI
           def self?.values: -> ::Array[FinchAPI::Models::Connect::SessionNewParams::product]
         end
 
+        type integration =
+          {
+            provider: String,
+            auth_method: FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method?
+          }
+
+        class Integration < FinchAPI::Internal::Type::BaseModel
+          attr_accessor provider: String
+
+          attr_accessor auth_method: FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method?
+
+          def initialize: (
+            provider: String,
+            ?auth_method: FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method?
+          ) -> void
+
+          def to_hash: -> {
+            provider: String,
+            auth_method: FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method?
+          }
+
+          type auth_method = :assisted | :credential | :oauth | :api_token
+
+          module AuthMethod
+            extend FinchAPI::Internal::Type::Enum
+
+            ASSISTED: :assisted
+            CREDENTIAL: :credential
+            OAUTH: :oauth
+            API_TOKEN: :api_token
+
+            def self?.values: -> ::Array[FinchAPI::Models::Connect::SessionNewParams::Integration::auth_method]
+          end
+        end
+
         type sandbox = :finch | :provider
 
         module Sandbox

data/sig/finch_api/models/connect/session_reauthenticate_params.rbs

@@ -16,7 +16,9 @@ module FinchAPI
 
         attr_accessor connection_id: String
 
-        attr_accessor minutes_to_expire: Integer
+        attr_reader minutes_to_expire: Integer?
+
+        def minutes_to_expire=: (Integer) -> Integer
 
         attr_accessor products: ::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::product]?
 
@@ -24,9 +26,9 @@ module FinchAPI
 
         def initialize: (
           connection_id: String,
-          minutes_to_expire: Integer,
-          products: ::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::product]?,
-          redirect_uri: String?,
+          ?minutes_to_expire: Integer,
+          ?products: ::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::product]?,
+          ?redirect_uri: String?,
           ?request_options: FinchAPI::request_opts
         ) -> void
 

data/sig/finch_api/resources/connect/sessions.rbs

@@ -3,23 +3,23 @@ module FinchAPI
     class Connect
       class Sessions
         def new: (
-          customer_email: String?,
           customer_id: String,
           customer_name: String,
-          integration: FinchAPI::Connect::SessionNewParams::Integration?,
-          manual: bool?,
-          minutes_to_expire: Float?,
           products: ::Array[FinchAPI::Models::Connect::SessionNewParams::product],
-          redirect_uri: String?,
-          sandbox: FinchAPI::Models::Connect::SessionNewParams::sandbox?,
+          ?customer_email: String?,
+          ?integration: FinchAPI::Connect::SessionNewParams::Integration?,
+          ?manual: bool?,
+          ?minutes_to_expire: Float?,
+          ?redirect_uri: String?,
+          ?sandbox: FinchAPI::Models::Connect::SessionNewParams::sandbox?,
           ?request_options: FinchAPI::request_opts
         ) -> FinchAPI::Models::Connect::SessionNewResponse
 
         def reauthenticate: (
           connection_id: String,
-          minutes_to_expire: Integer,
-          products: ::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::product]?,
-          redirect_uri: String?,
+          ?minutes_to_expire: Integer,
+          ?products: ::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::product]?,
+          ?redirect_uri: String?,
           ?request_options: FinchAPI::request_opts
         ) -> FinchAPI::Models::Connect::SessionReauthenticateResponse
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finch-api
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha.32
+  version: 0.1.0.pre.alpha.34
 platform: ruby
 authors:
 - Finch
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-31 00:00:00.000000000 Z
+date: 2025-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool