finch-api 0.1.0.pre.alpha.1

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

@@ -0,0 +1,350 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class Introspection < FinchAPI::BaseModel
+      sig { returns(String) }
+      def account_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def account_id=(_)
+      end
+
+      sig { returns(T::Array[FinchAPI::Models::Introspection::AuthenticationMethod]) }
+      def authentication_methods
+      end
+
+      sig do
+        params(_: T::Array[FinchAPI::Models::Introspection::AuthenticationMethod])
+          .returns(T::Array[FinchAPI::Models::Introspection::AuthenticationMethod])
+      end
+      def authentication_methods=(_)
+      end
+
+      sig { returns(String) }
+      def client_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def client_id=(_)
+      end
+
+      sig { returns(Symbol) }
+      def client_type
+      end
+
+      sig { params(_: Symbol).returns(Symbol) }
+      def client_type=(_)
+      end
+
+      sig { returns(String) }
+      def company_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def company_id=(_)
+      end
+
+      sig { returns(String) }
+      def connection_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def connection_id=(_)
+      end
+
+      sig { returns(FinchAPI::Models::Introspection::ConnectionStatus) }
+      def connection_status
+      end
+
+      sig do
+        params(_: FinchAPI::Models::Introspection::ConnectionStatus)
+          .returns(FinchAPI::Models::Introspection::ConnectionStatus)
+      end
+      def connection_status=(_)
+      end
+
+      sig { returns(Symbol) }
+      def connection_type
+      end
+
+      sig { params(_: Symbol).returns(Symbol) }
+      def connection_type=(_)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def customer_email
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def customer_email=(_)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def customer_id
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def customer_id=(_)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def customer_name
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def customer_name=(_)
+      end
+
+      sig { returns(T::Boolean) }
+      def manual
+      end
+
+      sig { params(_: T::Boolean).returns(T::Boolean) }
+      def manual=(_)
+      end
+
+      sig { returns(String) }
+      def payroll_provider_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def payroll_provider_id=(_)
+      end
+
+      sig { returns(T::Array[String]) }
+      def products
+      end
+
+      sig { params(_: T::Array[String]).returns(T::Array[String]) }
+      def products=(_)
+      end
+
+      sig { returns(String) }
+      def provider_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def provider_id=(_)
+      end
+
+      sig { returns(String) }
+      def username
+      end
+
+      sig { params(_: String).returns(String) }
+      def username=(_)
+      end
+
+      sig do
+        params(
+          account_id: String,
+          authentication_methods: T::Array[FinchAPI::Models::Introspection::AuthenticationMethod],
+          client_id: String,
+          client_type: Symbol,
+          company_id: String,
+          connection_id: String,
+          connection_status: FinchAPI::Models::Introspection::ConnectionStatus,
+          connection_type: Symbol,
+          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
+        )
+          .void
+      end
+      def initialize(
+        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: Symbol,
+              company_id: String,
+              connection_id: String,
+              connection_status: FinchAPI::Models::Introspection::ConnectionStatus,
+              connection_type: Symbol,
+              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)) }
+        def connection_status
+        end
+
+        sig do
+          params(_: FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus)
+            .returns(FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus)
+        end
+        def connection_status=(_)
+        end
+
+        sig { returns(T.nilable(T::Array[String])) }
+        def products
+        end
+
+        sig { params(_: T::Array[String]).returns(T::Array[String]) }
+        def products=(_)
+        end
+
+        sig { returns(T.nilable(Symbol)) }
+        def type
+        end
+
+        sig { params(_: Symbol).returns(Symbol) }
+        def type=(_)
+        end
+
+        sig do
+          params(
+            connection_status: FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus,
+            products: T::Array[String],
+            type: Symbol
+          )
+            .void
+        end
+        def initialize(connection_status: nil, products: nil, type: nil)
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                connection_status: FinchAPI::Models::Introspection::AuthenticationMethod::ConnectionStatus,
+                products: T::Array[String],
+                type: Symbol
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class ConnectionStatus < FinchAPI::BaseModel
+          sig { returns(T.nilable(String)) }
+          def message
+          end
+
+          sig { params(_: String).returns(String) }
+          def message=(_)
+          end
+
+          sig { returns(T.nilable(Symbol)) }
+          def status
+          end
+
+          sig { params(_: Symbol).returns(Symbol) }
+          def status=(_)
+          end
+
+          sig { params(message: String, status: Symbol).void }
+          def initialize(message: nil, status: nil)
+          end
+
+          sig { override.returns({message: String, status: Symbol}) }
+          def to_hash
+          end
+        end
+
+        class Type < FinchAPI::Enum
+          abstract!
+
+          ASSISTED = :assisted
+          CREDENTIAL = :credential
+          API_TOKEN = :api_token
+          API_CREDENTIAL = :api_credential
+          OAUTH = :oauth
+
+          sig { override.returns(T::Array[Symbol]) }
+          def self.values
+          end
+        end
+      end
+
+      class ClientType < FinchAPI::Enum
+        abstract!
+
+        PRODUCTION = :production
+        DEVELOPMENT = :development
+        SANDBOX = :sandbox
+
+        sig { override.returns(T::Array[Symbol]) }
+        def self.values
+        end
+      end
+
+      class ConnectionStatus < FinchAPI::BaseModel
+        sig { returns(T.nilable(String)) }
+        def message
+        end
+
+        sig { params(_: String).returns(String) }
+        def message=(_)
+        end
+
+        sig { returns(T.nilable(Symbol)) }
+        def status
+        end
+
+        sig { params(_: Symbol).returns(Symbol) }
+        def status=(_)
+        end
+
+        sig { params(message: String, status: Symbol).void }
+        def initialize(message: nil, status: nil)
+        end
+
+        sig { override.returns({message: String, status: Symbol}) }
+        def to_hash
+        end
+      end
+
+      class ConnectionType < FinchAPI::Enum
+        abstract!
+
+        PROVIDER = :provider
+        FINCH = :finch
+
+        sig { override.returns(T::Array[Symbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class JobCompletionEvent < FinchAPI::Models::BaseWebhookEvent
+      sig { returns(T.nilable(FinchAPI::Models::JobCompletionEvent::Data)) }
+      def data
+      end
+
+      sig { params(_: FinchAPI::Models::JobCompletionEvent::Data).returns(FinchAPI::Models::JobCompletionEvent::Data) }
+      def data=(_)
+      end
+
+      sig { returns(T.nilable(Symbol)) }
+      def event_type
+      end
+
+      sig { params(_: Symbol).returns(Symbol) }
+      def event_type=(_)
+      end
+
+      sig { params(data: FinchAPI::Models::JobCompletionEvent::Data, event_type: Symbol).void }
+      def initialize(data: nil, event_type: nil)
+      end
+
+      sig { override.returns({data: FinchAPI::Models::JobCompletionEvent::Data, event_type: Symbol}) }
+      def to_hash
+      end
+
+      class Data < FinchAPI::BaseModel
+        sig { returns(String) }
+        def job_id
+        end
+
+        sig { params(_: String).returns(String) }
+        def job_id=(_)
+        end
+
+        sig { returns(String) }
+        def job_url
+        end
+
+        sig { params(_: String).returns(String) }
+        def job_url=(_)
+        end
+
+        sig { params(job_id: String, job_url: String).void }
+        def initialize(job_id:, job_url:)
+        end
+
+        sig { override.returns({job_id: String, job_url: String}) }
+        def to_hash
+        end
+      end
+
+      class EventType < FinchAPI::Enum
+        abstract!
+
+        JOB_BENEFIT_CREATE_COMPLETED = :"job.benefit_create.completed"
+        JOB_BENEFIT_ENROLL_COMPLETED = :"job.benefit_enroll.completed"
+        JOB_BENEFIT_REGISTER_COMPLETED = :"job.benefit_register.completed"
+        JOB_BENEFIT_UNENROLL_COMPLETED = :"job.benefit_unenroll.completed"
+        JOB_BENEFIT_UPDATE_COMPLETED = :"job.benefit_update.completed"
+        JOB_DATA_SYNC_ALL_COMPLETED = :"job.data_sync_all.completed"
+
+        sig { override.returns(T::Array[Symbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Jobs
+      class AutomatedAsyncJob < FinchAPI::BaseModel
+        sig { returns(T.nilable(Time)) }
+        def completed_at
+        end
+
+        sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
+        def completed_at=(_)
+        end
+
+        sig { returns(Time) }
+        def created_at
+        end
+
+        sig { params(_: Time).returns(Time) }
+        def created_at=(_)
+        end
+
+        sig { returns(String) }
+        def job_id
+        end
+
+        sig { params(_: String).returns(String) }
+        def job_id=(_)
+        end
+
+        sig { returns(String) }
+        def job_url
+        end
+
+        sig { params(_: String).returns(String) }
+        def job_url=(_)
+        end
+
+        sig { returns(T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params)) }
+        def params
+        end
+
+        sig do
+          params(_: T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params))
+            .returns(T.nilable(FinchAPI::Models::Jobs::AutomatedAsyncJob::Params))
+        end
+        def params=(_)
+        end
+
+        sig { returns(T.nilable(Time)) }
+        def scheduled_at
+        end
+
+        sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
+        def scheduled_at=(_)
+        end
+
+        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
+
+        sig { returns(Symbol) }
+        def type
+        end
+
+        sig { params(_: Symbol).returns(Symbol) }
+        def type=(_)
+        end
+
+        sig do
+          params(
+            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: Symbol,
+            type: Symbol
+          )
+            .void
+        end
+        def initialize(
+          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: Symbol,
+                type: Symbol
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class Params < FinchAPI::BaseModel
+          sig { returns(T.nilable(String)) }
+          def individual_id
+          end
+
+          sig { params(_: String).returns(String) }
+          def individual_id=(_)
+          end
+
+          sig { params(individual_id: String).void }
+          def initialize(individual_id: nil)
+          end
+
+          sig { override.returns({individual_id: String}) }
+          def to_hash
+          end
+        end
+
+        class Status < FinchAPI::Enum
+          abstract!
+
+          PENDING = :pending
+          IN_PROGRESS = :in_progress
+          COMPLETE = :complete
+          ERROR = :error
+          REAUTH_ERROR = :reauth_error
+          PERMISSIONS_ERROR = :permissions_error
+
+          sig { override.returns(T::Array[Symbol]) }
+          def self.values
+          end
+        end
+
+        class Type < FinchAPI::Enum
+          abstract!
+
+          DATA_SYNC_ALL = :data_sync_all
+          W4_FORM_EMPLOYEE_SYNC = :w4_form_employee_sync
+
+          sig { override.returns(T::Array[Symbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Jobs
+      class AutomatedCreateParams < FinchAPI::BaseModel
+        extend FinchAPI::RequestParameters::Converter
+        include FinchAPI::RequestParameters
+
+        sig { returns(Symbol) }
+        def type
+        end
+
+        sig { params(_: Symbol).returns(Symbol) }
+        def type=(_)
+        end
+
+        sig { returns(FinchAPI::Models::Jobs::AutomatedCreateParams::Params) }
+        def params
+        end
+
+        sig do
+          params(_: FinchAPI::Models::Jobs::AutomatedCreateParams::Params)
+            .returns(FinchAPI::Models::Jobs::AutomatedCreateParams::Params)
+        end
+        def params=(_)
+        end
+
+        sig do
+          params(
+            type: Symbol,
+            params: FinchAPI::Models::Jobs::AutomatedCreateParams::Params,
+            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+          )
+            .void
+        end
+        def initialize(type:, params:, request_options: {})
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                type: Symbol,
+                params: FinchAPI::Models::Jobs::AutomatedCreateParams::Params,
+                request_options: FinchAPI::RequestOptions
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class Type < FinchAPI::Enum
+          abstract!
+
+          W4_FORM_EMPLOYEE_SYNC = :w4_form_employee_sync
+
+          sig { override.returns(T::Array[Symbol]) }
+          def self.values
+          end
+        end
+
+        class Params < FinchAPI::BaseModel
+          sig { returns(String) }
+          def individual_id
+          end
+
+          sig { params(_: String).returns(String) }
+          def individual_id=(_)
+          end
+
+          sig { params(individual_id: String).void }
+          def initialize(individual_id:)
+          end
+
+          sig { override.returns({individual_id: String}) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end