proxy-cheap-client 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 72af370a7a949355facabddfef0d1bf5ec5221303ce4314e287f66cb96b1750c
+  data.tar.gz: bd3e0d5c6cc1bfd9adbf66abe2e01dc4fd0e2156fd0fe3c3f5544692effdf7a5
+SHA512:
+  metadata.gz: 1f51ba931aa10bfe72a7604c6681b3c63812053353ba01a6056c8854aba7904237506faea69ac0ac3739798e87bfa6284848733125fbb376e9f1d16f009b212d
+  data.tar.gz: 1f01a397a39b39380014d66bddcdf4289d508b23cb5adbce4557e39bae33745959ef43b6cb9ce96169b6d6242b485dc28c2ba79116163ee7b510d2fac5580d6a

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MassProspecting
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,166 @@
+# proxy-cheap-client
+
+Ruby client for the Proxy-Cheap.com API.
+
+[![Gem Version](https://img.shields.io/gem/v/proxy-cheap-client.svg)](https://rubygems.org/gems/proxy-cheap-client) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](./LICENSE.txt)
+
+## Features
+
+* Retrieve account balance
+* List proxies
+* Enable/disable auto-extend on proxies
+* Order new residential proxies
+
+## Requirements
+
+* Ruby 2.7+
+* Internet access to Proxy-Cheap.com API
+* API key and API secret from Proxy-Cheap.com
+
+## Installation
+
+Install from RubyGems:
+
+```bash
+gem install proxy-cheap-client
+```
+
+Or add to your `Gemfile`:
+
+```ruby
+gem "proxy-cheap-client"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Configuration
+
+The client requires both an API key and API secret.
+
+You have to pass them explicitly when initializing the client:
+
+```ruby
+client = ProxyCheapClient::Client.new(
+  api_key: "your_api_key_here",
+  api_secret: "your_api_secret_here"
+)
+```
+
+## Usage Example
+
+```ruby
+require "proxy_cheap_client"
+
+client = ProxyCheapClient::Client.new(
+  api_key: "your_api_key_here",
+  api_secret: "your_api_secret_here"
+)
+
+# 1. Get balance
+balance = client.balance
+puts "Balance: #{balance.amount} #{balance.currency}"
+```
+
+## Load Proxies
+
+```ruby
+proxies = client.proxies
+proxies.each do |p|
+  puts "Proxy #{p.id}: #{p.ip}:#{p.port}, auto_extend=#{p.auto_extend}"
+end
+```
+
+## Load Specific Proxy
+
+```ruby
+proxy = ProxyCheapClient::Proxy.load(12345)
+puts "Proxy details: #{proxy.to_h}"
+```
+
+## Enable auto-extend for a proxy
+
+```ruby
+proxy.enable_auto_extend
+puts "Auto-extend enabled"
+```
+
+## Disable auto-extend
+
+```ruby
+proxy.disable_auto_extend
+puts "Auto-extend disabled"
+```
+
+## Supported Countries
+
+```ruby
+arr = client.countries
+puts "Supported Countries: #{arr}"
+```
+
+## Order Residential Proxies
+
+```ruby
+order = client.order_static_residential_proxy(
+  country: "US",
+  proxyProtocol: "HTTP",
+  authenticationType: "USERNAME_PASSWORD"
+)
+```
+
+## Order Proxies
+
+```ruby
+order.proxies
+```
+
+## Error Handling
+
+The client raises specific exceptions for failure modes:
+
+* `ProxyCheapClient::AuthenticationError` - API key or secret is missing or invalid (HTTP 401)
+* `ProxyCheapClient::NotFoundError` - Resource does not exist (HTTP 404)
+* `ProxyCheapClient::BadRequestError` - Invalid request parameters (HTTP 400)
+* `ProxyCheapClient::ServerError` - Server-side error (HTTP 5xx)
+* `ProxyCheapClient::RequestError` - General request failure
+* `ProxyCheapClient::InvalidResponseError` - Malformed or non-JSON response
+
+All errors inherit from `ProxyCheapClient::Error` and include `status_code` and `response_body` attributes for debugging:
+
+```ruby
+begin
+  client.balance
+rescue ProxyCheapClient::NotFoundError => e
+  puts "Not found: #{e.message}"
+  puts "Status: #{e.status_code}"
+  puts "Body: #{e.response_body}"
+rescue ProxyCheapClient::Error => e
+  puts "API failure: #{e.message}"
+end
+```
+
+## Publishing
+
+Build and push to RubyGems:
+
+```bash
+gem build proxy-cheap-client.gemspec
+gem push proxy-cheap-client-#{ProxyCheapClient::VERSION}.gem
+```
+
+Make sure you have an account on RubyGems.org and appropriate credentials configured in `~/.gem/credentials`.
+
+## Contributing
+
+1. Fork the repository.
+2. Create a feature branch: `git checkout -b feature/xyz`
+3. Run tests (add test suite if missing).
+4. Open a pull request with a clear description.
+
+## License
+
+This project is licensed under the MIT License. See `LICENSE.txt` for details.

data/lib/proxy-cheap-client.rb

@@ -0,0 +1,4 @@
+gem 'faraday', '2.3.0'
+gem 'faraday-net_http', '2.1.0'
+require_relative "proxy_cheap_client/client"
+

data/lib/proxy_cheap_client/client.rb

@@ -0,0 +1,132 @@
+require "faraday"
+require "json"
+require_relative "version"
+require_relative "errors"
+require_relative "models/base"
+require_relative "models/balance"
+require_relative "models/proxy"
+require_relative "models/order"
+require_relative "models/configuration"
+
+module ProxyCheapClient
+  class Client < Base
+    API_BASE = "https://api.proxy-cheap.com"
+
+    # Initialize the client with API credentials.
+    # @param api_key [String] API key (or set PROXY_CHEAP_API_KEY env var)
+    # @param api_secret [String] API secret (or set PROXY_CHEAP_API_SECRET env var)
+    # @param timeout [Integer] Request timeout in seconds (default: 10)
+    def initialize(
+      api_key:, 
+      api_secret:, 
+      timeout: 10
+    )
+      @api_key = api_key
+      @api_secret = api_secret
+
+      raise AuthenticationError, "API key missing" unless @api_key && !@api_key.strip.empty?
+      raise AuthenticationError, "API secret missing" unless @api_secret && !@api_secret.strip.empty?
+
+      @conn = Faraday.new(url: API_BASE) do |f|
+        f.request :json
+        f.response :raise_error
+        f.options.timeout = timeout
+        f.headers["X-Api-Key"] = @api_key
+        f.headers["X-Api-Secret"] = @api_secret
+        f.headers["Content-Type"] = "application/json"
+        f.adapter Faraday.default_adapter
+      end
+    rescue Faraday::Error => e
+      raise RequestError, "Connection failure: #{e.message}"
+    end
+
+    def conn
+      @conn
+    end
+
+    # retrieve the array of countries with number of available proxies per country
+    def countries
+      config = self.configuration(
+        networkType: "RESIDENTIAL_STATIC",
+        ipVersion: "IPv4",
+        country: "US",
+        proxyProtocol: "HTTP",
+        authenticationType: "USERNAME_PASSWORD",
+        quantity: 1
+      )
+      config.data["supportedCountries"]
+    end
+
+    # Get user balance.
+    # @return [Balance]
+    def balance
+      resp = request(:get, "account/balance")
+      Balance.new(resp, self)
+    end
+
+    # Get all user proxies.
+    # @return [Array<Proxy>]
+    def proxies
+      resp = request(:get, "proxies")
+      # API may return proxies directly as an array or wrapped in a "data" key
+      proxy_list = resp.is_a?(Hash) && resp.key?("data") ? resp["data"] : resp
+      proxy_list = resp.is_a?(Hash) && resp.key?("proxies") ? resp["proxies"] : resp
+      Array(proxy_list).map { |p| Proxy.new(p, self) }
+    end
+    
+    # Convenience method to order a static residential proxy.
+    # @param params [Hash] Order parameters
+    # @option params [String] :country 2 letter country code (required)
+    # @option params [String] :isp ISP id
+    # @option params [String] :proxyProtocol HTTP, HTTPS, SOCKS5 (default: HTTP)
+    # @option params [String] :authenticationType USERNAME_PASSWORD or IP_WHITELIST
+    # @option params [Integer] :quantity number of proxies (default: 1)
+    # @return [Order]
+    def order_static_residential_proxy(params = {})
+      order_params = {
+        networkType: "RESIDENTIAL_STATIC",
+        ipVersion: "IPv4"
+      }.merge(params)
+      order(order_params)
+    end # def order_static_residential_proxy
+
+    private
+
+    # Get configuration/pricing according to filter parameters.
+    # Use this to preview an order before executing it.
+    # @param params [Hash] Configuration parameters
+    # @option params [String] :networkType MOBILE, DATACENTER, RESIDENTIAL, RESIDENTIAL_STATIC
+    # @option params [String] :ipVersion IPv4, IPv6, MOBILE
+    # @option params [String] :country 2 letter country code
+    # @option params [String] :region 2 letter region code
+    # @option params [String] :isp ISP id
+    # @option params [String] :proxyProtocol HTTP, HTTPS, SOCKS5
+    # @option params [String] :authenticationType USERNAME_PASSWORD, IP_WHITELIST
+    # @option params [Array<String>] :ipWhitelist whitelisted IPs
+    # @option params [String] :package package id
+    # @option params [Integer] :quantity proxies amount
+    # @option params [String] :couponCode order promo code
+    # @option params [Integer] :bandwidth amount in GB
+    # @option params [Boolean] :isAutoExtendEnabled enables auto extend
+    # @option params [Integer] :autoExtendBandwidth how many GB to extend
+    # @return [Configuration]
+    def configuration(params = {})
+      resp = request(:post, "order/configuration", params)
+      Configuration.new(resp, self)
+    end # def configuration
+
+    # Execute an order with the given configuration.
+    # Use `configuration` first to preview the order.
+    # @param params [Hash] Same parameters as `configuration`
+    # @return [Order]
+    def order(params = {})
+      resp = request(:post, "order/execute", params)
+      # {"id"=>"019aebab-7635-79e1-ba1f-95118dc12695",
+      # "periodInMonths"=>"1",
+      # "totalPrice"=>"3.39"}
+
+      # Return order model (API returns order descriptor including id/status)
+      Order.new(resp, self)
+    end # def order
+  end # class Client
+end # module ProxyCheapClient

data/lib/proxy_cheap_client/errors.rb

@@ -0,0 +1,18 @@
+module ProxyCheapClient
+  class Error < StandardError
+    attr_reader :status_code, :response_body
+
+    def initialize(message = nil, status_code: nil, response_body: nil)
+      @status_code = status_code
+      @response_body = response_body
+      super(message)
+    end
+  end
+
+  class AuthenticationError < Error; end
+  class RequestError < Error; end
+  class NotFoundError < Error; end
+  class BadRequestError < Error; end
+  class ServerError < Error; end
+  class InvalidResponseError < Error; end
+end

data/lib/proxy_cheap_client/models/balance.rb

@@ -0,0 +1,17 @@
+module ProxyCheapClient
+  #module Models
+    class Balance < Base
+      attr_reader :amount, :currency, :conn
+
+      def initialize(attrs = {}, client)
+        @amount = attrs["balance"] || attrs["amount"]
+        @currency = attrs["currency"] || "USD"
+        @conn = client.conn
+      end
+
+      def to_h
+        { amount: amount, currency: currency }
+      end
+    end
+  #end
+end

data/lib/proxy_cheap_client/models/base.rb

@@ -0,0 +1,87 @@
+module ProxyCheapClient
+  class Base
+    # Make an HTTP request to the API.
+    # @note Some API endpoints (whitelist, extend-period, buy-bandwidth) use GET
+    #       requests with JSON body, which is non-standard but matches the official API behavior.
+    def request(method, path, body = nil)
+      response = case method.to_s.downcase.to_sym
+                 when :get
+                   if body
+                     @conn.get(path) { |r| r.body = body.to_json }
+                   else
+                     @conn.get(path)
+                   end
+                 when :post
+                   @conn.post(path) { |r| r.body = body.to_json if body }
+                 when :patch
+                   @conn.patch(path) { |r| r.body = body.to_json if body }
+                 else
+                   raise RequestError, "Unsupported HTTP method: #{method}"
+                 end
+
+      parse_response(response)
+    rescue Faraday::UnauthorizedError => e
+      raise AuthenticationError.new(
+        "Unauthorized - check API key and secret",
+        status_code: 401,
+        response_body: extract_error_body(e)
+      )
+    rescue Faraday::ResourceNotFound => e
+      raise NotFoundError.new(
+        "Resource not found: #{path}",
+        status_code: 404,
+        response_body: extract_error_body(e)
+      )
+    rescue Faraday::BadRequestError => e
+      raise BadRequestError.new(
+        "Bad request: #{extract_error_message(e)}",
+        status_code: 400,
+        response_body: extract_error_body(e)
+      )
+    rescue Faraday::ServerError => e
+      raise ServerError.new(
+        "Server error: #{extract_error_message(e)}",
+        status_code: e.response&.dig(:status) || 500,
+        response_body: extract_error_body(e)
+      )
+    rescue Faraday::ClientError => e
+      raise RequestError.new(
+        "API request failed: #{extract_error_message(e)}",
+        status_code: e.response&.dig(:status),
+        response_body: extract_error_body(e)
+      )
+    end # request
+
+    def extract_error_body(error)
+      error.response&.dig(:body)
+    end # extract_error_body
+
+    def extract_error_message(error)
+      body = extract_error_body(error)
+      return error.message unless body
+
+      begin
+        parsed = JSON.parse(body)
+        parsed["message"] || parsed["error"] || body
+      rescue JSON::ParserError
+        body
+      end
+    end # extract_error_message
+
+    def parse_response(response)
+      return {} if response.body.nil? || response.body.empty?
+
+      begin
+        data = JSON.parse(response.body)
+      rescue JSON::ParserError
+        raise InvalidResponseError, "Response is not valid JSON"
+      end
+
+      if response.status >= 400
+        raise RequestError, "API error: #{data}"
+      end
+
+      data
+    end # parse_response
+  end # class Base
+end # module ProxyCheapClient

data/lib/proxy_cheap_client/models/configuration.rb

@@ -0,0 +1,20 @@
+module ProxyCheapClient
+  #module Models
+    class Configuration < Base
+      attr_reader :data, :price, :currency, :packages, :available, :conn
+
+      def initialize(attrs = {}, client)
+        @data = attrs
+        @price = attrs["price"] || attrs["totalPrice"]
+        @currency = attrs["currency"] || "USD"
+        @packages = attrs["packages"]
+        @available = attrs["available"]
+        @conn = client.conn
+      end
+
+      def to_h
+        data
+      end
+    end
+  #end
+end

data/lib/proxy_cheap_client/models/order.rb

@@ -0,0 +1,57 @@
+module ProxyCheapClient
+  #module Models
+    class Order < Base
+      attr_reader :data, 
+                  :id, 
+                  #:status, 
+                  #:proxies, 
+                  #:created_at, 
+                  :total_price, 
+                  #:currency,
+                  :conn
+
+      def initialize(attrs = {}, client)
+        @data = attrs
+        @id = attrs["id"] || attrs["orderId"]
+        #@status = attrs["status"]
+        #@proxies = attrs["proxies"]
+        #@created_at = attrs["createdAt"] || attrs["created_at"]
+        @total_price = attrs["totalPrice"] || attrs["total_price"]
+        #@currency = attrs["currency"]
+        @conn = client.conn
+      end # initialize
+
+      def to_h
+        {
+          id: id,
+          #status: status,
+          #proxies: proxies,
+          #created_at: created_at,
+          total_price: total_price,
+          #currency: currency
+        }
+      end # to_h
+
+      # Get proxies of an order
+      # @param order_id [String] Order ID
+      # @return [Order]
+      def proxies()
+          order_id = self.id
+          resp = request(:get, "orders/#{order_id}/proxies")
+
+          # The response may be an array or wrapped in a key (e.g. "proxies" or "data").
+          proxy_data = if resp.is_a?(Hash) && resp.key?("proxies")
+                resp["proxies"]
+              elsif resp.is_a?(Hash) && resp.key?("data")
+                resp["data"]
+              else
+                resp
+              end
+
+          Array(proxy_data).map { |p| ProxyCheapClient::Proxy.new(p) }
+      end # proxies
+
+
+    end # class
+  #end # module
+end # module

data/lib/proxy_cheap_client/models/proxy.rb

@@ -0,0 +1,124 @@
+module ProxyCheapClient
+  #module Models
+    class Proxy < Base
+      attr_reader :data, :id, :ip, :port, :type, :expires_at, 
+                  #:auto_renew, :auto_extend,
+                  :country, :isp, :username, :password, :protocol, :bandwidth_limit,
+                  :bandwidth_used, :status, :conn
+
+      def initialize(attrs = {}, client)
+        @data = attrs
+        @id = attrs["id"]
+        @ip = attrs["ip"] || attrs["host"] || (attrs["connection"] && attrs["connection"]['connectIp']) 
+        @port = attrs["port"] || (attrs["connection"] && attrs["connection"]['httpPort'])
+        @type = attrs["type"] || attrs["networkType"] || (attrs["connection"] && attrs["connection"]['ipVersion'])
+        @expires_at = attrs["expiresAt"] || attrs["expires_at"]
+        #@auto_renew = attrs["autoRenew"] || attrs["auto_renew"] || attrs["isAutoExtendEnabled"]
+        #@auto_extend = attrs["isAutoExtendEnabled"] || attrs["autoExtend"]
+        @country = attrs["countryCode"]
+        isp = attrs["metadata"]['ispName']
+        @username = attrs["username"] || (attrs["authentication"] && attrs["authentication"]['username'])
+        @password = attrs["password"] || (attrs["authentication"] && attrs["authentication"]['password'])
+        @protocol = attrs["protocol"] || attrs["proxyProtocol"] || attrs["proxyType"]
+        @bandwidth_limit = attrs["bandwidthLimit"] || attrs["bandwidth_limit"] || (attrs["bandwidth"] && attrs["bandwidth"]['total'])
+        @bandwidth_used = attrs["bandwidthUsed"] || attrs["bandwidth_used"] || (attrs["bandwidth"] && attrs["bandwidth"]['used'])
+        @status = attrs["status"]
+        @conn = client.conn
+      end # def initialize
+
+      def to_h
+        {
+          id: id,
+          ip: ip,
+          port: port,
+          type: type,
+          expires_at: expires_at,
+          #auto_renew: auto_renew,
+          #auto_extend: auto_extend,
+          country: country,
+          isp: isp,
+          username: username,
+          password: password,
+          protocol: protocol,
+          bandwidth_limit: bandwidth_limit,
+          bandwidth_used: bandwidth_used,
+          status: status
+        }
+      end # to_h
+=begin
+      # Change whitelisted IPs for a proxy.
+      # @note The official API uses GET with request body for this operation.
+      # @param proxy_id [Integer] Proxy ID
+      # @param ips [Array<String>] List of IPs to whitelist
+      # @return [Hash] API response
+      def whitelist(proxy_id, ips = [])
+        request(:get, "proxies/#{proxy_id}/whitelist-ip", { ips: ips })
+      end
+
+      # Extend a proxy period.
+      # @note The official API uses GET with request body for this operation.
+      # @param proxy_id [Integer] Proxy ID
+      # @param months [Integer] Number of months to extend (minimum 1)
+      # @return [Hash] API response
+      def extend_period(proxy_id, months)
+        raise ArgumentError, "You must extend for at least 1 month" unless months && months >= 1
+        request(:get, "proxies/#{proxy_id}/extend-period", { periodInMonths: months })
+      end
+
+      # Buy additional bandwidth for a proxy.
+      # @note The official API uses GET with request body for this operation.
+      # @param proxy_id [Integer] Proxy ID
+      # @param bandwidth_gb [Integer] Amount of bandwidth in GB (minimum 1)
+      # @return [Hash] API response
+      def buy_bandwidth(proxy_id, bandwidth_gb)
+        raise ArgumentError, "You must buy at least 1 GB" unless bandwidth_gb && bandwidth_gb >= 1
+        request(:get, "proxies/#{proxy_id}/buy-bandwidth", { bandwidth: bandwidth_gb })
+      end
+=end
+      # Get info on a specific proxy.
+      # @param proxy_id [Integer] Proxy ID
+      # @return [Proxy]
+      def self.load(proxy_id)
+        resp = request(:get, "proxies/#{proxy_id}")
+        Proxy.new(resp)
+      end # proxy
+=begin
+      def auto_extend?
+        !!@data.dig("autoExtend", "isEnabled")
+      end
+
+      def get_name
+        @data["name"]
+      end
+
+      def set_name(name)
+        response = @conn.patch("proxies/#{@data['id']}") do |req|
+          req.headers['Content-Type'] = 'application/json'
+          req.body = { name: name }.to_json
+        end
+        if response.success?
+          @data["name"] = name
+        else
+          raise "Failed to set proxy name (HTTP #{response.status})"
+        end
+      end
+=end
+      # Enable auto-extend for a proxy.
+      # @param proxy_id [Integer] Proxy ID
+      # @return [Hash] API response
+      def enable_auto_extend()
+        proxy_id = self.id
+        request(:post, "proxies/#{proxy_id}/auto-extend/enable")
+      end # enable_auto_extend
+
+      # Disable auto-extend for a proxy.
+      # @param proxy_id [Integer] Proxy ID
+      # @return [Hash] API response
+      def disable_auto_extend()
+        proxy_id = self.id
+        request(:post, "proxies/#{proxy_id}/auto-extend/disable")
+      end # disable_auto_extend
+
+    end # Proxy
+  #end # Model
+end

data/lib/proxy_cheap_client/version.rb

@@ -0,0 +1,3 @@
+module ProxyCheapClient
+  VERSION = "1.0.1"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: proxy-cheap-client
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Leandro Sardi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2025-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Manage balance, proxies, auto-extend, and order proxies via the Proxy-Cheap
+  API.
+email:
+- leandro@massprospecting.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/proxy-cheap-client.rb
+- lib/proxy_cheap_client/client.rb
+- lib/proxy_cheap_client/errors.rb
+- lib/proxy_cheap_client/models/balance.rb
+- lib/proxy_cheap_client/models/base.rb
+- lib/proxy_cheap_client/models/configuration.rb
+- lib/proxy_cheap_client/models/order.rb
+- lib/proxy_cheap_client/models/proxy.rb
+- lib/proxy_cheap_client/version.rb
+homepage: https://github.com/massprospecting/proxy-cheap-client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: Ruby client for Proxy-Cheap.com API
+test_files: []