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

data/rbi/lib/finch-api/models/introspection.rbi

@@ -1,327 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    class Introspection < FinchAPI::BaseModel
-      # [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::Util::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(
-          account_id: String,
-          authentication_methods: T::Array[T.any(FinchAPI::Models::Introspection::AuthenticationMethod, FinchAPI::Util::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::Util::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(
-        account_id:,
-        authentication_methods:,
-        client_id:,
-        client_type:,
-        company_id:,
-        connection_id:,
-        connection_status:,
-        connection_type:,
-        customer_email:,
-        customer_id:,
-        customer_name:,
-        manual:,
-        payroll_provider_id:,
-        products:,
-        provider_id:,
-        username:
-      )
-      end
-
-      sig do
-        override
-          .returns(
-            {
-              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::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::Util::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::Util::AnyHash),
-            products: T::Array[String],
-            type: FinchAPI::Models::Introspection::AuthenticationMethod::Type::OrSymbol
-          )
-            .returns(T.attached_class)
-        end
-        def self.new(connection_status: nil, products: nil, 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::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::Enum
-
-          TaggedSymbol =
-            T.type_alias { T.all(Symbol, FinchAPI::Models::Introspection::AuthenticationMethod::Type) }
-          OrSymbol =
-            T.type_alias { T.any(Symbol, FinchAPI::Models::Introspection::AuthenticationMethod::Type::TaggedSymbol) }
-
-          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::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Introspection::ClientType) }
-        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::Introspection::ClientType::TaggedSymbol) }
-
-        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::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(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::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Introspection::ConnectionType) }
-        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::Introspection::ConnectionType::TaggedSymbol) }
-
-        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/lib/finch-api/models/job_completion_event.rbi

@@ -1,83 +0,0 @@
-# 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::Util::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::Util::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::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(job_id:, job_url:)
-        end
-
-        sig { override.returns({job_id: String, job_url: String}) }
-        def to_hash
-        end
-      end
-
-      module EventType
-        extend FinchAPI::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::JobCompletionEvent::EventType) }
-        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::JobCompletionEvent::EventType::TaggedSymbol) }
-
-        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/lib/finch-api/models/jobs/automated_async_job.rbi

@@ -1,146 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    module Jobs
-      class AutomatedAsyncJob < FinchAPI::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::Util::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::Util::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(completed_at:, created_at:, job_id:, job_url:, params:, scheduled_at:, started_at:, status:, 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::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(individual_id: nil)
-          end
-
-          sig { override.returns({individual_id: String}) }
-          def to_hash
-          end
-        end
-
-        module Status
-          extend FinchAPI::Enum
-
-          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status) }
-          OrSymbol =
-            T.type_alias { T.any(Symbol, FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol) }
-
-          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::Enum
-
-          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::AutomatedAsyncJob::Type) }
-          OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol) }
-
-          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/lib/finch-api/models/jobs/automated_create_params.rbi

@@ -1,76 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    module Jobs
-      class AutomatedCreateParams < FinchAPI::BaseModel
-        extend FinchAPI::RequestParameters::Converter
-        include FinchAPI::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 { params(params: T.any(FinchAPI::Models::Jobs::AutomatedCreateParams::Params, FinchAPI::Util::AnyHash)).void }
-        attr_writer :params
-
-        sig do
-          params(
-            type: FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol,
-            params: T.any(FinchAPI::Models::Jobs::AutomatedCreateParams::Params, FinchAPI::Util::AnyHash),
-            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
-          )
-            .returns(T.attached_class)
-        end
-        def self.new(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::Enum
-
-          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::AutomatedCreateParams::Type) }
-          OrSymbol =
-            T.type_alias { T.any(Symbol, FinchAPI::Models::Jobs::AutomatedCreateParams::Type::TaggedSymbol) }
-
-          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::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(individual_id:)
-          end
-
-          sig { override.returns({individual_id: String}) }
-          def to_hash
-          end
-        end
-      end
-    end
-  end
-end

data/rbi/lib/finch-api/models/jobs/automated_create_response.rbi

@@ -1,44 +0,0 @@
-# typed: strong
-
-module FinchAPI
-  module Models
-    module Jobs
-      class AutomatedCreateResponse < FinchAPI::BaseModel
-        # The number of allowed refreshes per hour (per hour, fixed window)
-        sig { returns(Integer) }
-        attr_accessor :allowed_refreshes
-
-        # 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 number of remaining refreshes available (per hour, fixed window)
-        sig { returns(Integer) }
-        attr_accessor :remaining_refreshes
-
-        sig do
-          params(allowed_refreshes: Integer, job_id: String, job_url: String, remaining_refreshes: Integer)
-            .returns(T.attached_class)
-        end
-        def self.new(allowed_refreshes:, job_id:, job_url:, remaining_refreshes:)
-        end
-
-        sig do
-          override
-            .returns({
-                       allowed_refreshes: Integer,
-                       job_id: String,
-                       job_url: String,
-                       remaining_refreshes: Integer
-                     })
-        end
-        def to_hash
-        end
-      end
-    end
-  end
-end