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

data/rbi/finch_api/models/provider_list_response.rbi

@@ -0,0 +1,280 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class ProviderListResponse < FinchAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            FinchAPI::Models::ProviderListResponse,
+            FinchAPI::Internal::AnyHash
+          )
+        end
+
+      # The id of the payroll provider used in Connect.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The display name of the payroll provider.
+      sig { returns(String) }
+      attr_accessor :display_name
+
+      # The list of Finch products supported on this payroll provider.
+      sig { returns(T::Array[String]) }
+      attr_accessor :products
+
+      # The authentication methods supported by the provider.
+      sig do
+        returns(
+          T.nilable(
+            T::Array[
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod
+            ]
+          )
+        )
+      end
+      attr_reader :authentication_methods
+
+      sig do
+        params(
+          authentication_methods:
+            T::Array[
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod::OrHash
+            ]
+        ).void
+      end
+      attr_writer :authentication_methods
+
+      # `true` if the integration is in a beta state, `false` otherwise
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :beta
+
+      sig { params(beta: T::Boolean).void }
+      attr_writer :beta
+
+      # The url to the official icon of the payroll provider.
+      sig { returns(T.nilable(String)) }
+      attr_reader :icon
+
+      sig { params(icon: String).void }
+      attr_writer :icon
+
+      # The url to the official logo of the payroll provider.
+      sig { returns(T.nilable(String)) }
+      attr_reader :logo
+
+      sig { params(logo: String).void }
+      attr_writer :logo
+
+      # [DEPRECATED] Whether the Finch integration with this provider uses the Assisted
+      # Connect Flow by default. This field is now deprecated. Please check for a `type`
+      # of `assisted` in the `authentication_methods` field instead.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :manual
+
+      sig { params(manual: T::Boolean).void }
+      attr_writer :manual
+
+      # whether MFA is required for the provider.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :mfa_required
+
+      sig { params(mfa_required: T::Boolean).void }
+      attr_writer :mfa_required
+
+      # The hex code for the primary color of the payroll provider.
+      sig { returns(T.nilable(String)) }
+      attr_reader :primary_color
+
+      sig { params(primary_color: String).void }
+      attr_writer :primary_color
+
+      sig do
+        params(
+          id: String,
+          display_name: String,
+          products: T::Array[String],
+          authentication_methods:
+            T::Array[
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod::OrHash
+            ],
+          beta: T::Boolean,
+          icon: String,
+          logo: String,
+          manual: T::Boolean,
+          mfa_required: T::Boolean,
+          primary_color: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The id of the payroll provider used in Connect.
+        id:,
+        # The display name of the payroll provider.
+        display_name:,
+        # The list of Finch products supported on this payroll provider.
+        products:,
+        # The authentication methods supported by the provider.
+        authentication_methods: nil,
+        # `true` if the integration is in a beta state, `false` otherwise
+        beta: nil,
+        # The url to the official icon of the payroll provider.
+        icon: nil,
+        # The url to the official logo of the payroll provider.
+        logo: nil,
+        # [DEPRECATED] Whether the Finch integration with this provider uses the Assisted
+        # Connect Flow by default. This field is now deprecated. Please check for a `type`
+        # of `assisted` in the `authentication_methods` field instead.
+        manual: nil,
+        # whether MFA is required for the provider.
+        mfa_required: nil,
+        # The hex code for the primary color of the payroll provider.
+        primary_color: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            display_name: String,
+            products: T::Array[String],
+            authentication_methods:
+              T::Array[
+                FinchAPI::Models::ProviderListResponse::AuthenticationMethod
+              ],
+            beta: T::Boolean,
+            icon: String,
+            logo: String,
+            manual: T::Boolean,
+            mfa_required: T::Boolean,
+            primary_color: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class AuthenticationMethod < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod,
+              FinchAPI::Internal::AnyHash
+            )
+          end
+
+        # The type of authentication method
+        sig do
+          returns(
+            FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::TaggedSymbol
+          )
+        end
+        attr_accessor :type
+
+        # The supported benefit types and their configurations
+        sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
+        attr_reader :benefits_support
+
+        sig do
+          params(benefits_support: T::Hash[Symbol, T.nilable(T.anything)]).void
+        end
+        attr_writer :benefits_support
+
+        # The supported fields for each Finch product
+        sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
+        attr_reader :supported_fields
+
+        sig do
+          params(supported_fields: T::Hash[Symbol, T.nilable(T.anything)]).void
+        end
+        attr_writer :supported_fields
+
+        sig do
+          params(
+            type:
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::OrSymbol,
+            benefits_support: T::Hash[Symbol, T.nilable(T.anything)],
+            supported_fields: T::Hash[Symbol, T.nilable(T.anything)]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The type of authentication method
+          type:,
+          # The supported benefit types and their configurations
+          benefits_support: nil,
+          # The supported fields for each Finch product
+          supported_fields: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              type:
+                FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::TaggedSymbol,
+              benefits_support: T::Hash[Symbol, T.nilable(T.anything)],
+              supported_fields: T::Hash[Symbol, T.nilable(T.anything)]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The type of authentication method
+        module Type
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ASSISTED =
+            T.let(
+              :assisted,
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::TaggedSymbol
+            )
+          CREDENTIAL =
+            T.let(
+              :credential,
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::TaggedSymbol
+            )
+          API_TOKEN =
+            T.let(
+              :api_token,
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::TaggedSymbol
+            )
+          API_CREDENTIAL =
+            T.let(
+              :api_credential,
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::TaggedSymbol
+            )
+          OAUTH =
+            T.let(
+              :oauth,
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::TaggedSymbol
+            )
+          API =
+            T.let(
+              :api,
+              FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                FinchAPI::Models::ProviderListResponse::AuthenticationMethod::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/request_forwarding_forward_params.rbi

@@ -33,12 +33,12 @@ module FinchAPI
       # The HTTP headers to include on the forwarded request. This value must be
       # specified as an object of key-value pairs. Example:
       # `{"Content-Type": "application/xml", "X-API-Version": "v1" }`
-      sig { returns(T.nilable(T.anything)) }
+      sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
       attr_accessor :headers
 
       # The query parameters for the forwarded request. This value must be specified as
       # a valid JSON object rather than a query string.
-      sig { returns(T.nilable(T.anything)) }
+      sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
       attr_accessor :params
 
       sig do
@@ -46,8 +46,8 @@ module FinchAPI
           method_: String,
           route: String,
           data: T.nilable(String),
-          headers: T.nilable(T.anything),
-          params: T.nilable(T.anything),
+          headers: T.nilable(T::Hash[Symbol, T.nilable(T.anything)]),
+          params: T.nilable(T::Hash[Symbol, T.nilable(T.anything)]),
           request_options: FinchAPI::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
@@ -79,8 +79,8 @@ module FinchAPI
             method_: String,
             route: String,
             data: T.nilable(String),
-            headers: T.nilable(T.anything),
-            params: T.nilable(T.anything),
+            headers: T.nilable(T::Hash[Symbol, T.nilable(T.anything)]),
+            params: T.nilable(T::Hash[Symbol, T.nilable(T.anything)]),
             request_options: FinchAPI::RequestOptions
           }
         )

data/rbi/finch_api/models/request_forwarding_forward_response.rbi

@@ -11,17 +11,6 @@ module FinchAPI
           )
         end
 
-      # A string representation of the HTTP response body of the forwarded request's
-      # response received from the underlying integration's API. This field may be null
-      # in the case where the upstream system's response is empty.
-      sig { returns(T.nilable(String)) }
-      attr_accessor :data
-
-      # The HTTP headers of the forwarded request's response, exactly as received from
-      # the underlying integration's API.
-      sig { returns(T.nilable(T.anything)) }
-      attr_accessor :headers
-
       # An object containing details of your original forwarded request, for your ease
       # of reference.
       sig do
@@ -42,40 +31,51 @@ module FinchAPI
       sig { returns(Integer) }
       attr_accessor :status_code
 
+      # A string representation of the HTTP response body of the forwarded request's
+      # response received from the underlying integration's API. This field may be null
+      # in the case where the upstream system's response is empty.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :data
+
+      # The HTTP headers of the forwarded request's response, exactly as received from
+      # the underlying integration's API.
+      sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
+      attr_accessor :headers
+
       sig do
         params(
-          data: T.nilable(String),
-          headers: T.nilable(T.anything),
           request:
             FinchAPI::Models::RequestForwardingForwardResponse::Request::OrHash,
-          status_code: Integer
+          status_code: Integer,
+          data: T.nilable(String),
+          headers: T.nilable(T::Hash[Symbol, T.nilable(T.anything)])
         ).returns(T.attached_class)
       end
       def self.new(
-        # A string representation of the HTTP response body of the forwarded request's
-        # response received from the underlying integration's API. This field may be null
-        # in the case where the upstream system's response is empty.
-        data:,
-        # The HTTP headers of the forwarded request's response, exactly as received from
-        # the underlying integration's API.
-        headers:,
         # An object containing details of your original forwarded request, for your ease
         # of reference.
         request:,
         # The HTTP status code of the forwarded request's response, exactly received from
         # the underlying integration's API. This value will be returned as an integer.
-        status_code:
+        status_code:,
+        # A string representation of the HTTP response body of the forwarded request's
+        # response received from the underlying integration's API. This field may be null
+        # in the case where the upstream system's response is empty.
+        data: nil,
+        # The HTTP headers of the forwarded request's response, exactly as received from
+        # the underlying integration's API.
+        headers: nil
       )
       end
 
       sig do
         override.returns(
           {
-            data: T.nilable(String),
-            headers: T.nilable(T.anything),
             request:
               FinchAPI::Models::RequestForwardingForwardResponse::Request,
-            status_code: Integer
+            status_code: Integer,
+            data: T.nilable(String),
+            headers: T.nilable(T::Hash[Symbol, T.nilable(T.anything)])
           }
         )
       end
@@ -91,74 +91,107 @@ module FinchAPI
             )
           end
 
-        # The body that was specified for the forwarded request. If a value was not
-        # specified in the original request, this value will be returned as null ;
-        # otherwise, this value will always be returned as a string.
-        sig { returns(T.nilable(String)) }
-        attr_accessor :data
-
-        # The specified HTTP headers that were included in the forwarded request. If no
-        # headers were specified, this will be returned as `null`.
-        sig { returns(T.nilable(T.anything)) }
-        attr_accessor :headers
-
         # The HTTP method that was specified for the forwarded request. Valid values
         # include: `GET` , `POST` , `PUT` , `DELETE` , and `PATCH`.
         sig { returns(String) }
         attr_accessor :method_
 
-        # The query parameters that were included in the forwarded request. If no query
-        # parameters were specified, this will be returned as `null`.
-        sig { returns(T.nilable(T.anything)) }
-        attr_accessor :params
-
         # The URL route path that was specified for the forwarded request.
         sig { returns(String) }
         attr_accessor :route
 
+        # The body that was specified for the forwarded request.
+        sig do
+          returns(
+            T.nilable(
+              FinchAPI::Models::RequestForwardingForwardResponse::Request::Data::Variants
+            )
+          )
+        end
+        attr_accessor :data
+
+        # The HTTP headers that were specified for the forwarded request.
+        sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
+        attr_accessor :headers
+
+        # The query parameters that were specified for the forwarded request.
+        sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
+        attr_accessor :params
+
         # An object containing details of your original forwarded request, for your ease
         # of reference.
         sig do
           params(
-            data: T.nilable(String),
-            headers: T.nilable(T.anything),
             method_: String,
-            params: T.nilable(T.anything),
-            route: String
+            route: String,
+            data:
+              T.nilable(
+                FinchAPI::Models::RequestForwardingForwardResponse::Request::Data::Variants
+              ),
+            headers: T.nilable(T::Hash[Symbol, T.nilable(T.anything)]),
+            params: T.nilable(T::Hash[Symbol, T.nilable(T.anything)])
           ).returns(T.attached_class)
         end
         def self.new(
-          # The body that was specified for the forwarded request. If a value was not
-          # specified in the original request, this value will be returned as null ;
-          # otherwise, this value will always be returned as a string.
-          data:,
-          # The specified HTTP headers that were included in the forwarded request. If no
-          # headers were specified, this will be returned as `null`.
-          headers:,
           # The HTTP method that was specified for the forwarded request. Valid values
           # include: `GET` , `POST` , `PUT` , `DELETE` , and `PATCH`.
           method_:,
-          # The query parameters that were included in the forwarded request. If no query
-          # parameters were specified, this will be returned as `null`.
-          params:,
           # The URL route path that was specified for the forwarded request.
-          route:
+          route:,
+          # The body that was specified for the forwarded request.
+          data: nil,
+          # The HTTP headers that were specified for the forwarded request.
+          headers: nil,
+          # The query parameters that were specified for the forwarded request.
+          params: nil
         )
         end
 
         sig do
           override.returns(
             {
-              data: T.nilable(String),
-              headers: T.nilable(T.anything),
               method_: String,
-              params: T.nilable(T.anything),
-              route: String
+              route: String,
+              data:
+                T.nilable(
+                  FinchAPI::Models::RequestForwardingForwardResponse::Request::Data::Variants
+                ),
+              headers: T.nilable(T::Hash[Symbol, T.nilable(T.anything)]),
+              params: T.nilable(T::Hash[Symbol, T.nilable(T.anything)])
             }
           )
         end
         def to_hash
         end
+
+        # The body that was specified for the forwarded request.
+        module Data
+          extend FinchAPI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(String, T::Hash[Symbol, T.nilable(T.anything)])
+            end
+
+          sig do
+            override.returns(
+              T::Array[
+                FinchAPI::Models::RequestForwardingForwardResponse::Request::Data::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+
+          UnionMember1Map =
+            T.let(
+              FinchAPI::Internal::Type::HashOf[
+                FinchAPI::Internal::Type::Unknown,
+                nil?: true
+              ],
+              FinchAPI::Internal::Type::Converter
+            )
+        end
       end
     end
   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,17 +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:,
-          products:,
-          customer_email: nil,
-          integration: nil,
-          manual: nil,
+          # Integration configuration for the connect session
+          integration:,
+          # Enable manual authentication mode
+          manual:,
           # The number of minutes until the session expires (defaults to 129,600, which is
           # 90 days)
-          minutes_to_expire: nil,
-          redirect_uri: nil,
-          sandbox: nil,
+          minutes_to_expire:,
+          # The Finch products to request access to
+          products:,
+          # The URI to redirect to after the Connect flow is completed
+          redirect_uri:,
+          # Sandbox mode for testing
+          sandbox:,
           request_options: {}
         )
         end
@@ -44,7 +52,7 @@ module FinchAPI
         sig do
           params(
             connection_id: String,
-            minutes_to_expire: T.nilable(Integer),
+            minutes_to_expire: Integer,
             products:
               T.nilable(
                 T::Array[
@@ -60,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: nil,
+          minutes_to_expire:,
           # The products to request access to (optional for reauthentication)
-          products: nil,
+          products:,
           # The URI to redirect to after the Connect flow is completed
-          redirect_uri: nil,
+          redirect_uri:,
           request_options: {}
         )
         end

data/rbi/finch_api/resources/hris/benefits/individuals.rbi

@@ -12,6 +12,7 @@ module FinchAPI
           sig do
             params(
               benefit_id: String,
+              entity_ids: T::Array[String],
               individuals:
                 T::Array[
                   FinchAPI::HRIS::Benefits::IndividualEnrollManyParams::Individual::OrHash
@@ -22,8 +23,11 @@ module FinchAPI
             )
           end
           def enroll_many(
+            # Path param:
             benefit_id,
-            # Array of the individual_id to enroll and a configuration object.
+            # Query param: The entity IDs to specify which entities' data to access.
+            entity_ids: nil,
+            # Body param: Array of the individual_id to enroll and a configuration object.
             individuals: nil,
             request_options: {}
           )
@@ -33,18 +37,25 @@ module FinchAPI
           sig do
             params(
               benefit_id: String,
+              entity_ids: T::Array[String],
               request_options: FinchAPI::RequestOptions::OrHash
             ).returns(
               FinchAPI::Models::HRIS::Benefits::IndividualEnrolledIDsResponse
             )
           end
-          def enrolled_ids(benefit_id, request_options: {})
+          def enrolled_ids(
+            benefit_id,
+            # The entity IDs to specify which entities' data to access.
+            entity_ids: nil,
+            request_options: {}
+          )
           end
 
           # Get enrollment information for the given individuals.
           sig do
             params(
               benefit_id: String,
+              entity_ids: T::Array[String],
               individual_ids: String,
               request_options: FinchAPI::RequestOptions::OrHash
             ).returns(
@@ -55,6 +66,8 @@ module FinchAPI
           end
           def retrieve_many_benefits(
             benefit_id,
+            # The entity IDs to specify which entities' data to access.
+            entity_ids: nil,
             # comma-delimited list of stable Finch uuids for each individual. If empty,
             # defaults to all individuals
             individual_ids: nil,
@@ -66,6 +79,7 @@ module FinchAPI
           sig do
             params(
               benefit_id: String,
+              entity_ids: T::Array[String],
               individual_ids: T::Array[String],
               request_options: FinchAPI::RequestOptions::OrHash
             ).returns(
@@ -73,8 +87,11 @@ module FinchAPI
             )
           end
           def unenroll_many(
+            # Path param:
             benefit_id,
-            # Array of individual_ids to unenroll.
+            # Query param: The entity IDs to specify which entities' data to access.
+            entity_ids: nil,
+            # Body param: Array of individual_ids to unenroll.
             individual_ids: nil,
             request_options: {}
           )