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

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

@@ -0,0 +1,35 @@
+# typed: strong
+
+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
+
+        # The ID of the payment.
+        sig { returns(String) }
+        attr_accessor :payment_id
+
+        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
+    end
+  end
+end

data/rbi/finch_api/models/webhook_event.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module WebhookEvent
+      extend FinchAPI::Internal::Type::Union
+
+      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
+    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

@@ -0,0 +1,56 @@
+# typed: strong
+
+module FinchAPI
+  # 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: 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.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    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
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    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

@@ -0,0 +1,31 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class AccessTokens
+      # Exchange the authorization code for an access token
+      sig do
+        params(
+          code: String,
+          client_id: String,
+          client_secret: String,
+          redirect_uri: String,
+          request_options: FinchAPI::RequestOptions::OrHash
+        ).returns(FinchAPI::CreateAccessTokenResponse)
+      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
+    end
+  end
+end

data/rbi/finch_api/resources/account.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Account
+      # Disconnect one or more `access_token`s from your application.
+      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 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
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Connect
+      class Sessions
+        # Create a new connect session for an employer
+        sig do
+          params(
+            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),
+            redirect_uri: T.nilable(String),
+            sandbox:
+              T.nilable(FinchAPI::Connect::SessionNewParams::Sandbox::OrSymbol),
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::Connect::SessionNewResponse)
+        end
+        def new(
+          customer_id:,
+          customer_name:,
+          products:,
+          customer_email: nil,
+          integration: nil,
+          manual: nil,
+          # The number of minutes until the session expires (defaults to 43,200, which is 30
+          # days)
+          minutes_to_expire: nil,
+          redirect_uri: nil,
+          sandbox: nil,
+          request_options: {}
+        )
+        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::Connect::SessionReauthenticateParams::Product::OrSymbol
+                ]
+              ),
+            redirect_uri: T.nilable(String),
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::Models::Connect::SessionReauthenticateResponse)
+        end
+        def reauthenticate(
+          # The ID of the existing connection to reauthenticate
+          connection_id:,
+          # The number of minutes until the session expires (defaults to 43,200, which is 30
+          # days)
+          minutes_to_expire: nil,
+          # The products to request access to (optional for reauthentication)
+          products: nil,
+          # The URI to redirect to after the Connect flow is completed
+          redirect_uri: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/finch_api/resources/connect.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class Connect
+      sig { returns(FinchAPI::Resources::Connect::Sessions) }
+      attr_reader :sessions
+
+      # @api private
+      sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Benefits
+        class Individuals
+          # Enroll an individual into a deduction or contribution. This is an overwrite
+          # operation. If the employee is already enrolled, the enrollment amounts will be
+          # adjusted. Making the same request multiple times will not create new
+          # enrollments, but will continue to set the state of the existing enrollment.
+          sig do
+            params(
+              benefit_id: String,
+              individuals:
+                T::Array[
+                  FinchAPI::HRIS::Benefits::IndividualEnrollManyParams::Individual::OrHash
+                ],
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::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
+
+          # Lists individuals currently enrolled in a given deduction.
+          sig do
+            params(
+              benefit_id: String,
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::Models::HRIS::Benefits::IndividualEnrolledIDsResponse
+            )
+          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::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::Internal::SinglePage[
+                FinchAPI::HRIS::Benefits::IndividualBenefit
+              ]
+            )
+          end
+          def retrieve_many_benefits(
+            benefit_id,
+            # comma-delimited list of stable Finch uuids for each individual. If empty,
+            # defaults to all individuals
+            individual_ids: nil,
+            request_options: {}
+          )
+          end
+
+          # Unenroll individuals from a deduction or contribution
+          sig do
+            params(
+              benefit_id: String,
+              individual_ids: T::Array[String],
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).returns(
+              FinchAPI::HRIS::Benefits::UnenrolledIndividualBenefitResponse
+            )
+          end
+          def unenroll_many(
+            benefit_id,
+            # Array of individual_ids to unenroll.
+            individual_ids: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Benefits
+        sig { returns(FinchAPI::Resources::HRIS::Benefits::Individuals) }
+        attr_reader :individuals
+
+        # Creates a new company-wide deduction or contribution. Please use the
+        # `/providers` endpoint to view available types for each provider.
+        sig do
+          params(
+            company_contribution:
+              T.nilable(
+                FinchAPI::HRIS::BenefitCreateParams::CompanyContribution::OrHash
+              ),
+            description: String,
+            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.
+          company_contribution: nil,
+          # 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).
+          description: nil,
+          # The frequency of the benefit deduction/contribution.
+          frequency: nil,
+          # Type of benefit.
+          type: nil,
+          request_options: {}
+        )
+        end
+
+        # Lists deductions and contributions information for a given item
+        sig do
+          params(
+            benefit_id: String,
+            request_options: FinchAPI::RequestOptions::OrHash
+          ).returns(FinchAPI::HRIS::CompanyBenefit)
+        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::RequestOptions::OrHash
+          ).returns(FinchAPI::HRIS::UpdateCompanyBenefitResponse)
+        end
+        def update(
+          benefit_id,
+          # Updated name or description.
+          description: nil,
+          request_options: {}
+        )
+        end
+
+        # List all company-wide deductions and contributions.
+        sig do
+          params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+            FinchAPI::Internal::SinglePage[FinchAPI::HRIS::CompanyBenefit]
+          )
+        end
+        def list(request_options: {})
+        end
+
+        # Get deductions metadata
+        sig do
+          params(request_options: FinchAPI::RequestOptions::OrHash).returns(
+            FinchAPI::Internal::SinglePage[
+              FinchAPI::Models::HRIS::BenefitListSupportedBenefitsResponse
+            ]
+          )
+        end
+        def list_supported_benefits(request_options: {})
+        end
+
+        # @api private
+        sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Company
+        class PayStatementItem
+          class Rules
+            # **Beta:** this endpoint currently serves employers onboarded after March 4th and
+            # historical support will be added soon Custom rules can be created to associate
+            # specific attributes to pay statement items depending on the use case. For
+            # example, pay statement items that meet certain conditions can be labeled as a
+            # pre-tax 401k. This metadata can be retrieved where pay statement item
+            # information is available.
+            sig do
+              params(
+                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::HRIS::Company::PayStatementItem::RuleCreateParams::EntityType::OrSymbol,
+                request_options: FinchAPI::RequestOptions::OrHash
+              ).returns(
+                FinchAPI::Models::HRIS::Company::PayStatementItem::RuleCreateResponse
+              )
+            end
+            def create(
+              # Specifies the fields to be applied when the condition is met.
+              attributes: nil,
+              conditions: nil,
+              # Specifies when the rules should stop applying rules based on the date.
+              effective_end_date: nil,
+              # Specifies when the rule should begin applying based on the date.
+              effective_start_date: nil,
+              # The entity type to which the rule is applied.
+              entity_type: nil,
+              request_options: {}
+            )
+            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::RequestOptions::OrHash
+              ).returns(
+                FinchAPI::Models::HRIS::Company::PayStatementItem::RuleUpdateResponse
+              )
+            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::RequestOptions::OrHash).returns(
+                FinchAPI::Internal::ResponsesPage[
+                  FinchAPI::Models::HRIS::Company::PayStatementItem::RuleListResponse
+                ]
+              )
+            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::RequestOptions::OrHash
+              ).returns(
+                FinchAPI::Models::HRIS::Company::PayStatementItem::RuleDeleteResponse
+              )
+            end
+            def delete(rule_id, request_options: {})
+            end
+
+            # @api private
+            sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+            def self.new(client:)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# typed: strong
+
+module FinchAPI
+  module Resources
+    class HRIS
+      class Company
+        class PayStatementItem
+          sig do
+            returns(FinchAPI::Resources::HRIS::Company::PayStatementItem::Rules)
+          end
+          attr_reader :rules
+
+          # **Beta:** this endpoint currently serves employers onboarded after March 4th and
+          # historical support will be added soon Retrieve a list of detailed pay statement
+          # items for the access token's connection account.
+          sig do
+            params(
+              categories:
+                T::Array[
+                  FinchAPI::HRIS::Company::PayStatementItemListParams::Category::OrSymbol
+                ],
+              end_date: Date,
+              name: String,
+              start_date: Date,
+              type: String,
+              request_options: FinchAPI::RequestOptions::OrHash
+            ).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,
+            # defaults to all categories.
+            categories: nil,
+            # The end date to retrieve pay statement items by via their last seen pay date in
+            # `YYYY-MM-DD` format.
+            end_date: nil,
+            # Case-insensitive partial match search by pay statement item name.
+            name: nil,
+            # The start date to retrieve pay statement items by via their last seen pay date
+            # (inclusive) in `YYYY-MM-DD` format.
+            start_date: nil,
+            # String search by pay statement item type.
+            type: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: FinchAPI::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end