finch-api 0.1.0.pre.alpha.1

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

@@ -0,0 +1,39 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class BaseWebhookEvent < FinchAPI::BaseModel
+      sig { returns(String) }
+      def account_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def account_id=(_)
+      end
+
+      sig { returns(String) }
+      def company_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def company_id=(_)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def connection_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def connection_id=(_)
+      end
+
+      sig { params(account_id: String, company_id: String, connection_id: String).void }
+      def initialize(account_id:, company_id:, connection_id: nil)
+      end
+
+      sig { override.returns({account_id: String, company_id: String, connection_id: String}) }
+      def to_hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class CompanyEvent < FinchAPI::Models::BaseWebhookEvent
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      def data
+      end
+
+      sig do
+        params(_: T.nilable(T::Hash[Symbol, T.anything])).returns(T.nilable(T::Hash[Symbol, T.anything]))
+      end
+      def data=(_)
+      end
+
+      sig { returns(T.nilable(Symbol)) }
+      def event_type
+      end
+
+      sig { params(_: Symbol).returns(Symbol) }
+      def event_type=(_)
+      end
+
+      sig { params(data: T.nilable(T::Hash[Symbol, T.anything]), event_type: Symbol).void }
+      def initialize(data: nil, event_type: nil)
+      end
+
+      sig { override.returns({data: T.nilable(T::Hash[Symbol, T.anything]), event_type: Symbol}) }
+      def to_hash
+      end
+
+      class EventType < FinchAPI::Enum
+        abstract!
+
+        COMPANY_UPDATED = :"company.updated"
+
+        sig { override.returns(T::Array[Symbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/connect/session_new_params.rbi

@@ -0,0 +1,203 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Connect
+      class SessionNewParams < FinchAPI::BaseModel
+        extend FinchAPI::RequestParameters::Converter
+        include FinchAPI::RequestParameters
+
+        sig { returns(String) }
+        def customer_id
+        end
+
+        sig { params(_: String).returns(String) }
+        def customer_id=(_)
+        end
+
+        sig { returns(String) }
+        def customer_name
+        end
+
+        sig { params(_: String).returns(String) }
+        def customer_name=(_)
+        end
+
+        sig { returns(T::Array[Symbol]) }
+        def products
+        end
+
+        sig { params(_: T::Array[Symbol]).returns(T::Array[Symbol]) }
+        def products=(_)
+        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(FinchAPI::Models::Connect::SessionNewParams::Integration)) }
+        def integration
+        end
+
+        sig do
+          params(_: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration))
+            .returns(T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration))
+        end
+        def integration=(_)
+        end
+
+        sig { returns(T.nilable(T::Boolean)) }
+        def manual
+        end
+
+        sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+        def manual=(_)
+        end
+
+        sig { returns(T.nilable(Float)) }
+        def minutes_to_expire
+        end
+
+        sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
+        def minutes_to_expire=(_)
+        end
+
+        sig { returns(T.nilable(String)) }
+        def redirect_uri
+        end
+
+        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+        def redirect_uri=(_)
+        end
+
+        sig { returns(T.nilable(Symbol)) }
+        def sandbox
+        end
+
+        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
+        def sandbox=(_)
+        end
+
+        sig do
+          params(
+            customer_id: String,
+            customer_name: String,
+            products: T::Array[Symbol],
+            customer_email: T.nilable(String),
+            integration: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration),
+            manual: T.nilable(T::Boolean),
+            minutes_to_expire: T.nilable(Float),
+            redirect_uri: T.nilable(String),
+            sandbox: T.nilable(Symbol),
+            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+          )
+            .void
+        end
+        def initialize(
+          customer_id:,
+          customer_name:,
+          products:,
+          customer_email: nil,
+          integration: nil,
+          manual: nil,
+          minutes_to_expire: nil,
+          redirect_uri: nil,
+          sandbox: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                customer_id: String,
+                customer_name: String,
+                products: T::Array[Symbol],
+                customer_email: T.nilable(String),
+                integration: T.nilable(FinchAPI::Models::Connect::SessionNewParams::Integration),
+                manual: T.nilable(T::Boolean),
+                minutes_to_expire: T.nilable(Float),
+                redirect_uri: T.nilable(String),
+                sandbox: T.nilable(Symbol),
+                request_options: FinchAPI::RequestOptions
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class Product < FinchAPI::Enum
+          abstract!
+
+          COMPANY = :company
+          DIRECTORY = :directory
+          INDIVIDUAL = :individual
+          EMPLOYMENT = :employment
+          PAYMENT = :payment
+          PAY_STATEMENT = :pay_statement
+          BENEFITS = :benefits
+          SSN = :ssn
+
+          sig { override.returns(T::Array[Symbol]) }
+          def self.values
+          end
+        end
+
+        class Integration < FinchAPI::BaseModel
+          sig { returns(T.nilable(Symbol)) }
+          def auth_method
+          end
+
+          sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
+          def auth_method=(_)
+          end
+
+          sig { returns(T.nilable(String)) }
+          def provider
+          end
+
+          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+          def provider=(_)
+          end
+
+          sig { params(auth_method: T.nilable(Symbol), provider: T.nilable(String)).void }
+          def initialize(auth_method: nil, provider: nil)
+          end
+
+          sig { override.returns({auth_method: T.nilable(Symbol), provider: T.nilable(String)}) }
+          def to_hash
+          end
+
+          class AuthMethod < FinchAPI::Enum
+            abstract!
+
+            ASSISTED = T.let(:assisted, T.nilable(Symbol))
+            CREDENTIAL = T.let(:credential, T.nilable(Symbol))
+            OAUTH = T.let(:oauth, T.nilable(Symbol))
+            API_TOKEN = T.let(:api_token, T.nilable(Symbol))
+
+            sig { override.returns(T::Array[Symbol]) }
+            def self.values
+            end
+          end
+        end
+
+        class Sandbox < FinchAPI::Enum
+          abstract!
+
+          FINCH = T.let(:finch, T.nilable(Symbol))
+          PROVIDER = T.let(:provider, T.nilable(Symbol))
+
+          sig { override.returns(T::Array[Symbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/connect/session_new_response.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Connect
+      class SessionNewResponse < FinchAPI::BaseModel
+        sig { returns(String) }
+        def connect_url
+        end
+
+        sig { params(_: String).returns(String) }
+        def connect_url=(_)
+        end
+
+        sig { returns(String) }
+        def session_id
+        end
+
+        sig { params(_: String).returns(String) }
+        def session_id=(_)
+        end
+
+        sig { params(connect_url: String, session_id: String).void }
+        def initialize(connect_url:, session_id:)
+        end
+
+        sig { override.returns({connect_url: String, session_id: String}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/connect/session_reauthenticate_params.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Connect
+      class SessionReauthenticateParams < FinchAPI::BaseModel
+        extend FinchAPI::RequestParameters::Converter
+        include FinchAPI::RequestParameters
+
+        sig { returns(String) }
+        def connection_id
+        end
+
+        sig { params(_: String).returns(String) }
+        def connection_id=(_)
+        end
+
+        sig { returns(T.nilable(Integer)) }
+        def minutes_to_expire
+        end
+
+        sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+        def minutes_to_expire=(_)
+        end
+
+        sig { returns(T.nilable(T::Array[Symbol])) }
+        def products
+        end
+
+        sig { params(_: T.nilable(T::Array[Symbol])).returns(T.nilable(T::Array[Symbol])) }
+        def products=(_)
+        end
+
+        sig { returns(T.nilable(String)) }
+        def redirect_uri
+        end
+
+        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+        def redirect_uri=(_)
+        end
+
+        sig do
+          params(
+            connection_id: String,
+            minutes_to_expire: T.nilable(Integer),
+            products: T.nilable(T::Array[Symbol]),
+            redirect_uri: T.nilable(String),
+            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+          )
+            .void
+        end
+        def initialize(
+          connection_id:,
+          minutes_to_expire: nil,
+          products: nil,
+          redirect_uri: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                connection_id: String,
+                minutes_to_expire: T.nilable(Integer),
+                products: T.nilable(T::Array[Symbol]),
+                redirect_uri: T.nilable(String),
+                request_options: FinchAPI::RequestOptions
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class Product < FinchAPI::Enum
+          abstract!
+
+          COMPANY = :company
+          DIRECTORY = :directory
+          INDIVIDUAL = :individual
+          EMPLOYMENT = :employment
+          PAYMENT = :payment
+          PAY_STATEMENT = :pay_statement
+          BENEFITS = :benefits
+          SSN = :ssn
+
+          sig { override.returns(T::Array[Symbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/finch-api/models/connect/session_reauthenticate_response.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    module Connect
+      class SessionReauthenticateResponse < FinchAPI::BaseModel
+        sig { returns(String) }
+        def connect_url
+        end
+
+        sig { params(_: String).returns(String) }
+        def connect_url=(_)
+        end
+
+        sig { returns(String) }
+        def session_id
+        end
+
+        sig { params(_: String).returns(String) }
+        def session_id=(_)
+        end
+
+        sig { params(connect_url: String, session_id: String).void }
+        def initialize(connect_url:, session_id:)
+        end
+
+        sig { override.returns({connect_url: String, session_id: String}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class ConnectionStatusType < FinchAPI::Enum
+      abstract!
+
+      PENDING = :pending
+      PROCESSING = :processing
+      CONNECTED = :connected
+      ERROR_NO_ACCOUNT_SETUP = :error_no_account_setup
+      ERROR_PERMISSIONS = :error_permissions
+      REAUTH = :reauth
+
+      sig { override.returns(T::Array[Symbol]) }
+      def self.values
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class CreateAccessTokenResponse < FinchAPI::BaseModel
+      sig { returns(String) }
+      def access_token
+      end
+
+      sig { params(_: String).returns(String) }
+      def access_token=(_)
+      end
+
+      sig { returns(String) }
+      def account_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def account_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(Symbol) }
+      def connection_type
+      end
+
+      sig { params(_: Symbol).returns(Symbol) }
+      def connection_type=(_)
+      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(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 token_type
+      end
+
+      sig { params(_: String).returns(String) }
+      def token_type=(_)
+      end
+
+      sig do
+        params(
+          access_token: String,
+          account_id: String,
+          client_type: Symbol,
+          company_id: String,
+          connection_id: String,
+          connection_type: Symbol,
+          products: T::Array[String],
+          provider_id: String,
+          customer_id: T.nilable(String),
+          token_type: String
+        )
+          .void
+      end
+      def initialize(
+        access_token:,
+        account_id:,
+        client_type:,
+        company_id:,
+        connection_id:,
+        connection_type:,
+        products:,
+        provider_id:,
+        customer_id: nil,
+        token_type: nil
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              access_token: String,
+              account_id: String,
+              client_type: Symbol,
+              company_id: String,
+              connection_id: String,
+              connection_type: Symbol,
+              products: T::Array[String],
+              provider_id: String,
+              customer_id: T.nilable(String),
+              token_type: String
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class ClientType < FinchAPI::Enum
+        abstract!
+
+        PRODUCTION = :production
+        DEVELOPMENT = :development
+        SANDBOX = :sandbox
+
+        sig { override.returns(T::Array[Symbol]) }
+        def self.values
+        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/directory_event.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class DirectoryEvent < FinchAPI::Models::BaseWebhookEvent
+      sig { returns(T.nilable(FinchAPI::Models::DirectoryEvent::Data)) }
+      def data
+      end
+
+      sig { params(_: FinchAPI::Models::DirectoryEvent::Data).returns(FinchAPI::Models::DirectoryEvent::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::DirectoryEvent::Data, event_type: Symbol).void }
+      def initialize(data: nil, event_type: nil)
+      end
+
+      sig { override.returns({data: FinchAPI::Models::DirectoryEvent::Data, event_type: Symbol}) }
+      def to_hash
+      end
+
+      class Data < 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 EventType < FinchAPI::Enum
+        abstract!
+
+        DIRECTORY_CREATED = :"directory.created"
+        DIRECTORY_UPDATED = :"directory.updated"
+        DIRECTORY_DELETED = :"directory.deleted"
+
+        sig { override.returns(T::Array[Symbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: strong
+
+module FinchAPI
+  module Models
+    class DisconnectResponse < FinchAPI::BaseModel
+      sig { returns(String) }
+      def status
+      end
+
+      sig { params(_: String).returns(String) }
+      def status=(_)
+      end
+
+      sig { params(status: String).void }
+      def initialize(status:)
+      end
+
+      sig { override.returns({status: String}) }
+      def to_hash
+      end
+    end
+  end
+end