capistrano-data_plane_api 0.1.4 → 0.2.0

data/lib/capistrano/data_plane_api.rb

@@ -1,5 +1,7 @@
+# typed: true
 # frozen_string_literal: true
 
+require 'sorbet-runtime'
 require 'data_plane_api'
 require 'pastel'
 require 'pathname'
@@ -25,11 +27,10 @@ module Capistrano
     class NoSuchBackendError < Error; end
     class NoBackendForThisStageError < Error; end
 
-    # @return [Pastel::Delegator]
-    COLORS = ::Pastel.new
+    COLORS = T.let(::Pastel.new, T.untyped) # rubocop:disable Sorbet/ForbidTUntyped
 
     class << self
-      # @return [Capistrano::DataPlaneApi::Configuration]
+      #: -> Configuration
       def configuration
         raise NotConfiguredError, <<~ERR unless @configuration
           `Capistrano::DataPlaneApi` is not configured!
@@ -40,7 +41,7 @@ module Capistrano
         @configuration
       end
 
-      # @param val [Capistrano::DataPlaneApi::Configuration, Hash{String, Symbol => Object}, String, Pathname]
+      #: (Configuration | Hash[String | Symbol, Object] | String | Pathname) -> void
       def configuration=(val)
         case val
         when ::Hash
@@ -54,17 +55,13 @@ module Capistrano
           @configuration = val
         when ::String, ::Pathname
           @configuration = Configuration.from_file(val.to_s)
-          @configuration.file_path = val
-        else
-          raise ::ArgumentError,
-                "Configuration should be a `#{::Hash}`, `#{Configuration}`, #{::String} or #{::Pathname}" \
-                ", received: #{val.inspect} (#{val.class.inspect})"
+          @configuration.file_path = val.to_s
         end
       end
 
       # Prints the current configuration in a human readable format.
       #
-      # @return [void]
+      #: -> void
       def show_config
         puts ::JSON.pretty_generate(configuration.to_h)
       end
@@ -72,7 +69,7 @@ module Capistrano
       # Prints the current state of all backends and
       # their servers in a human readable format.
       #
-      # @return [void]
+      #: -> void
       def show_state
         TerminalPrintLoop.call do
           ShowState.call
@@ -81,32 +78,32 @@ module Capistrano
 
       # Set server's admin_state to `drain`.
       #
-      # @param deployment_stage [Symbol]
-      # @param force [Boolean] Change the server's state even when no other server is `up`
-      # @param config [::DataPlaneApi::Configuration, nil]
-      # @return [Hash, FalseClass] Server state after the change, or `false`
+      # @param force: Change the server's state even when no other server is `up`
+      # @return: Server state after the change, or `nil`
       #   when no change happened
       # @raise [Error] The process failed due to some reason
+      #: (String | Symbol, bool, ::DataPlaneApi::Configuration?) -> Hash[String, untyped]?
       def server_set_drain(deployment_stage, force: false, config: nil)
         haproxy_server, haproxy_backend = find_server_and_backend(deployment_stage)
-        return false if haproxy_backend.servers.length < 2 # skip HAProxy if there is only a single server
+        servers = T.must haproxy_backend.servers
+        return if servers.length < 2 # skip HAProxy if there is only a single server
 
         validate_backend_state(haproxy_backend, haproxy_server) unless force
 
         conf = ::DataPlaneApi::Configuration.new(
-          basic_user: haproxy_backend.basic_user || @configuration.basic_user,
+          basic_user:     haproxy_backend.basic_user || @configuration.basic_user,
           basic_password: haproxy_backend.basic_password || @configuration.basic_password,
-          parent: config,
-          url: configuration.api_url
+          parent:         config,
+          url:            configuration.api_url,
         )
 
         # set the target server's state to `drain`
         response =
           ::DataPlaneApi::Server.update_transient_settings(
-            backend: haproxy_backend.name,
-            name: haproxy_server.name,
+            backend:  haproxy_backend.name,
+            name:     haproxy_server.name,
             settings: { admin_state: :drain },
-            config: conf
+            config:   conf,
           )
 
         unless response.status.between?(200, 299) && response.body['admin_state'] == 'drain'
@@ -119,32 +116,31 @@ module Capistrano
 
       # Set server's admin_state to `maint`.
       #
-      # @param deployment_stage [Symbol]
-      # @param force [Boolean] Change the server's state even when no other server is `up`
-      # @param config [::DataPlaneApi::Configuration, nil]
-      # @return [Hash, FalseClass] Server state after the change, or `false`
-      #   when no change happened
+      # @param force: Change the server's state even when no other server is `up`
+      # @return: Server state after the change, or `nil` when no change happened
       # @raise [Error] The process failed due to some reason
+      #: (String | Symbol, bool, ::DataPlaneApi::Configuration?) -> Hash[String, untyped]?
       def server_set_maint(deployment_stage, force: false, config: nil)
         haproxy_server, haproxy_backend = find_server_and_backend(deployment_stage)
-        return false if haproxy_backend.servers.length < 2 # skip HAProxy if there is only a single server
+        servers = T.must haproxy_backend.servers
+        return if servers.length < 2 # skip HAProxy if there is only a single server
 
         validate_backend_state(haproxy_backend, haproxy_server) unless force
 
         conf = ::DataPlaneApi::Configuration.new(
-          basic_user: haproxy_backend.basic_user || @configuration.basic_user,
+          basic_user:     haproxy_backend.basic_user || @configuration.basic_user,
           basic_password: haproxy_backend.basic_password || @configuration.basic_password,
-          parent: config,
-          url: configuration.api_url
+          parent:         config,
+          url:            configuration.api_url,
         )
 
         # set the target server's state to `maint`
         response =
           ::DataPlaneApi::Server.update_transient_settings(
-            backend: haproxy_backend.name,
-            name: haproxy_server.name,
+            backend:  haproxy_backend.name,
+            name:     haproxy_server.name,
             settings: { admin_state: :maint },
-            config: conf
+            config:   conf,
           )
 
         unless response.status.between?(200, 299) && response.body['admin_state'] == 'maint'
@@ -157,29 +153,28 @@ module Capistrano
 
       # Set server's admin_state to `ready`
       #
-      # @param deployment_stage [Symbol]
-      # @param config [::DataPlaneApi::Configuration, nil]
-      # @return [Hash, FalseClass] Server state after the change, or `false`
-      #   when no change happened
+      # @return: Server state after the change, or `nil` when no change happened
       # @raise [Error] The process failed due to some reason
+      #: (String | Symbol, ::DataPlaneApi::Configuration?) -> Hash[String, untyped]?
       def server_set_ready(deployment_stage, config: nil)
         haproxy_server, haproxy_backend = find_server_and_backend(deployment_stage)
-        return false if haproxy_backend.servers.length < 2 # skip HAProxy if there is only a single server
+        servers = T.must haproxy_backend.servers
+        return if servers.length < 2 # skip HAProxy if there is only a single server
 
         conf = ::DataPlaneApi::Configuration.new(
-          basic_user: haproxy_backend.basic_user || @configuration.basic_user,
+          basic_user:     haproxy_backend.basic_user || @configuration.basic_user,
           basic_password: haproxy_backend.basic_password || @configuration.basic_password,
-          parent: config,
-          url: configuration.api_url
+          parent:         config,
+          url:            configuration.api_url,
         )
 
         # set the target server's state to `drain`
         response =
           ::DataPlaneApi::Server.update_transient_settings(
-            backend: haproxy_backend.name,
-            name: haproxy_server.name,
+            backend:  haproxy_backend.name,
+            name:     haproxy_server.name,
             settings: { admin_state: :ready },
-            config: conf
+            config:   conf,
           )
 
         unless response.status.between?(200, 299) &&
@@ -193,13 +188,26 @@ module Capistrano
         response.body
       end
 
+      # Get the state of the server.
+      #
+      # @return: Server state
+      # @raise [Error] The process failed due to some reason
+      #: (String | Symbol, ::DataPlaneApi::Configuration?) -> Hash[String, untyped]?
+      def server_get_state(deployment_stage, config: nil)
+        haproxy_server, haproxy_backend = find_server_and_backend(deployment_stage)
+
+        # set the target server's state to `drain`
+        response = get_server_settings(T.must(haproxy_backend.name), T.must(haproxy_server.name), config: config)
+        response.body
+      end
+
       # Find the HAProxy backend config with a particular name.
       #
-      # @param backend_name [String]
-      # @return [Capistrano::DataPlaneApi::Configuration::Backend] HAProxy backend config.
+      # @return: HAProxy backend config.
       # @raise [NoSuchBackendError] There is no backend with this name.
+      #: (Symbol | String) -> Configuration::Backend
       def find_backend(backend_name)
-        backend = configuration.backends.find { _1.name == backend_name }
+        backend = configuration.backends&.find { _1.name == backend_name }
         if backend.nil?
           raise NoSuchBackendError,
                 'There is no HAProxy backend with this name! ' \
@@ -212,21 +220,20 @@ module Capistrano
       # Find the server and backend config for a particular
       # deployment stage.
       #
-      # @param deployment_stage [Symbol, String]
-      # @return [Capistrano::DataPlaneApi::Configuration::Server, Capistrano::DataPlaneApi::Configuration::Backend]
+      # @return:
       #   Two-element Array
       #   where the first element is the HAProxy server config and the second one
       #   is the HAProxy backend config
+      #: (Symbol | String) -> [Configuration::Server, Configuration::Backend]
       def find_server_and_backend(deployment_stage)
-        # @type [Capistrano::DataPlaneApi::Configuration::Server, nil]
-        haproxy_server = nil
+        haproxy_server = T.let(nil, T.nilable(Configuration::Server))
         deployment_stage_str = deployment_stage.to_s
+
         # find the HAProxy backend that the
         # current deployment target is a part of
-        # @type [Capistrano::DataPlaneApi::Configuration::Backend]
         haproxy_backend =
-          configuration.backends.each do |backend|
-            haproxy_server = backend.servers.find { _1.stage == deployment_stage_str }
+          configuration.backends&.each do |backend|
+            haproxy_server = backend.servers&.find { _1.stage == deployment_stage_str }
             break backend if haproxy_server
           end
 
@@ -236,21 +243,22 @@ module Capistrano
                 "#{deployment_stage.inspect} `#{configuration.file_path.inspect}`"
         end
 
-        [haproxy_server, haproxy_backend]
+        [T.must(haproxy_server), haproxy_backend]
       end
 
-      # @param backend_name [String]
-      # @param config [::DataPlaneApi::Configuration, nil]
-      # @return [Faraday::Response]
+      #: (Symbol | String, ::DataPlaneApi::Configuration?) -> Faraday::Response
       def get_backend_servers_settings(backend_name, config: nil)
         haproxy_backend = find_backend(backend_name)
         conf = ::DataPlaneApi::Configuration.new(
-          basic_user: haproxy_backend.basic_user || @configuration.basic_user,
+          basic_user:     haproxy_backend.basic_user || @configuration.basic_user,
           basic_password: haproxy_backend.basic_password || @configuration.basic_password,
-          parent: config,
-          url: configuration.api_url
+          parent:         config,
+          url:            configuration.api_url,
+        )
+        response = ::DataPlaneApi::Server.get_runtime_settings(
+          backend: backend_name.to_s,
+          config:  conf,
         )
-        response = ::DataPlaneApi::Server.get_runtime_settings(backend: backend_name, config: conf)
         unless response.status.between?(200, 299)
           raise QueryError,
                 "HAProxy query failed! Couldn't fetch servers' states"
@@ -259,21 +267,35 @@ module Capistrano
         response
       end
 
+      #: (Symbol | String, Symbol | String, ::DataPlaneApi::Configuration?) -> Faraday::Response
+      def get_server_settings(backend_name, server_name, config: nil)
+        haproxy_backend = find_backend(backend_name)
+        conf = ::DataPlaneApi::Configuration.new(
+          basic_user:     haproxy_backend.basic_user || @configuration.basic_user,
+          basic_password: haproxy_backend.basic_password || @configuration.basic_password,
+          parent:         config,
+          url:            configuration.api_url,
+        )
+        response = ::DataPlaneApi::Server.get_runtime_settings(
+          backend: backend_name.to_s,
+          name:    server_name.to_s,
+          config:  conf,
+        )
+        unless response.status.between?(200, 299)
+          raise QueryError,
+                "HAProxy query failed! Couldn't fetch server's state"
+        end
+
+        response
+      end
+
       private
 
-      # @param haproxy_backend [Capistrano::DataPlaneApi::Configuration::Backend]
-      # @param haproxy_server [Capistrano::DataPlaneApi::Configuration::Server]
-      # @return [void]
+      #: (Configuration::Backend, Configuration::Server) -> void
       def validate_backend_state(haproxy_backend, haproxy_server)
-        response = get_backend_servers_settings(haproxy_backend.name)
-        unless haproxy_backend.servers.length == response.body.length
-          raise QueryError,
-                'HAProxy query failed! Configured servers for this backend' \
-                "don't match the configuration file! `#{configuration.file_path}`"
-        end
+        response = get_backend_servers_settings(T.must(haproxy_backend.name))
 
-        # @type [Array<Hash>]
-        server_statuses = response.body
+        server_statuses = T.let(response.body, T::Array[T::Hash[String, T.untyped]]) # rubocop:disable Sorbet/ForbidTUntyped
         # check if there are any servers other than this one that are `ready` and `up`
         other_servers_ready = server_statuses.any? do |server_status|
           server_status['admin_state'] == 'ready' &&

data/lib/capistrano-data_plane_api.rb

@@ -0,0 +1,4 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative 'capistrano/data_plane_api'

data/rbi/capistrano-data_plane_api.rbi

@@ -0,0 +1,283 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `capistrano-data_plane_api` gem.
+# Please instead update this file by running `spoom srb sigs export`.
+
+module Capistrano; end
+
+# Main module/namespace of the `capistrano-data_plane_api` gem.
+module Capistrano::DataPlaneApi
+  extend ::Capistrano::DataPlaneApi::Helper
+
+  class << self
+    # @raise [NotConfiguredError]
+    sig { returns(::Capistrano::DataPlaneApi::Configuration) }
+    def configuration; end
+
+    sig do
+      params(
+        val: T.any(::Capistrano::DataPlaneApi::Configuration, ::Pathname, ::String, T::Hash[T.any(::String, ::Symbol), ::Object])
+      ).void
+    end
+    def configuration=(val); end
+
+    # Find the HAProxy backend config with a particular name.
+    #
+    # @return: HAProxy backend config.
+    #
+    # @raise [NoSuchBackendError] There is no backend with this name.
+    sig { params(backend_name: T.any(::String, ::Symbol)).returns(::Capistrano::DataPlaneApi::Configuration::Backend) }
+    def find_backend(backend_name); end
+
+    # Find the server and backend config for a particular
+    # deployment stage.
+    #
+    # @return:
+    #   Two-element Array
+    #   where the first element is the HAProxy server config and the second one
+    #   is the HAProxy backend config
+    sig do
+      params(
+        deployment_stage: T.any(::String, ::Symbol)
+      ).returns([::Capistrano::DataPlaneApi::Configuration::Server, ::Capistrano::DataPlaneApi::Configuration::Backend])
+    end
+    def find_server_and_backend(deployment_stage); end
+
+    sig do
+      params(
+        backend_name: T.any(::String, ::Symbol),
+        config: T.nilable(::DataPlaneApi::Configuration)
+      ).returns(::Faraday::Response)
+    end
+    def get_backend_servers_settings(backend_name, config: T.unsafe(nil)); end
+
+    sig do
+      params(
+        backend_name: T.any(::String, ::Symbol),
+        server_name: T.any(::String, ::Symbol),
+        config: T.nilable(::DataPlaneApi::Configuration)
+      ).returns(::Faraday::Response)
+    end
+    def get_server_settings(backend_name, server_name, config: T.unsafe(nil)); end
+
+    # Get the state of the server.
+    #
+    # @return: Server state
+    #
+    # @raise [Error] The process failed due to some reason
+    sig do
+      params(
+        deployment_stage: T.any(::String, ::Symbol),
+        config: T.nilable(::DataPlaneApi::Configuration)
+      ).returns(T.nilable(T::Hash[::String, T.untyped]))
+    end
+    def server_get_state(deployment_stage, config: T.unsafe(nil)); end
+
+    # Set server's admin_state to `drain`.
+    #
+    # @return: Server state after the change, or `nil`
+    #   when no change happened
+    #
+    # @raise [Error] The process failed due to some reason
+    sig do
+      params(
+        deployment_stage: T.any(::String, ::Symbol),
+        force: T::Boolean,
+        config: T.nilable(::DataPlaneApi::Configuration)
+      ).returns(T.nilable(T::Hash[::String, T.untyped]))
+    end
+    def server_set_drain(deployment_stage, force: T.unsafe(nil), config: T.unsafe(nil)); end
+
+    # Set server's admin_state to `maint`.
+    #
+    # @return: Server state after the change, or `nil` when no change happened
+    #
+    # @raise [Error] The process failed due to some reason
+    sig do
+      params(
+        deployment_stage: T.any(::String, ::Symbol),
+        force: T::Boolean,
+        config: T.nilable(::DataPlaneApi::Configuration)
+      ).returns(T.nilable(T::Hash[::String, T.untyped]))
+    end
+    def server_set_maint(deployment_stage, force: T.unsafe(nil), config: T.unsafe(nil)); end
+
+    # Set server's admin_state to `ready`
+    #
+    # @return: Server state after the change, or `nil` when no change happened
+    #
+    # @raise [Error] The process failed due to some reason
+    sig do
+      params(
+        deployment_stage: T.any(::String, ::Symbol),
+        config: T.nilable(::DataPlaneApi::Configuration)
+      ).returns(T.nilable(T::Hash[::String, T.untyped]))
+    end
+    def server_set_ready(deployment_stage, config: T.unsafe(nil)); end
+
+    # Prints the current configuration in a human readable format.
+    sig { void }
+    def show_config; end
+
+    # Prints the current state of all backends and
+    # their servers in a human readable format.
+    sig { void }
+    def show_state; end
+
+    private
+
+    sig do
+      params(
+        haproxy_backend: ::Capistrano::DataPlaneApi::Configuration::Backend,
+        haproxy_server: ::Capistrano::DataPlaneApi::Configuration::Server
+      ).void
+    end
+    def validate_backend_state(haproxy_backend, haproxy_server); end
+  end
+end
+
+Capistrano::DataPlaneApi::COLORS = T.let(T.unsafe(nil), Pastel::Delegator)
+
+# Configuration object of the `capistrano-data_plane_api` gem.
+class Capistrano::DataPlaneApi::Configuration < ::Capistrano::DataPlaneApi::Type
+  class << self
+    sig { params(path: ::String).returns(T.attached_class) }
+    def from_file(path); end
+  end
+end
+
+# Contains the configuration options of a backend
+class Capistrano::DataPlaneApi::Configuration::Backend < ::Capistrano::DataPlaneApi::Type; end
+
+# Contains the configuration options of a server
+class Capistrano::DataPlaneApi::Configuration::Server < ::Capistrano::DataPlaneApi::Type
+  sig { returns(T.nilable(::String)) }
+  def name; end
+
+  sig { returns(T.nilable(::String)) }
+  def stage; end
+end
+
+# A Shale type that represents a ruby `Symbol`
+class Capistrano::DataPlaneApi::Configuration::Symbol < ::Shale::Type::String
+  class << self
+    def cast(value); end
+  end
+end
+
+# Include in a class to grant it the `#dig` method.
+# It's implemented so that it calls public methods.
+module Capistrano::DataPlaneApi::Diggable
+  include ::Booleans::KernelExtension
+  include ::Kernel
+
+  # Extracts the nested value specified by the sequence of key objects by calling `dig` at each step,
+  # returning `nil` if any intermediate step is `nil`.
+  #
+  # This implementation of `dig` uses `public_send` under the hood.
+  #
+  # @raise [TypeError] value has no #dig method
+  sig { params(args: T.untyped).returns(T.untyped) }
+  def dig(*args); end
+end
+
+# Include in a class to make its instances capable
+# of comparing themselves with other objects of the same class
+# by calling `==` on their instance variables.
+module Capistrano::DataPlaneApi::Equatable
+  include ::Booleans::KernelExtension
+  include ::Kernel
+
+  # @param other [Object]
+  # @return [Boolean]
+  def ==(*args, **_arg1, &blk); end
+
+  sig { params(other: ::Object).returns(T::Boolean) }
+  def eql?(other); end
+end
+
+class Capistrano::DataPlaneApi::Error < ::StandardError; end
+
+# Provides helper methods
+module Capistrano::DataPlaneApi::Helper
+  sig { returns(T::Boolean) }
+  def force_haproxy?; end
+
+  sig { params(state: T.nilable(T.any(::String, ::Symbol))).returns(T.nilable(::String)) }
+  def humanize_admin_state(state); end
+
+  sig { params(backend: ::Capistrano::DataPlaneApi::Configuration::Backend).returns(::String) }
+  def humanize_backend_name(backend); end
+
+  sig { params(state: T.nilable(T.any(::String, ::Symbol))).returns(T.nilable(::String)) }
+  def humanize_operational_state(state); end
+
+  sig { returns(T::Boolean) }
+  def no_haproxy?; end
+end
+
+Capistrano::DataPlaneApi::Helper::ADMIN_STATE_COLORS = T.let(T.unsafe(nil), Hash)
+Capistrano::DataPlaneApi::Helper::OPERATIONAL_STATE_COLORS = T.let(T.unsafe(nil), Hash)
+class Capistrano::DataPlaneApi::NoBackendForThisStageError < ::Capistrano::DataPlaneApi::Error; end
+class Capistrano::DataPlaneApi::NoOtherServerReadyError < ::Capistrano::DataPlaneApi::Error; end
+class Capistrano::DataPlaneApi::NoSuchBackendError < ::Capistrano::DataPlaneApi::Error; end
+class Capistrano::DataPlaneApi::NotConfiguredError < ::Capistrano::DataPlaneApi::Error; end
+class Capistrano::DataPlaneApi::QueryError < ::Capistrano::DataPlaneApi::Error; end
+
+# Creates a human readable summary of the state of
+# HAProxy backends and servers to stdout.
+module Capistrano::DataPlaneApi::ShowState
+  class << self
+    sig { returns(::String) }
+    def call; end
+
+    private
+
+    sig { params(server: T::Hash[::String, T.untyped]).returns(T.nilable(::String)) }
+    def admin_state(server); end
+
+    sig { params(backend: ::Capistrano::DataPlaneApi::Configuration::Backend).returns(::String) }
+    def backend_name(backend); end
+
+    sig { params(server: T::Hash[::String, T.untyped]).returns(T.nilable(::String)) }
+    def operational_state(server); end
+
+    sig { params(server: T::Hash[::String, T.untyped]).returns(T.nilable(::String)) }
+    def server_name(server); end
+  end
+end
+
+# Provides a method that renders
+# strings in a terminal with the given interval.
+module Capistrano::DataPlaneApi::TerminalPrintLoop
+  class << self
+    # Calls the passed block in an endless loop with a given interval
+    # between calls.
+    # It prints the `String` returned from the block and clears it
+    # before another frame is printed.
+    sig { params(interval: ::Integer, _block: T.proc.params(arg0: ::String).returns(::Object)).void }
+    def call(interval: T.unsafe(nil), &_block); end
+  end
+end
+
+# A Base class for all types of the Data Plane API request and response bodies
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+class Capistrano::DataPlaneApi::Type < ::Shale::Mapper
+  include ::Capistrano::DataPlaneApi::Diggable
+  include ::Capistrano::DataPlaneApi::Equatable
+
+  abstract!
+
+  sig { params(key: T.any(::String, ::Symbol)).returns(T.nilable(::Object)) }
+  def [](key); end
+
+  sig { params(key: T.any(::String, ::Symbol), val: ::Object).void }
+  def []=(key, val); end
+
+  def to_h; end
+end
+
+class Capistrano::DataPlaneApi::UpdateServerStateError < ::Capistrano::DataPlaneApi::Error; end
+Capistrano::DataPlaneApi::VERSION = T.let(T.unsafe(nil), String)

data/sorbet/config

@@ -0,0 +1,6 @@
+--dir
+.
+--enable-experimental-rbs-signatures
+--ignore=tmp/
+--ignore=vendor/
+--ignore=rbi/capistrano-data_plane_api.rbi

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/faraday.rbi

@@ -0,0 +1,17 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Faraday
+  class << self
+    sig { params(url: T.untyped, options: T::Hash[Symbol, T.untyped], block: T.nilable(T.proc.params(connection: Faraday::Connection).void)).returns(Faraday::Connection) }
+    def new(url = nil, options = {}, &block); end
+  end
+end
+
+class Faraday::Response
+  sig { returns(T::Boolean) }
+  def success?; end
+end