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

data/rbi/lib/finch-api/base_page.rbi

@@ -2,8 +2,6 @@
 
 module FinchAPI
   module BasePage
-    abstract!
-
     Elem = type_member(:out)
 
     sig { overridable.returns(T::Boolean) }
@@ -22,18 +20,17 @@ module FinchAPI
     def to_enum
     end
 
-    alias_method :enum_for, :to_enum
-
+    # @api private
     sig do
       params(
         client: FinchAPI::BaseClient,
         req: FinchAPI::BaseClient::RequestComponentsShape,
         headers: T.any(T::Hash[String, String], Net::HTTPHeader),
-        unwrapped: T.anything
+        page_data: T.anything
       )
         .void
     end
-    def initialize(client:, req:, headers:, unwrapped:)
+    def initialize(client:, req:, headers:, page_data:)
     end
   end
 end

data/rbi/lib/finch-api/client.rbi

@@ -11,69 +11,60 @@ module FinchAPI
     DEFAULT_MAX_RETRY_DELAY = T.let(8.0, Float)
 
     sig { returns(T.nilable(String)) }
-    def access_token
-    end
+    attr_reader :access_token
 
     sig { returns(T.nilable(String)) }
-    def client_id
-    end
+    attr_reader :client_id
 
     sig { returns(T.nilable(String)) }
-    def client_secret
-    end
+    attr_reader :client_secret
 
     sig { returns(FinchAPI::Resources::AccessTokens) }
-    def access_tokens
-    end
+    attr_reader :access_tokens
 
     sig { returns(FinchAPI::Resources::HRIS) }
-    def hris
-    end
+    attr_reader :hris
 
     sig { returns(FinchAPI::Resources::Providers) }
-    def providers
-    end
+    attr_reader :providers
 
     sig { returns(FinchAPI::Resources::Account) }
-    def account
-    end
+    attr_reader :account
 
     sig { returns(FinchAPI::Resources::Webhooks) }
-    def webhooks
-    end
+    attr_reader :webhooks
 
     sig { returns(FinchAPI::Resources::RequestForwarding) }
-    def request_forwarding
-    end
+    attr_reader :request_forwarding
 
     sig { returns(FinchAPI::Resources::Jobs) }
-    def jobs
-    end
+    attr_reader :jobs
 
     sig { returns(FinchAPI::Resources::Sandbox) }
-    def sandbox
-    end
+    attr_reader :sandbox
 
     sig { returns(FinchAPI::Resources::Payroll) }
-    def payroll
-    end
+    attr_reader :payroll
 
     sig { returns(FinchAPI::Resources::Connect) }
-    def connect
-    end
+    attr_reader :connect
 
+    # @api private
     sig { override.returns(T::Hash[String, String]) }
     private def auth_headers
     end
 
+    # @api private
     sig { returns(T::Hash[String, String]) }
     private def bearer_auth
     end
 
+    # @api private
     sig { returns(T::Hash[String, String]) }
     private def basic_auth
     end
 
+    # Creates and returns a new client for interacting with the API.
     sig do
       params(
         base_url: T.nilable(String),
@@ -85,13 +76,17 @@ module FinchAPI
         initial_retry_delay: Float,
         max_retry_delay: Float
       )
-        .void
+        .returns(T.attached_class)
     end
-    def initialize(
+    def self.new(
+      # Override the default base URL for the API, e.g., `"https://api.example.com/v2/"`
       base_url: nil,
       access_token: nil,
+      # Defaults to `ENV["FINCH_CLIENT_ID"]`
       client_id: ENV["FINCH_CLIENT_ID"],
+      # Defaults to `ENV["FINCH_CLIENT_SECRET"]`
       client_secret: ENV["FINCH_CLIENT_SECRET"],
+      # Max number of retries to attempt after a failed retryable request.
       max_retries: DEFAULT_MAX_RETRIES,
       timeout: DEFAULT_TIMEOUT_IN_SECONDS,
       initial_retry_delay: DEFAULT_INITIAL_RETRY_DELAY,

data/rbi/lib/finch-api/errors.rbi

@@ -3,8 +3,7 @@
 module FinchAPI
   class Error < StandardError
     sig { returns(T.nilable(StandardError)) }
-    def cause
-    end
+    attr_accessor :cause
   end
 
   class ConversionError < FinchAPI::Error
@@ -12,17 +11,15 @@ module FinchAPI
 
   class APIError < FinchAPI::Error
     sig { returns(URI::Generic) }
-    def url
-    end
+    attr_accessor :url
 
     sig { returns(T.nilable(Integer)) }
-    def status
-    end
+    attr_accessor :status
 
     sig { returns(T.nilable(T.anything)) }
-    def body
-    end
+    attr_accessor :body
 
+    # @api private
     sig do
       params(
         url: URI::Generic,
@@ -32,21 +29,20 @@ module FinchAPI
         response: NilClass,
         message: T.nilable(String)
       )
-        .void
+        .returns(T.attached_class)
     end
-    def initialize(url:, status: nil, body: nil, request: nil, response: nil, message: nil)
+    def self.new(url:, status: nil, body: nil, request: nil, response: nil, message: nil)
     end
   end
 
   class APIConnectionError < FinchAPI::APIError
     sig { void }
-    def status
-    end
+    attr_accessor :status
 
     sig { void }
-    def body
-    end
+    attr_accessor :body
 
+    # @api private
     sig do
       params(
         url: URI::Generic,
@@ -56,13 +52,14 @@ module FinchAPI
         response: NilClass,
         message: T.nilable(String)
       )
-        .void
+        .returns(T.attached_class)
     end
-    def initialize(url:, status: nil, body: nil, request: nil, response: nil, message: "Connection error.")
+    def self.new(url:, status: nil, body: nil, request: nil, response: nil, message: "Connection error.")
     end
   end
 
   class APITimeoutError < FinchAPI::APIConnectionError
+    # @api private
     sig do
       params(
         url: URI::Generic,
@@ -72,13 +69,14 @@ module FinchAPI
         response: NilClass,
         message: T.nilable(String)
       )
-        .void
+        .returns(T.attached_class)
     end
-    def initialize(url:, status: nil, body: nil, request: nil, response: nil, message: "Request timed out.")
+    def self.new(url:, status: nil, body: nil, request: nil, response: nil, message: "Request timed out.")
     end
   end
 
   class APIStatusError < FinchAPI::APIError
+    # @api private
     sig do
       params(
         url: URI::Generic,
@@ -94,9 +92,9 @@ module FinchAPI
     end
 
     sig { returns(Integer) }
-    def status
-    end
+    attr_accessor :status
 
+    # @api private
     sig do
       params(
         url: URI::Generic,
@@ -106,9 +104,9 @@ module FinchAPI
         response: NilClass,
         message: T.nilable(String)
       )
-        .void
+        .returns(T.attached_class)
     end
-    def initialize(url:, status:, body:, request:, response:, message: nil)
+    def self.new(url:, status:, body:, request:, response:, message: nil)
     end
   end
 

data/rbi/lib/finch-api/extern.rbi

@@ -1,7 +1,7 @@
 # typed: strong
 
 module FinchAPI
+  # @api private
   module Extern
-    abstract!
   end
 end

data/rbi/lib/finch-api/individuals_page.rbi

@@ -6,32 +6,14 @@ module FinchAPI
 
     Elem = type_member
 
-    sig { returns(T::Array[Elem]) }
-    def individuals
-    end
-
-    sig { params(_: T::Array[Elem]).returns(T::Array[Elem]) }
-    def individuals=(_)
-    end
+    sig { returns(T.nilable(T::Array[Elem])) }
+    attr_accessor :individuals
 
     sig { returns(FinchAPI::Models::Paging) }
-    def paging
-    end
+    attr_accessor :paging
 
-    sig { params(_: FinchAPI::Models::Paging).returns(FinchAPI::Models::Paging) }
-    def paging=(_)
-    end
-
-    sig do
-      params(
-        client: FinchAPI::BaseClient,
-        req: FinchAPI::BaseClient::RequestComponentsShape,
-        headers: T.any(T::Hash[String, String], Net::HTTPHeader),
-        unwrapped: T::Hash[Symbol, T.anything]
-      )
-        .void
-    end
-    def initialize(client:, req:, headers:, unwrapped:)
+    sig { returns(String) }
+    def inspect
     end
   end
 end

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

@@ -7,36 +7,25 @@ module FinchAPI
       include FinchAPI::RequestParameters
 
       sig { returns(String) }
-      def code
-      end
-
-      sig { params(_: String).returns(String) }
-      def code=(_)
-      end
+      attr_accessor :code
 
       sig { returns(T.nilable(String)) }
-      def client_id
-      end
+      attr_reader :client_id
 
-      sig { params(_: String).returns(String) }
-      def client_id=(_)
-      end
+      sig { params(client_id: String).void }
+      attr_writer :client_id
 
       sig { returns(T.nilable(String)) }
-      def client_secret
-      end
+      attr_reader :client_secret
 
-      sig { params(_: String).returns(String) }
-      def client_secret=(_)
-      end
+      sig { params(client_secret: String).void }
+      attr_writer :client_secret
 
       sig { returns(T.nilable(String)) }
-      def redirect_uri
-      end
+      attr_reader :redirect_uri
 
-      sig { params(_: String).returns(String) }
-      def redirect_uri=(_)
-      end
+      sig { params(redirect_uri: String).void }
+      attr_writer :redirect_uri
 
       sig do
         params(
@@ -44,11 +33,11 @@ module FinchAPI
           client_id: String,
           client_secret: String,
           redirect_uri: String,
-          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(code:, client_id: nil, client_secret: nil, redirect_uri: nil, request_options: {})
+      def self.new(code:, client_id: nil, client_secret: nil, redirect_uri: nil, request_options: {})
       end
 
       sig do

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

@@ -6,8 +6,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/account_introspect_params.rbi

@@ -6,8 +6,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}) }