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

data/rbi/finch_api/models/sandbox/payment_create_response.rbi

@@ -4,6 +4,9 @@ module FinchAPI
   module Models
     module Sandbox
       class PaymentCreateResponse < FinchAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
         # The date of the payment.
         sig { returns(String) }
         attr_accessor :pay_date
@@ -12,15 +15,20 @@ module FinchAPI
         sig { returns(String) }
         attr_accessor :payment_id
 
-        sig { params(pay_date: String, payment_id: String).returns(T.attached_class) }
+        sig do
+          params(pay_date: String, payment_id: String).returns(T.attached_class)
+        end
         def self.new(
           # The date of the payment.
           pay_date:,
           # The ID of the payment.
           payment_id:
-        ); end
-        sig { override.returns({pay_date: String, payment_id: String}) }
-        def to_hash; end
+        )
+        end
+
+        sig { override.returns({ pay_date: String, payment_id: String }) }
+        def to_hash
+        end
       end
     end
   end

data/rbi/finch_api/models/webhook_event.rbi

@@ -5,13 +5,23 @@ module FinchAPI
     module WebhookEvent
       extend FinchAPI::Internal::Type::Union
 
-      sig do
-        override
-          .returns(
-            [FinchAPI::Models::AccountUpdateEvent, FinchAPI::Models::CompanyEvent, FinchAPI::Models::JobCompletionEvent, FinchAPI::Models::DirectoryEvent, FinchAPI::Models::EmploymentEvent, FinchAPI::Models::IndividualEvent, FinchAPI::Models::PaymentEvent, FinchAPI::Models::PayStatementEvent]
+      Variants =
+        T.type_alias do
+          T.any(
+            FinchAPI::AccountUpdateEvent,
+            FinchAPI::CompanyEvent,
+            FinchAPI::JobCompletionEvent,
+            FinchAPI::DirectoryEvent,
+            FinchAPI::EmploymentEvent,
+            FinchAPI::IndividualEvent,
+            FinchAPI::PaymentEvent,
+            FinchAPI::PayStatementEvent
           )
+        end
+
+      sig { override.returns(T::Array[FinchAPI::WebhookEvent::Variants]) }
+      def self.variants
       end
-      def self.variants; end
     end
   end
 end

data/rbi/finch_api/models.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module FinchAPI
+  AccessTokenCreateParams = FinchAPI::Models::AccessTokenCreateParams
+
+  AccountDisconnectParams = FinchAPI::Models::AccountDisconnectParams
+
+  AccountIntrospectParams = FinchAPI::Models::AccountIntrospectParams
+
+  AccountUpdateEvent = FinchAPI::Models::AccountUpdateEvent
+
+  BaseWebhookEvent = FinchAPI::Models::BaseWebhookEvent
+
+  CompanyEvent = FinchAPI::Models::CompanyEvent
+
+  Connect = FinchAPI::Models::Connect
+
+  ConnectionStatusType = FinchAPI::Models::ConnectionStatusType
+
+  CreateAccessTokenResponse = FinchAPI::Models::CreateAccessTokenResponse
+
+  DirectoryEvent = FinchAPI::Models::DirectoryEvent
+
+  DisconnectResponse = FinchAPI::Models::DisconnectResponse
+
+  EmploymentEvent = FinchAPI::Models::EmploymentEvent
+
+  HRIS = FinchAPI::Models::HRIS
+
+  Income = FinchAPI::Models::Income
+
+  IndividualEvent = FinchAPI::Models::IndividualEvent
+
+  Introspection = FinchAPI::Models::Introspection
+
+  JobCompletionEvent = FinchAPI::Models::JobCompletionEvent
+
+  Jobs = FinchAPI::Models::Jobs
+
+  Location = FinchAPI::Models::Location
+
+  Money = FinchAPI::Models::Money
+
+  OperationSupport = FinchAPI::Models::OperationSupport
+
+  OperationSupportMatrix = FinchAPI::Models::OperationSupportMatrix
+
+  Paging = FinchAPI::Models::Paging
+
+  PaymentEvent = FinchAPI::Models::PaymentEvent
+
+  Payroll = FinchAPI::Models::Payroll
+
+  PayStatementEvent = FinchAPI::Models::PayStatementEvent
+
+  Provider = FinchAPI::Models::Provider
+
+  ProviderListParams = FinchAPI::Models::ProviderListParams
+
+  RequestForwardingForwardParams =
+    FinchAPI::Models::RequestForwardingForwardParams
+
+  Sandbox = FinchAPI::Models::Sandbox
+
+  WebhookEvent = FinchAPI::Models::WebhookEvent
+end

data/rbi/finch_api/request_options.rbi

@@ -1,17 +1,18 @@
 # typed: strong
 
 module FinchAPI
-  RequestOpts = T.type_alias { T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash) }
-
   # Specify HTTP behaviour to use for a specific request. These options supplement
   # or override those provided at the client level.
   #
   # When making a request, you can pass an actual {RequestOptions} instance, or
   # simply pass a Hash with symbol keys matching the attributes on this class.
   class RequestOptions < FinchAPI::Internal::Type::BaseModel
+    OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+
     # @api private
-    sig { params(opts: T.any(T.self_type, T::Hash[Symbol, T.anything])).void }
-    def self.validate!(opts); end
+    sig { params(opts: FinchAPI::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
 
     # Idempotency key to send with request and all associated retries. Will only be
     # sent for write requests.
@@ -20,7 +21,11 @@ module FinchAPI
 
     # Extra query params to send with the request. These are `.merge`’d into any
     # `query` given at the client level.
-    sig { returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])) }
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
     attr_accessor :extra_query
 
     # Extra headers to send with the request. These are `.merged`’d into any
@@ -42,7 +47,10 @@ module FinchAPI
     attr_accessor :timeout
 
     # Returns a new instance of RequestOptions.
-    sig { params(values: FinchAPI::Internal::AnyHash).returns(T.attached_class) }
-    def self.new(values = {}); end
+    sig do
+      params(values: FinchAPI::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
   end
 end

data/rbi/finch_api/resources/access_tokens.rbi

@@ -10,15 +10,22 @@ module FinchAPI
           client_id: String,
           client_secret: String,
           redirect_uri: String,
-          request_options: FinchAPI::RequestOpts
-        )
-          .returns(FinchAPI::Models::CreateAccessTokenResponse)
+          request_options: FinchAPI::RequestOptions::OrHash
+        ).returns(FinchAPI::CreateAccessTokenResponse)
+      end
+      def create(
+        code:,
+        client_id: nil,
+        client_secret: nil,
+        redirect_uri: nil,
+        request_options: {}
+      )
       end
-      def create(code:, client_id: nil, client_secret: nil, redirect_uri: nil, request_options: {}); end
 
       # @api private
       sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/finch_api/resources/account.rbi

@@ -4,16 +4,27 @@ module FinchAPI
   module Resources
     class Account
       # Disconnect one or more `access_token`s from your application.
-      sig { params(request_options: FinchAPI::RequestOpts).returns(FinchAPI::Models::DisconnectResponse) }
-      def disconnect(request_options: {}); end
+      sig do
+        params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+          FinchAPI::DisconnectResponse
+        )
+      end
+      def disconnect(request_options: {})
+      end
 
       # Read account information associated with an `access_token`
-      sig { params(request_options: FinchAPI::RequestOpts).returns(FinchAPI::Models::Introspection) }
-      def introspect(request_options: {}); end
+      sig do
+        params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+          FinchAPI::Introspection
+        )
+      end
+      def introspect(request_options: {})
+      end
 
       # @api private
       sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

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

@@ -9,16 +9,20 @@ module FinchAPI
           params(
             customer_id: String,
             customer_name: String,
-            products: T::Array[FinchAPI::Models::Connect::SessionNewParams::Product::OrSymbol],
+            products:
+              T::Array[FinchAPI::Connect::SessionNewParams::Product::OrSymbol],
             customer_email: T.nilable(String),
-            integration: T.nilable(T.any(FinchAPI::Models::Connect::SessionNewParams::Integration, FinchAPI::Internal::AnyHash)),
+            integration:
+              T.nilable(
+                FinchAPI::Connect::SessionNewParams::Integration::OrHash
+              ),
             manual: T.nilable(T::Boolean),
             minutes_to_expire: T.nilable(Float),
             redirect_uri: T.nilable(String),
-            sandbox: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Sandbox::OrSymbol),
-            request_options: FinchAPI::RequestOpts
-          )
-            .returns(FinchAPI::Models::Connect::SessionNewResponse)
+            sandbox:
+              T.nilable(FinchAPI::Connect::SessionNewParams::Sandbox::OrSymbol),
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::Connect::SessionNewResponse)
         end
         def new(
           customer_id:,
@@ -33,17 +37,23 @@ module FinchAPI
           redirect_uri: nil,
           sandbox: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         # Create a new Connect session for reauthenticating an existing connection
         sig do
           params(
             connection_id: String,
             minutes_to_expire: T.nilable(Integer),
-            products: T.nilable(T::Array[FinchAPI::Models::Connect::SessionReauthenticateParams::Product::OrSymbol]),
+            products:
+              T.nilable(
+                T::Array[
+                  FinchAPI::Connect::SessionReauthenticateParams::Product::OrSymbol
+                ]
+              ),
             redirect_uri: T.nilable(String),
-            request_options: FinchAPI::RequestOpts
-          )
-            .returns(FinchAPI::Models::Connect::SessionReauthenticateResponse)
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::Connect::SessionReauthenticateResponse)
         end
         def reauthenticate(
           # The ID of the existing connection to reauthenticate
@@ -56,10 +66,13 @@ module FinchAPI
           # The URI to redirect to after the Connect flow is completed
           redirect_uri: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/connect.rbi

@@ -8,7 +8,8 @@ module FinchAPI
 
       # @api private
       sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

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

@@ -12,33 +12,46 @@ module FinchAPI
           sig do
             params(
               benefit_id: String,
-              individuals: T::Array[
-                T.any(
-                  FinchAPI::Models::HRIS::Benefits::IndividualEnrollManyParams::Individual,
-                  FinchAPI::Internal::AnyHash
-                )
-              ],
-              request_options: FinchAPI::RequestOpts
+              individuals:
+                T::Array[
+                  FinchAPI::HRIS::Benefits::IndividualEnrollManyParams::Individual::OrHash
+                ],
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::HRIS::Benefits::EnrolledIndividualBenefitResponse
             )
-              .returns(FinchAPI::Models::HRIS::Benefits::EnrolledIndividualBenefitResponse)
           end
           def enroll_many(
             benefit_id,
             # Array of the individual_id to enroll and a configuration object.
             individuals: nil,
             request_options: {}
-          ); end
+          )
+          end
+
           # Lists individuals currently enrolled in a given deduction.
           sig do
-            params(benefit_id: String, request_options: FinchAPI::RequestOpts)
-              .returns(FinchAPI::Models::HRIS::Benefits::IndividualEnrolledIDsResponse)
+            params(
+              benefit_id: String,
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::Models::HRIS::Benefits::IndividualEnrolledIDsResponse
+            )
+          end
+          def enrolled_ids(benefit_id, request_options: {})
           end
-          def enrolled_ids(benefit_id, request_options: {}); end
 
           # Get enrollment information for the given individuals.
           sig do
-            params(benefit_id: String, individual_ids: String, request_options: FinchAPI::RequestOpts)
-              .returns(FinchAPI::Internal::SinglePage[FinchAPI::Models::HRIS::Benefits::IndividualBenefit])
+            params(
+              benefit_id: String,
+              individual_ids: String,
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::Internal::SinglePage[
+                FinchAPI::HRIS::Benefits::IndividualBenefit
+              ]
+            )
           end
           def retrieve_many_benefits(
             benefit_id,
@@ -46,25 +59,31 @@ module FinchAPI
             # defaults to all individuals
             individual_ids: nil,
             request_options: {}
-          ); end
+          )
+          end
+
           # Unenroll individuals from a deduction or contribution
           sig do
             params(
               benefit_id: String,
               individual_ids: T::Array[String],
-              request_options: FinchAPI::RequestOpts
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::HRIS::Benefits::UnenrolledIndividualBenefitResponse
             )
-              .returns(FinchAPI::Models::HRIS::Benefits::UnenrolledIndividualBenefitResponse)
           end
           def unenroll_many(
             benefit_id,
             # Array of individual_ids to unenroll.
             individual_ids: nil,
             request_options: {}
-          ); end
+          )
+          end
+
           # @api private
           sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-          def self.new(client:); end
+          def self.new(client:)
+          end
         end
       end
     end

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

@@ -11,15 +11,15 @@ module FinchAPI
         # `/providers` endpoint to view available types for each provider.
         sig do
           params(
-            company_contribution: T.nilable(
-              T.any(FinchAPI::Models::HRIS::BenefitCreateParams::CompanyContribution, FinchAPI::Internal::AnyHash)
-            ),
+            company_contribution:
+              T.nilable(
+                FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::OrHash
+              ),
             description: String,
-            frequency: T.nilable(FinchAPI::Models::HRIS::BenefitFrequency::OrSymbol),
-            type: T.nilable(FinchAPI::Models::HRIS::BenefitType::OrSymbol),
-            request_options: FinchAPI::RequestOpts
-          )
-            .returns(FinchAPI::Models::HRIS::CreateCompanyBenefitsResponse)
+            frequency: T.nilable(FinchAPI::HRIS::BenefitFrequency::OrSymbol),
+            type: T.nilable(FinchAPI::HRIS::BenefitType::OrSymbol),
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::HRIS::CreateCompanyBenefitsResponse)
         end
         def create(
           # The company match for this benefit.
@@ -33,42 +33,59 @@ module FinchAPI
           # Type of benefit.
           type: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         # Lists deductions and contributions information for a given item
         sig do
-          params(benefit_id: String, request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Models::HRIS::CompanyBenefit)
+          params(
+            benefit_id: String,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::HRIS::CompanyBenefit)
+        end
+        def retrieve(benefit_id, request_options: {})
         end
-        def retrieve(benefit_id, request_options: {}); end
 
         # Updates an existing company-wide deduction or contribution
         sig do
-          params(benefit_id: String, description: String, request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Models::HRIS::UpdateCompanyBenefitResponse)
+          params(
+            benefit_id: String,
+            description: String,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::HRIS::UpdateCompanyBenefitResponse)
         end
         def update(
           benefit_id,
           # Updated name or description.
           description: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         # List all company-wide deductions and contributions.
         sig do
-          params(request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Internal::SinglePage[FinchAPI::Models::HRIS::CompanyBenefit])
+          params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+            FinchAPI::Internal::SinglePage[FinchAPI::HRIS::CompanyBenefit]
+          )
+        end
+        def list(request_options: {})
         end
-        def list(request_options: {}); end
 
         # Get deductions metadata
         sig do
-          params(request_options: FinchAPI::RequestOpts)
-            .returns(FinchAPI::Internal::SinglePage[FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse])
+          params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+            FinchAPI::Internal::SinglePage[
+              FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse
+            ]
+          )
+        end
+        def list_supported_benefits(request_options: {})
         end
-        def list_supported_benefits(request_options: {}); end
 
         # @api private
         sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/finch_api/resources/hris/company/pay_statement_item/rules.rbi

@@ -14,22 +14,20 @@ module FinchAPI
             # information is available.
             sig do
               params(
-                attributes: T.any(
-                  FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams::Attributes,
-                  FinchAPI::Internal::AnyHash
-                ),
-                conditions: T::Array[
-                  T.any(
-                    FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams::Condition,
-                    FinchAPI::Internal::AnyHash
-                  )
-                ],
+                attributes:
+                  FinchAPI::HRIS::Company::PayStatementItem::RuleCreateParams::Attributes::OrHash,
+                conditions:
+                  T::Array[
+                    FinchAPI::HRIS::Company::PayStatementItem::RuleCreateParams::Condition::OrHash
+                  ],
                 effective_end_date: T.nilable(String),
                 effective_start_date: T.nilable(String),
-                entity_type: FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateParams::EntityType::OrSymbol,
-                request_options: FinchAPI::RequestOpts
+                entity_type:
+                  FinchAPI::HRIS::Company::PayStatementItem::RuleCreateParams::EntityType::OrSymbol,
+                request_options: FinchAPI::RequestOptions::OrHash
+              ).returns(
+                FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateResponse
               )
-                .returns(FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateResponse)
             end
             def create(
               # Specifies the fields to be applied when the condition is met.
@@ -42,36 +40,52 @@ module FinchAPI
               # The entity type to which the rule is applied.
               entity_type: nil,
               request_options: {}
-            ); end
+            )
+            end
+
             # **Beta:** this endpoint currently serves employers onboarded after March 4th and
             # historical support will be added soon Update a rule for a pay statement item.
             sig do
-              params(rule_id: String, optional_property: T.anything, request_options: FinchAPI::RequestOpts)
-                .returns(FinchAPI::Models::HRIS::Company::PayStatementItem::RuleUpdateResponse)
+              params(
+                rule_id: String,
+                optional_property: T.anything,
+                request_options: FinchAPI::RequestOptions::OrHash
+              ).returns(
+                FinchAPI::Models::HRIS::Company::PayStatementItem::RuleUpdateResponse
+              )
+            end
+            def update(rule_id, optional_property: nil, request_options: {})
             end
-            def update(rule_id, optional_property: nil, request_options: {}); end
 
             # **Beta:** this endpoint currently serves employers onboarded after March 4th and
             # historical support will be added soon List all rules of a connection account.
             sig do
-              params(request_options: FinchAPI::RequestOpts)
-                .returns(
-                  FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::Company::PayStatementItem::RuleListResponse]
-                )
+              params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+                FinchAPI::Internal::ResponsesPage[
+                  FinchAPI::Models::HRIS::Company::PayStatementItem::RuleListResponse
+                ]
+              )
+            end
+            def list(request_options: {})
             end
-            def list(request_options: {}); end
 
             # **Beta:** this endpoint currently serves employers onboarded after March 4th and
             # historical support will be added soon Delete a rule for a pay statement item.
             sig do
-              params(rule_id: String, request_options: FinchAPI::RequestOpts)
-                .returns(FinchAPI::Models::HRIS::Company::PayStatementItem::RuleDeleteResponse)
+              params(
+                rule_id: String,
+                request_options: FinchAPI::RequestOptions::OrHash
+              ).returns(
+                FinchAPI::Models::HRIS::Company::PayStatementItem::RuleDeleteResponse
+              )
+            end
+            def delete(rule_id, request_options: {})
             end
-            def delete(rule_id, request_options: {}); end
 
             # @api private
             sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-            def self.new(client:); end
+            def self.new(client:)
+            end
           end
         end
       end

data/rbi/finch_api/resources/hris/company/pay_statement_item.rbi

@@ -5,7 +5,9 @@ module FinchAPI
     class HRIS
       class Company
         class PayStatementItem
-          sig { returns(FinchAPI::Resources::HRIS::Company::PayStatementItem::Rules) }
+          sig do
+            returns(FinchAPI::Resources::HRIS::Company::PayStatementItem::Rules)
+          end
           attr_reader :rules
 
           # **Beta:** this endpoint currently serves employers onboarded after March 4th and
@@ -13,14 +15,20 @@ module FinchAPI
           # items for the access token's connection account.
           sig do
             params(
-              categories: T::Array[FinchAPI::Models::HRIS::Company::PayStatementItemListParams::Category::OrSymbol],
+              categories:
+                T::Array[
+                  FinchAPI::HRIS::Company::PayStatementItemListParams::Category::OrSymbol
+                ],
               end_date: Date,
               name: String,
               start_date: Date,
               type: String,
-              request_options: FinchAPI::RequestOpts
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::Internal::ResponsesPage[
+                FinchAPI::Models::HRIS::Company::PayStatementItemListResponse
+              ]
             )
-              .returns(FinchAPI::Internal::ResponsesPage[FinchAPI::Models::HRIS::Company::PayStatementItemListResponse])
           end
           def list(
             # Comma-delimited list of pay statement item categories to filter on. If empty,
@@ -37,10 +45,13 @@ module FinchAPI
             # String search by pay statement item type.
             type: nil,
             request_options: {}
-          ); end
+          )
+          end
+
           # @api private
           sig { params(client: FinchAPI::Client).returns(T.attached_class) }
-          def self.new(client:); end
+          def self.new(client:)
+          end
         end
       end
     end