finch-api 0.1.0.pre.alpha.1 → 0.1.0.pre.alpha.2

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

@@ -4,80 +4,52 @@ module FinchAPI
   module Models
     module Jobs
       class AutomatedAsyncJob < FinchAPI::BaseModel
+        # The datetime the job completed.
         sig { returns(T.nilable(Time)) }
-        def completed_at
-        end
-
-        sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-        def completed_at=(_)
-        end
+        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) }
-        def created_at
-        end
-
-        sig { params(_: Time).returns(Time) }
-        def created_at=(_)
-        end
+        attr_accessor :created_at
 
+        # The id of the job that has been created.
         sig { returns(String) }
-        def job_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def job_id=(_)
-        end
+        attr_accessor :job_id
 
+        # The url that can be used to retrieve the job status
         sig { returns(String) }
-        def job_url
-        end
-
-        sig { params(_: String).returns(String) }
-        def job_url=(_)
-        end
+        attr_accessor :job_url
 
+        # The input parameters for the job.
         sig { returns(T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params)) }
-        def params
-        end
+        attr_reader :params
 
         sig do
-          params(_: T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params))
-            .returns(T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params))
-        end
-        def params=(_)
+          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)) }
-        def scheduled_at
-        end
-
-        sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-        def scheduled_at=(_)
-        end
+        attr_accessor :scheduled_at
 
+        # The datetime a job entered into the job queue.
         sig { returns(T.nilable(Time)) }
-        def started_at
-        end
-
-        sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-        def started_at=(_)
-        end
-
-        sig { returns(Symbol) }
-        def status
-        end
-
-        sig { params(_: Symbol).returns(Symbol) }
-        def status=(_)
-        end
+        attr_accessor :started_at
 
-        sig { returns(Symbol) }
-        def type
-        end
+        sig { returns(FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol) }
+        attr_accessor :status
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def type=(_)
-        end
+        # The type of automated job
+        sig { returns(FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol) }
+        attr_accessor :type
 
         sig do
           params(
@@ -85,25 +57,15 @@ module FinchAPI
             created_at: Time,
             job_id: String,
             job_url: String,
-            params: T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params),
+            params: T.nilable(T.any(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params, FinchAPI::Util::AnyHash)),
             scheduled_at: T.nilable(Time),
             started_at: T.nilable(Time),
-            status: Symbol,
-            type: Symbol
+            status: FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::OrSymbol,
+            type: FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::OrSymbol
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
-          completed_at:,
-          created_at:,
-          job_id:,
-          job_url:,
-          params:,
-          scheduled_at:,
-          started_at:,
-          status:,
-          type:
-        )
+        def self.new(completed_at:, created_at:, job_id:, job_url:, params:, scheduled_at:, started_at:, status:, type:)
         end
 
         sig do
@@ -117,8 +79,8 @@ module FinchAPI
                 params: T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params),
                 scheduled_at: T.nilable(Time),
                 started_at: T.nilable(Time),
-                status: Symbol,
-                type: Symbol
+                status: FinchAPI::Models::Jobs::AutomatedAsyncJob::Status::TaggedSymbol,
+                type: FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol
               }
             )
         end
@@ -126,16 +88,16 @@ module FinchAPI
         end
 
         class Params < FinchAPI::BaseModel
+          # The ID of the individual that the job was completed for.
           sig { returns(T.nilable(String)) }
-          def individual_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def individual_id=(_)
-          end
+          attr_reader :individual_id
 
           sig { params(individual_id: String).void }
-          def initialize(individual_id: nil)
+          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}) }
@@ -143,28 +105,38 @@ module FinchAPI
           end
         end
 
-        class Status < FinchAPI::Enum
-          abstract!
+        module Status
+          extend FinchAPI::Enum
 
-          PENDING = :pending
-          IN_PROGRESS = :in_progress
-          COMPLETE = :complete
-          ERROR = :error
-          REAUTH_ERROR = :reauth_error
-          PERMISSIONS_ERROR = :permissions_error
+          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) }
 
-          sig { override.returns(T::Array[Symbol]) }
+          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
 
-        class Type < FinchAPI::Enum
-          abstract!
+        # 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 = :data_sync_all
-          W4_FORM_EMPLOYEE_SYNC = :w4_form_employee_sync
+          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[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::Jobs::AutomatedAsyncJob::Type::TaggedSymbol]) }
           def self.values
           end
         end

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

@@ -7,41 +7,32 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
-        sig { returns(Symbol) }
-        def type
-        end
-
-        sig { params(_: Symbol).returns(Symbol) }
-        def type=(_)
-        end
+        # The type of job to start.
+        sig { returns(FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol) }
+        attr_accessor :type
 
         sig { returns(FinchAPI::Models::Jobs::AutomatedCreateParams::Params) }
-        def params
-        end
+        attr_reader :params
 
-        sig do
-          params(_: FinchAPI::Models::Jobs::AutomatedCreateParams::Params)
-            .returns(FinchAPI::Models::Jobs::AutomatedCreateParams::Params)
-        end
-        def params=(_)
-        end
+        sig { params(params: T.any(FinchAPI::Models::Jobs::AutomatedCreateParams::Params, FinchAPI::Util::AnyHash)).void }
+        attr_writer :params
 
         sig do
           params(
-            type: Symbol,
-            params: FinchAPI::Models::Jobs::AutomatedCreateParams::Params,
-            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            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)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(type:, params:, request_options: {})
+        def self.new(type:, params:, request_options: {})
         end
 
         sig do
           override
             .returns(
               {
-                type: Symbol,
+                type: FinchAPI::Models::Jobs::AutomatedCreateParams::Type::OrSymbol,
                 params: FinchAPI::Models::Jobs::AutomatedCreateParams::Params,
                 request_options: FinchAPI::RequestOptions
               }
@@ -50,27 +41,29 @@ module FinchAPI
         def to_hash
         end
 
-        class Type < FinchAPI::Enum
-          abstract!
+        # 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 = :w4_form_employee_sync
+          W4_FORM_EMPLOYEE_SYNC =
+            T.let(:w4_form_employee_sync, FinchAPI::Models::Jobs::AutomatedCreateParams::Type::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          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) }
-          def individual_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def individual_id=(_)
-          end
+          attr_accessor :individual_id
 
-          sig { params(individual_id: String).void }
-          def initialize(individual_id:)
+          sig { params(individual_id: String).returns(T.attached_class) }
+          def self.new(individual_id:)
           end
 
           sig { override.returns({individual_id: String}) }

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

@@ -4,47 +4,27 @@ module FinchAPI
   module Models
     module Jobs
       class AutomatedCreateResponse < FinchAPI::BaseModel
+        # The number of allowed refreshes per hour (per hour, fixed window)
         sig { returns(Integer) }
-        def allowed_refreshes
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def allowed_refreshes=(_)
-        end
+        attr_accessor :allowed_refreshes
 
+        # The id of the job that has been created.
         sig { returns(String) }
-        def job_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def job_id=(_)
-        end
+        attr_accessor :job_id
 
+        # The url that can be used to retrieve the job status
         sig { returns(String) }
-        def job_url
-        end
-
-        sig { params(_: String).returns(String) }
-        def job_url=(_)
-        end
+        attr_accessor :job_url
 
+        # The number of remaining refreshes available (per hour, fixed window)
         sig { returns(Integer) }
-        def remaining_refreshes
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def remaining_refreshes=(_)
-        end
+        attr_accessor :remaining_refreshes
 
         sig do
-          params(
-            allowed_refreshes: Integer,
-            job_id: String,
-            job_url: String,
-            remaining_refreshes: Integer
-          ).void
+          params(allowed_refreshes: Integer, job_id: String, job_url: String, remaining_refreshes: Integer)
+            .returns(T.attached_class)
         end
-        def initialize(allowed_refreshes:, job_id:, job_url:, remaining_refreshes:)
+        def self.new(allowed_refreshes:, job_id:, job_url:, remaining_refreshes:)
         end
 
         sig do

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

@@ -7,31 +7,29 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
+        # Number of items to return
         sig { returns(T.nilable(Integer)) }
-        def limit
-        end
+        attr_reader :limit
 
-        sig { params(_: Integer).returns(Integer) }
-        def limit=(_)
-        end
+        sig { params(limit: Integer).void }
+        attr_writer :limit
 
+        # Index to start from (defaults to 0)
         sig { returns(T.nilable(Integer)) }
-        def offset
-        end
+        attr_reader :offset
 
-        sig { params(_: Integer).returns(Integer) }
-        def offset=(_)
-        end
+        sig { params(offset: Integer).void }
+        attr_writer :offset
 
         sig do
           params(
             limit: Integer,
             offset: Integer,
-            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(limit: nil, offset: nil, request_options: {})
+        def self.new(limit: nil, offset: nil, request_options: {})
         end
 
         sig { override.returns({limit: Integer, offset: Integer, request_options: FinchAPI::RequestOptions}) }

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

@@ -0,0 +1,126 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Jobs
+      class AutomatedListResponse < FinchAPI::BaseModel
+        sig { returns(T::Array[FinchAPI::Models::Jobs::AutomatedAsyncJob]) }
+        attr_accessor :data
+
+        sig { returns(FinchAPI::Models::Jobs::AutomatedListResponse::Meta) }
+        attr_reader :meta
+
+        sig { params(meta: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta, FinchAPI::Util::AnyHash)).void }
+        attr_writer :meta
+
+        sig do
+          params(
+            data: T::Array[T.any(FinchAPI::Models::Jobs::AutomatedAsyncJob, FinchAPI::Util::AnyHash)],
+            meta: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta, FinchAPI::Util::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(data:, meta:)
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                data: T::Array[FinchAPI::Models::Jobs::AutomatedAsyncJob],
+                meta: FinchAPI::Models::Jobs::AutomatedListResponse::Meta
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class Meta < FinchAPI::BaseModel
+          # Information about remaining quotas for this connection. Only applicable for
+          #   customers opted in to use Finch's Data Sync Refresh endpoint
+          #   (`POST /jobs/automated`). Please contact a Finch representative for more
+          #   details.
+          sig { returns(T.nilable(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas)) }
+          attr_reader :quotas
+
+          sig do
+            params(
+              quotas: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas, FinchAPI::Util::AnyHash)
+            )
+              .void
+          end
+          attr_writer :quotas
+
+          sig do
+            params(
+              quotas: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas, FinchAPI::Util::AnyHash)
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(quotas: nil)
+          end
+
+          sig { override.returns({quotas: FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas}) }
+          def to_hash
+          end
+
+          class Quotas < FinchAPI::BaseModel
+            sig { returns(T.nilable(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll)) }
+            attr_reader :data_sync_all
+
+            sig do
+              params(
+                data_sync_all: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll, FinchAPI::Util::AnyHash)
+              )
+                .void
+            end
+            attr_writer :data_sync_all
+
+            # Information about remaining quotas for this connection. Only applicable for
+            #   customers opted in to use Finch's Data Sync Refresh endpoint
+            #   (`POST /jobs/automated`). Please contact a Finch representative for more
+            #   details.
+            sig do
+              params(
+                data_sync_all: T.any(FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll, FinchAPI::Util::AnyHash)
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(data_sync_all: nil)
+            end
+
+            sig do
+              override.returns({data_sync_all: FinchAPI::Models::Jobs::AutomatedListResponse::Meta::Quotas::DataSyncAll})
+            end
+            def to_hash
+            end
+
+            class DataSyncAll < FinchAPI::BaseModel
+              sig { returns(T.nilable(Integer)) }
+              attr_reader :allowed_refreshes
+
+              sig { params(allowed_refreshes: Integer).void }
+              attr_writer :allowed_refreshes
+
+              sig { returns(T.nilable(Integer)) }
+              attr_reader :remaining_refreshes
+
+              sig { params(remaining_refreshes: Integer).void }
+              attr_writer :remaining_refreshes
+
+              sig do
+                params(allowed_refreshes: Integer, remaining_refreshes: Integer).returns(T.attached_class)
+              end
+              def self.new(allowed_refreshes: nil, remaining_refreshes: nil)
+              end
+
+              sig { override.returns({allowed_refreshes: Integer, remaining_refreshes: Integer}) }
+              def to_hash
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,8 +7,15 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
-        sig { params(request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])).void }
-        def initialize(request_options: {})
+        sig do
+          params(
+            request_options: T.any(
+              FinchAPI::RequestOptions,
+              FinchAPI::Util::AnyHash
+            )
+          ).returns(T.attached_class)
+        end
+        def self.new(request_options: {})
         end
 
         sig { override.returns({request_options: FinchAPI::RequestOptions}) }

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

@@ -4,47 +4,52 @@ module FinchAPI
   module Models
     module Jobs
       class ManualAsyncJob < FinchAPI::BaseModel
+        # Specific information about the job, such as individual statuses for batch jobs.
         sig { returns(T.nilable(T::Array[T.anything])) }
-        def body
-        end
-
-        sig { params(_: T.nilable(T::Array[T.anything])).returns(T.nilable(T::Array[T.anything])) }
-        def body=(_)
-        end
+        attr_accessor :body
 
         sig { returns(String) }
-        def job_id
-        end
+        attr_accessor :job_id
 
-        sig { params(_: String).returns(String) }
-        def job_id=(_)
-        end
+        sig { returns(FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol) }
+        attr_accessor :status
 
-        sig { returns(Symbol) }
-        def status
+        sig do
+          params(
+            body: T.nilable(T::Array[T.anything]),
+            job_id: String,
+            status: FinchAPI::Models::Jobs::ManualAsyncJob::Status::OrSymbol
+          )
+            .returns(T.attached_class)
         end
-
-        sig { params(_: Symbol).returns(Symbol) }
-        def status=(_)
+        def self.new(body:, job_id:, status:)
         end
 
-        sig { params(body: T.nilable(T::Array[T.anything]), job_id: String, status: Symbol).void }
-        def initialize(body:, job_id:, status:)
+        sig do
+          override
+            .returns(
+              {
+                body: T.nilable(T::Array[T.anything]),
+                job_id: String,
+                status: FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol
+              }
+            )
         end
-
-        sig { override.returns({body: T.nilable(T::Array[T.anything]), job_id: String, status: Symbol}) }
         def to_hash
         end
 
-        class Status < FinchAPI::Enum
-          abstract!
+        module Status
+          extend FinchAPI::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::Jobs::ManualAsyncJob::Status) }
+          OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol) }
 
-          PENDING = :pending
-          IN_PROGRESS = :in_progress
-          ERROR = :error
-          COMPLETE = :complete
+          PENDING = T.let(:pending, FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol)
+          IN_PROGRESS = T.let(:in_progress, FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol)
+          ERROR = T.let(:error, FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol)
+          COMPLETE = T.let(:complete, FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[FinchAPI::Models::Jobs::ManualAsyncJob::Status::TaggedSymbol]) }
           def self.values
           end
         end

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

@@ -7,8 +7,15 @@ module FinchAPI
         extend FinchAPI::RequestParameters::Converter
         include FinchAPI::RequestParameters
 
-        sig { params(request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])).void }
-        def initialize(request_options: {})
+        sig do
+          params(
+            request_options: T.any(
+              FinchAPI::RequestOptions,
+              FinchAPI::Util::AnyHash
+            )
+          ).returns(T.attached_class)
+        end
+        def self.new(request_options: {})
         end
 
         sig { override.returns({request_options: FinchAPI::RequestOptions}) }