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

data/rbi/finch_api/models/introspection.rbi

@@ -0,0 +1,362 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class Introspection < FinchAPI::Internal::Type::BaseModel
+      # The Finch UUID of the token being introspected.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # [DEPRECATED] Use `connection_id` to associate tokens with a Finch connection
+      # instead of this account ID.
+      sig { returns(String) }
+      attr_accessor :account_id
+
+      sig { returns(T::Array[FinchAPI::Models::Introspection::AuthenticationMethod]) }
+      attr_accessor :authentication_methods
+
+      # The client ID of the application associated with the `access_token`.
+      sig { returns(String) }
+      attr_accessor :client_id
+
+      # The type of application associated with a token.
+      sig { returns(FinchAPI::Models::Introspection::ClientType::TaggedSymbol) }
+      attr_accessor :client_type
+
+      # [DEPRECATED] Use `connection_id` to associate tokens with a Finch connection
+      # instead of this company ID.
+      sig { returns(String) }
+      attr_accessor :company_id
+
+      # The Finch UUID of the connection associated with the `access_token`.
+      sig { returns(String) }
+      attr_accessor :connection_id
+
+      sig { returns(FinchAPI::Models::Introspection::ConnectionStatus) }
+      attr_reader :connection_status
+
+      sig do
+        params(
+          connection_status: T.any(FinchAPI::Models::Introspection::ConnectionStatus, FinchAPI::Internal::AnyHash)
+        )
+          .void
+      end
+      attr_writer :connection_status
+
+      # The type of the connection associated with the token.
+      #
+      # - `provider` - connection to an external provider
+      # - `finch` - finch-generated data.
+      sig { returns(FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol) }
+      attr_accessor :connection_type
+
+      # The email of your customer you provided to Finch when a connect session was
+      # created for this connection.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_email
+
+      # The ID of your customer you provided to Finch when a connect session was created
+      # for this connection.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_id
+
+      # The name of your customer you provided to Finch when a connect session was
+      # created for this connection.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_name
+
+      # Whether the connection associated with the `access_token` uses the Assisted
+      # Connect Flow. (`true` if using Assisted Connect, `false` if connection is
+      # automated)
+      sig { returns(T::Boolean) }
+      attr_accessor :manual
+
+      # [DEPRECATED] Use `provider_id` to identify the provider instead of this payroll
+      # provider ID.
+      sig { returns(String) }
+      attr_accessor :payroll_provider_id
+
+      # An array of the authorized products associated with the `access_token`.
+      sig { returns(T::Array[String]) }
+      attr_accessor :products
+
+      # The ID of the provider associated with the `access_token`.
+      sig { returns(String) }
+      attr_accessor :provider_id
+
+      # The account username used for login associated with the `access_token`.
+      sig { returns(String) }
+      attr_accessor :username
+
+      sig do
+        params(
+          id: String,
+          account_id: String,
+          authentication_methods: T::Array[T.any(FinchAPI::Models::Introspection::AuthenticationMethod, FinchAPI::Internal::AnyHash)],
+          client_id: String,
+          client_type: FinchAPI::Models::Introspection::ClientType::OrSymbol,
+          company_id: String,
+          connection_id: String,
+          connection_status: T.any(FinchAPI::Models::Introspection::ConnectionStatus, FinchAPI::Internal::AnyHash),
+          connection_type: FinchAPI::Models::Introspection::ConnectionType::OrSymbol,
+          customer_email: T.nilable(String),
+          customer_id: T.nilable(String),
+          customer_name: T.nilable(String),
+          manual: T::Boolean,
+          payroll_provider_id: String,
+          products: T::Array[String],
+          provider_id: String,
+          username: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # The Finch UUID of the token being introspected.
+        id:,
+        # [DEPRECATED] Use `connection_id` to associate tokens with a Finch connection
+        # instead of this account ID.
+        account_id:,
+        authentication_methods:,
+        # The client ID of the application associated with the `access_token`.
+        client_id:,
+        # The type of application associated with a token.
+        client_type:,
+        # [DEPRECATED] Use `connection_id` to associate tokens with a Finch connection
+        # instead of this company ID.
+        company_id:,
+        # The Finch UUID of the connection associated with the `access_token`.
+        connection_id:,
+        connection_status:,
+        # The type of the connection associated with the token.
+        #
+        # - `provider` - connection to an external provider
+        # - `finch` - finch-generated data.
+        connection_type:,
+        # The email of your customer you provided to Finch when a connect session was
+        # created for this connection.
+        customer_email:,
+        # The ID of your customer you provided to Finch when a connect session was created
+        # for this connection.
+        customer_id:,
+        # The name of your customer you provided to Finch when a connect session was
+        # created for this connection.
+        customer_name:,
+        # Whether the connection associated with the `access_token` uses the Assisted
+        # Connect Flow. (`true` if using Assisted Connect, `false` if connection is
+        # automated)
+        manual:,
+        # [DEPRECATED] Use `provider_id` to identify the provider instead of this payroll
+        # provider ID.
+        payroll_provider_id:,
+        # An array of the authorized products associated with the `access_token`.
+        products:,
+        # The ID of the provider associated with the `access_token`.
+        provider_id:,
+        # The account username used for login associated with the `access_token`.
+        username:
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              id: String,
+              account_id: String,
+              authentication_methods: T::Array[FinchAPI::Models::Introspection::AuthenticationMethod],
+              client_id: String,
+              client_type: FinchAPI::Models::Introspection::ClientType::TaggedSymbol,
+              company_id: String,
+              connection_id: String,
+              connection_status: FinchAPI::Models::Introspection::ConnectionStatus,
+              connection_type: FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol,
+              customer_email: T.nilable(String),
+              customer_id: T.nilable(String),
+              customer_name: T.nilable(String),
+              manual: T::Boolean,
+              payroll_provider_id: String,
+              products: T::Array[String],
+              provider_id: String,
+              username: String
+            }
+          )
+      end
+      def to_hash; end
+
+      class AuthenticationMethod < FinchAPI::Internal::Type::BaseModel
+        sig { returns(T.nilable(FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus)) }
+        attr_reader :connection_status
+
+        sig do
+          params(
+            connection_status: T.any(
+              FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus,
+              FinchAPI::Internal::AnyHash
+            )
+          )
+            .void
+        end
+        attr_writer :connection_status
+
+        # An array of the authorized products associated with the `access_token`.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :products
+
+        sig { params(products: T::Array[String]).void }
+        attr_writer :products
+
+        # The type of authentication method.
+        sig { returns(T.nilable(FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)) }
+        attr_reader :type
+
+        sig { params(type: FinchAPI::Models::Introspection::AuthenticationMethod::Type::OrSymbol).void }
+        attr_writer :type
+
+        sig do
+          params(
+            connection_status: T.any(
+              FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus,
+              FinchAPI::Internal::AnyHash
+            ),
+            products: T::Array[String],
+            type: FinchAPI::Models::Introspection::AuthenticationMethod::Type::OrSymbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          connection_status: nil,
+          # An array of the authorized products associated with the `access_token`.
+          products: nil,
+          # The type of authentication method.
+          type: nil
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                connection_status: FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus,
+                products: T::Array[String],
+                type: FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol
+              }
+            )
+        end
+        def to_hash; end
+
+        class ConnectionStatus < FinchAPI::Internal::Type::BaseModel
+          sig { returns(T.nilable(String)) }
+          attr_reader :message
+
+          sig { params(message: String).void }
+          attr_writer :message
+
+          sig { returns(T.nilable(FinchAPI::Models::ConnectionStatusType::TaggedSymbol)) }
+          attr_reader :status
+
+          sig { params(status: FinchAPI::Models::ConnectionStatusType::OrSymbol).void }
+          attr_writer :status
+
+          sig do
+            params(message: String, status: FinchAPI::Models::ConnectionStatusType::OrSymbol).returns(T.attached_class)
+          end
+          def self.new(message: nil, status: nil); end
+
+          sig { override.returns({message: String, status: FinchAPI::Models::ConnectionStatusType::TaggedSymbol}) }
+          def to_hash; end
+        end
+
+        # The type of authentication method.
+        module Type
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, FinchAPI::Models::Introspection::AuthenticationMethod::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ASSISTED = T.let(:assisted, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+          CREDENTIAL =
+            T.let(:credential, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+          API_TOKEN = T.let(:api_token, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+          API_CREDENTIAL =
+            T.let(:api_credential, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+          OAUTH = T.let(:oauth, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol]) }
+          def self.values; end
+        end
+      end
+
+      # The type of application associated with a token.
+      module ClientType
+        extend FinchAPI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Introspection::ClientType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PRODUCTION = T.let(:production, FinchAPI::Models::Introspection::ClientType::TaggedSymbol)
+        DEVELOPMENT = T.let(:development, FinchAPI::Models::Introspection::ClientType::TaggedSymbol)
+        SANDBOX = T.let(:sandbox, FinchAPI::Models::Introspection::ClientType::TaggedSymbol)
+
+        sig { override.returns(T::Array[FinchAPI::Models::Introspection::ClientType::TaggedSymbol]) }
+        def self.values; end
+      end
+
+      class ConnectionStatus < FinchAPI::Internal::Type::BaseModel
+        # The datetime when the connection was last successfully synced.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :last_successful_sync
+
+        sig { params(last_successful_sync: Time).void }
+        attr_writer :last_successful_sync
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :message
+
+        sig { params(message: String).void }
+        attr_writer :message
+
+        sig { returns(T.nilable(FinchAPI::Models::ConnectionStatusType::TaggedSymbol)) }
+        attr_reader :status
+
+        sig { params(status: FinchAPI::Models::ConnectionStatusType::OrSymbol).void }
+        attr_writer :status
+
+        sig do
+          params(
+            last_successful_sync: Time,
+            message: String,
+            status: FinchAPI::Models::ConnectionStatusType::OrSymbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # The datetime when the connection was last successfully synced.
+          last_successful_sync: nil,
+          message: nil,
+          status: nil
+        ); end
+        sig do
+          override
+            .returns(
+              {last_successful_sync: Time, message: String, status: FinchAPI::Models::ConnectionStatusType::TaggedSymbol}
+            )
+        end
+        def to_hash; end
+      end
+
+      # The type of the connection associated with the token.
+      #
+      # - `provider` - connection to an external provider
+      # - `finch` - finch-generated data.
+      module ConnectionType
+        extend FinchAPI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Introspection::ConnectionType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PROVIDER = T.let(:provider, FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol)
+        FINCH = T.let(:finch, FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol)
+
+        sig { override.returns(T::Array[FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/job_completion_event.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class JobCompletionEvent < FinchAPI::Models::BaseWebhookEvent
+      sig { returns(T.nilable(FinchAPI::Models::JobCompletionEvent::Data)) }
+      attr_reader :data
+
+      sig { params(data: T.any(FinchAPI::Models::JobCompletionEvent::Data, FinchAPI::Internal::AnyHash)).void }
+      attr_writer :data
+
+      sig { returns(T.nilable(FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
+
+      sig { params(event_type: FinchAPI::Models::JobCompletionEvent::EventType::OrSymbol).void }
+      attr_writer :event_type
+
+      sig do
+        params(
+          data: T.any(FinchAPI::Models::JobCompletionEvent::Data, FinchAPI::Internal::AnyHash),
+          event_type: FinchAPI::Models::JobCompletionEvent::EventType::OrSymbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(data: nil, event_type: nil); end
+
+      sig do
+        override
+          .returns(
+            {
+              data: FinchAPI::Models::JobCompletionEvent::Data,
+              event_type: FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol
+            }
+          )
+      end
+      def to_hash; end
+
+      class Data < FinchAPI::Internal::Type::BaseModel
+        # The id of the job which has completed.
+        sig { returns(String) }
+        attr_accessor :job_id
+
+        # The url to query the result of the job.
+        sig { returns(String) }
+        attr_accessor :job_url
+
+        sig { params(job_id: String, job_url: String).returns(T.attached_class) }
+        def self.new(
+          # The id of the job which has completed.
+          job_id:,
+          # The url to query the result of the job.
+          job_url:
+        ); end
+        sig { override.returns({job_id: String, job_url: String}) }
+        def to_hash; end
+      end
+
+      module EventType
+        extend FinchAPI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::JobCompletionEvent::EventType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        JOB_BENEFIT_CREATE_COMPLETED =
+          T.let(:"job.benefit_create.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_BENEFIT_ENROLL_COMPLETED =
+          T.let(:"job.benefit_enroll.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_BENEFIT_REGISTER_COMPLETED =
+          T.let(:"job.benefit_register.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_BENEFIT_UNENROLL_COMPLETED =
+          T.let(:"job.benefit_unenroll.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_BENEFIT_UPDATE_COMPLETED =
+          T.let(:"job.benefit_update.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+        JOB_DATA_SYNC_ALL_COMPLETED =
+          T.let(:"job.data_sync_all.completed", FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol)
+
+        sig { override.returns(T::Array[FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/jobs/automated_async_job.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Jobs
+      class AutomatedAsyncJob < FinchAPI::Internal::Type::BaseModel
+        # The datetime the job completed.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :completed_at
+
+        # The datetime when the job was created. for scheduled jobs, this will be the
+        # initial connection time. For ad-hoc jobs, this will be the time the creation
+        # request was received.
+        sig { returns(Time) }
+        attr_accessor :created_at
+
+        # The id of the job that has been created.
+        sig { returns(String) }
+        attr_accessor :job_id
+
+        # The url that can be used to retrieve the job status
+        sig { returns(String) }
+        attr_accessor :job_url
+
+        # The input parameters for the job.
+        sig { returns(T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params)) }
+        attr_reader :params
+
+        sig do
+          params(
+            params: T.nilable(T.any(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params, FinchAPI::Internal::AnyHash))
+          )
+            .void
+        end
+        attr_writer :params
+
+        # The datetime a job is scheduled to be run. For scheduled jobs, this datetime can
+        # be in the future if the job has not yet been enqueued. For ad-hoc jobs, this
+        # field will be null.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :scheduled_at
+
+        # The datetime a job entered into the job queue.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :started_at
+
+        sig { returns(FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol) }
+        attr_accessor :status
+
+        # The type of automated job
+        sig { returns(FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            completed_at: T.nilable(Time),
+            created_at: Time,
+            job_id: String,
+            job_url: String,
+            params: T.nilable(T.any(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params, FinchAPI::Internal::AnyHash)),
+            scheduled_at: T.nilable(Time),
+            started_at: T.nilable(Time),
+            status: FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::OrSymbol,
+            type: FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::OrSymbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # The datetime the job completed.
+          completed_at:,
+          # The datetime when the job was created. for scheduled jobs, this will be the
+          # initial connection time. For ad-hoc jobs, this will be the time the creation
+          # request was received.
+          created_at:,
+          # The id of the job that has been created.
+          job_id:,
+          # The url that can be used to retrieve the job status
+          job_url:,
+          # The input parameters for the job.
+          params:,
+          # The datetime a job is scheduled to be run. For scheduled jobs, this datetime can
+          # be in the future if the job has not yet been enqueued. For ad-hoc jobs, this
+          # field will be null.
+          scheduled_at:,
+          # The datetime a job entered into the job queue.
+          started_at:,
+          status:,
+          # The type of automated job
+          type:
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                completed_at: T.nilable(Time),
+                created_at: Time,
+                job_id: String,
+                job_url: String,
+                params: T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params),
+                scheduled_at: T.nilable(Time),
+                started_at: T.nilable(Time),
+                status: FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol,
+                type: FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol
+              }
+            )
+        end
+        def to_hash; end
+
+        class Params < FinchAPI::Internal::Type::BaseModel
+          # The ID of the individual that the job was completed for.
+          sig { returns(T.nilable(String)) }
+          attr_reader :individual_id
+
+          sig { params(individual_id: String).void }
+          attr_writer :individual_id
+
+          # The input parameters for the job.
+          sig { params(individual_id: String).returns(T.attached_class) }
+          def self.new(
+            # The ID of the individual that the job was completed for.
+            individual_id: nil
+          ); end
+          sig { override.returns({individual_id: String}) }
+          def to_hash; end
+        end
+
+        module Status
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PENDING = T.let(:pending, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
+          IN_PROGRESS = T.let(:in_progress, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
+          COMPLETE = T.let(:complete, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
+          ERROR = T.let(:error, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
+          REAUTH_ERROR = T.let(:reauth_error, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
+          PERMISSIONS_ERROR =
+            T.let(:permissions_error, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol]) }
+          def self.values; end
+        end
+
+        # The type of automated job
+        module Type
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::AutomatedAsyncJob::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DATA_SYNC_ALL = T.let(:data_sync_all, FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol)
+          W4_FORM_EMPLOYEE_SYNC =
+            T.let(:w4_form_employee_sync, FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol]) }
+          def self.values; end
+        end
+      end
+    end
+  end
+end

data/rbi/finch_api/models/jobs/automated_create_params.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Jobs
+      class AutomatedCreateParams < FinchAPI::Internal::Type::BaseModel
+        extend FinchAPI::Internal::Type::RequestParameters::Converter
+        include FinchAPI::Internal::Type::RequestParameters
+
+        # The type of job to start.
+        sig { returns(FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol) }
+        attr_accessor :type
+
+        sig { returns(FinchAPI::Models::Jobs::AutomatedCreateParams::Params) }
+        attr_reader :params
+
+        sig do
+          params(params: T.any(FinchAPI::Models::Jobs::AutomatedCreateParams::Params, FinchAPI::Internal::AnyHash))
+            .void
+        end
+        attr_writer :params
+
+        sig do
+          params(
+            type: FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol,
+            params: T.any(FinchAPI::Models::Jobs::AutomatedCreateParams::Params, FinchAPI::Internal::AnyHash),
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # The type of job to start.
+          type:,
+          params:,
+          request_options: {}
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                type: FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol,
+                params: FinchAPI::Models::Jobs::AutomatedCreateParams::Params,
+                request_options: FinchAPI::RequestOptions
+              }
+            )
+        end
+        def to_hash; end
+
+        # The type of job to start.
+        module Type
+          extend FinchAPI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::AutomatedCreateParams::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          W4_FORM_EMPLOYEE_SYNC =
+            T.let(:w4_form_employee_sync, FinchAPI::Models::Jobs::AutomatedCreateParams::Type::TaggedSymbol)
+
+          sig { override.returns(T::Array[FinchAPI::Models::Jobs::AutomatedCreateParams::Type::TaggedSymbol]) }
+          def self.values; end
+        end
+
+        class Params < FinchAPI::Internal::Type::BaseModel
+          # The unique ID of the individual for W-4 data sync.
+          sig { returns(String) }
+          attr_accessor :individual_id
+
+          sig { params(individual_id: String).returns(T.attached_class) }
+          def self.new(
+            # The unique ID of the individual for W-4 data sync.
+            individual_id:
+          ); end
+          sig { override.returns({individual_id: String}) }
+          def to_hash; end
+        end
+      end
+    end
+  end
+end