apiverve_permutationcombination 1.2.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93092a01f70164da689c80561eb65b7178508e141cd8ba871c0bb97ce1775059
-  data.tar.gz: c2094b8dcab7d45a47adb912a8e22de581bf8852cee16a20497c88d1912b7899
+  metadata.gz: 8aed762a982cccc2864c047c0113fe50a7b7105eba4daf152c12d8b64c88dd98
+  data.tar.gz: 5bed56a37d6fccc4cf7f5ab70e0da8722298b913f508cd800f61e9e226ff7442
 SHA512:
-  metadata.gz: e8595e00a82fda356e87b4cf996d2393bd0e72a9a0c8de3b749f033e16c18e2357514eb1955fbdaaede9ca7756136e9b3e1748161aaf8392189b755281f8007f
-  data.tar.gz: 8a93cd5b097ea47bfe8f6bc6eafd2f9d0a09512421e904a0c00a3610d7a15f0ed0ea730cdad7f16cd626dbfb2831a4db3b64467fbafb295955a7b80906c986d8
+  metadata.gz: 236aa91fdcc41f0686c940e149272182223bc8045c1e2c757a333d472ca72472c097df542de2f0a71c5d5612912ab86fd8ec93da4be19c5a48b0987535c80ce1
+  data.tar.gz: d7393a3761734a4e31a03076838b452ef6d4896e543ddefadb5fc6d5399ce6dda6928f552038020887fcc307aab358365723291e93279ae80b06f7824b0da913

data/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) {{year}} APIVerve
-
-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.
+MIT License
+
+Copyright (c) 2026 APIVerve and EvlarSoft LLC
+
+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

@@ -1,77 +1,77 @@
-# Permutation & Combination Calculator API - Ruby Gem
-
-Calculate permutations (P(n,r)) and combinations (C(n,r)) for any given values of n and r.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'apiverve_permutationcombination'
-```
-
-And then execute:
-
-```bash
-$ bundle install
-```
-
-Or install it yourself as:
-
-```bash
-$ gem install apiverve_permutationcombination
-```
-
-## Getting Started
-
-Get your API key at [APIVerve](https://apiverve.com)
-
-### Basic Usage
-
-```ruby
-require 'apiverve_permutationcombination'
-
-# Initialize the client
-client = APIVerve::Permutationcombination::Client.new(api_key: "YOUR_API_KEY")
-
-# Make a request
-response = client.execute({
+# Permutation & Combination Calculator API - Ruby Gem
+
+Calculate permutations (P(n,r)) and combinations (C(n,r)) for any given values of n and r.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'apiverve_permutationcombination'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install apiverve_permutationcombination
+```
+
+## Getting Started
+
+Get your API key at [APIVerve](https://apiverve.com)
+
+### Basic Usage
+
+```ruby
+require 'apiverve_permutationcombination'
+
+# Initialize the client
+client = APIVerve::Permutationcombination::Client.new(api_key: "YOUR_API_KEY")
+
+# Make a request
+response = client.execute({
   n: 10,
-  r: 3
-})
-
-# Print the response
-puts response
-```
-
-
-### Error Handling
-
-```ruby
-begin
-  response = client.execute({ n: 10, r: 3 })
-  puts response["data"]
-rescue APIVerve::Permutationcombination::ValidationError => e
-  puts "Validation error: #{e.errors.join(', ')}"
-rescue APIVerve::Permutationcombination::APIError => e
-  puts "API error: #{e.message}"
-  puts "Status code: #{e.status_code}"
-end
-```
-
-### Debug Mode
-
-```ruby
-# Enable debug logging
-client = APIVerve::Permutationcombination::Client.new(
-  api_key: "YOUR_API_KEY",
-  debug: true
-)
-```
-
-## Example Response
-
-```json
+  r: 3
+})
+
+# Print the response
+puts response
+```
+
+
+### Error Handling
+
+```ruby
+begin
+  response = client.execute({ n: 10, r: 3 })
+  puts response["data"]
+rescue APIVerve::Permutationcombination::ValidationError => e
+  puts "Validation error: #{e.errors.join(', ')}"
+rescue APIVerve::Permutationcombination::APIError => e
+  puts "API error: #{e.message}"
+  puts "Status code: #{e.status_code}"
+end
+```
+
+### Debug Mode
+
+```ruby
+# Enable debug logging
+client = APIVerve::Permutationcombination::Client.new(
+  api_key: "YOUR_API_KEY",
+  debug: true
+)
+```
+
+## Example Response
+
+```json
 {
   "status": "ok",
   "error": null,
@@ -85,18 +85,18 @@ client = APIVerve::Permutationcombination::Client.new(
       "combination": "C(n,r) = n! / (r! × (n-r)!)"
     }
   }
-}
-```
-
-## Documentation
-
-For more information, visit the [API Documentation](https://docs.apiverve.com/ref/permutationcombination?utm_source=rubygems&utm_medium=readme).
-
-## Support
-
-- Website: [https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=readme](https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=readme)
-- Email: hello@apiverve.com
-
-## License
-
-This gem is available under the [MIT License](LICENSE).
+}
+```
+
+## Documentation
+
+For more information, visit the [API Documentation](https://docs.apiverve.com/ref/permutationcombination?utm_source=rubygems&utm_medium=referral&utm_content=readme).
+
+## Support
+
+- Website: [https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=referral&utm_content=readme](https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=referral&utm_content=readme)
+- Email: hello@apiverve.com
+
+## License
+
+This gem is available under the [MIT License](LICENSE).

data/lib/apiverve_permutationcombination/client.rb

@@ -1,187 +1,184 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "faraday/multipart"
-require "json"
-
-module APIVerve
-  module Permutationcombination
-    # Client for the Permutation & Combination Calculator API
-    #
-    # @example Basic usage
-    #   client = APIVerve::Permutationcombination::Client.new(api_key: "your_api_key")
-    #   response = client.execute({ n: 10, r: 3 })
-    #   puts response
-    #
-    # @see https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=readme
-    class Client
-      BASE_URL = "https://api.apiverve.com/v1/permutationcombination"
-      DEFAULT_TIMEOUT = 30
-
-      # Validation rules for parameters
-      VALIDATION_RULES = {
-      'n' => { type: 'integer', required: true, min: 0, max: 170 },
-      'r' => { type: 'integer', required: true, min: 0, max: 170 }
-    }
-
-      # Format validation patterns
-      FORMAT_PATTERNS = {
-        'email' => /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
-        'url' => /^https?:\/\/.+/,
-        'ip' => /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/,
-        'date' => /^\d{4}-\d{2}-\d{2}$/,
-        'hexColor' => /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/
-      }.freeze
-
-      # Initialize the client
-      #
-      # @param api_key [String] Your APIVerve API key
-      # @param timeout [Integer] Request timeout in seconds (default: 30)
-      # @param debug [Boolean] Enable debug logging (default: false)
-      # @raise [ArgumentError] If API key is invalid
-      def initialize(api_key:, timeout: DEFAULT_TIMEOUT, debug: false)
-        validate_api_key!(api_key)
-
-        @api_key = api_key
-        @timeout = timeout
-        @debug = debug
-
-        @connection = Faraday.new(url: BASE_URL) do |conn|
-          conn.request :multipart
-          conn.request :url_encoded
-          conn.adapter Faraday.default_adapter
-          conn.options.timeout = @timeout
-          conn.headers["x-api-key"] = @api_key
-          conn.headers["auth-mode"] = "rubygems-package"
-          conn.headers["Content-Type"] = "application/json"
-        end
-      end
-
-      # Execute the API request
-      #
-      # @param params [Hash] Query parameters or request body
-      # @return [Hash] API response
-      # @raise [APIError] If the request fails
-      # @raise [ValidationError] If parameter validation fails
-      def execute(params = {})
-        validate_params!(params)
-
-        log("Making GET request to #{BASE_URL}")
-        log("Parameters: #{params.inspect}") if params.any?
-
-        response = @connection.get do |req|
-          params.each { |k, v| req.params[k.to_s] = v }
-        end
-
-        handle_response(response)
-      end
-
-      private
-
-      def validate_api_key!(api_key)
-        raise ArgumentError, "API key is required. Get your API key at: https://apiverve.com" if api_key.nil? || api_key.strip.empty?
-
-        unless api_key.match?(/^[a-zA-Z0-9_-]+$/)
-          raise ArgumentError, "Invalid API key format. API key should only contain letters, numbers, hyphens, and underscores."
-        end
-      end
-
-      def validate_params!(params)
-        return if VALIDATION_RULES.empty?
-
-        errors = []
-
-        VALIDATION_RULES.each do |param_name, rules|
-          value = params[param_name.to_sym] || params[param_name]
-
-          # Check required
-          if rules[:required] && (value.nil? || value.to_s.empty?)
-            errors << "Required parameter [#{param_name}] is missing."
-            next
-          end
-
-          next if value.nil?
-
-          case rules[:type]
-          when "integer", "number"
-            begin
-              num_value = rules[:type] == "number" ? Float(value) : Integer(value)
-              errors << "Parameter [#{param_name}] must be at least #{rules[:min]}." if rules[:min] && num_value < rules[:min]
-              errors << "Parameter [#{param_name}] must be at most #{rules[:max]}." if rules[:max] && num_value > rules[:max]
-            rescue ArgumentError, TypeError
-              errors << "Parameter [#{param_name}] must be a valid #{rules[:type]}."
-            end
-          when "string"
-            unless value.is_a?(String)
-              errors << "Parameter [#{param_name}] must be a string."
-              next
-            end
-            errors << "Parameter [#{param_name}] must be at least #{rules[:min_length]} characters." if rules[:min_length] && value.length < rules[:min_length]
-            errors << "Parameter [#{param_name}] must be at most #{rules[:max_length]} characters." if rules[:max_length] && value.length > rules[:max_length]
-
-            if rules[:format] && FORMAT_PATTERNS[rules[:format]]
-              unless value.match?(FORMAT_PATTERNS[rules[:format]])
-                errors << "Parameter [#{param_name}] must be a valid #{rules[:format]}."
-              end
-            end
-          when "boolean"
-            unless [true, false, "true", "false"].include?(value)
-              errors << "Parameter [#{param_name}] must be a boolean."
-            end
-          end
-
-          # Enum validation
-          if rules[:enum] && !rules[:enum].include?(value)
-            errors << "Parameter [#{param_name}] must be one of: #{rules[:enum].join(', ')}."
-          end
-        end
-
-        raise ValidationError, errors unless errors.empty?
-      end
-
-      def handle_response(response)
-        log("Response status: #{response.status}")
-
-        data = JSON.parse(response.body)
-
-        if data["status"] == "error"
-          raise APIError.new(data["error"] || "Unknown API error", response.status, data)
-        end
-
-        unless response.success?
-          raise APIError.new(data["error"] || "HTTP #{response.status} error", response.status, data)
-        end
-
-        log("Request successful")
-        data
-      rescue JSON::ParserError => e
-        raise APIError.new("Invalid JSON response: #{e.message}", response.status)
-      end
-
-      def log(message)
-        puts "[APIVerve::Permutationcombination] #{message}" if @debug
-      end
-    end
-
-    # Custom error class for API errors
-    class APIError < StandardError
-      attr_reader :status_code, :response
-
-      def initialize(message, status_code = nil, response = nil)
-        @status_code = status_code
-        @response = response
-        super(message)
-      end
-    end
-
-    # Custom error class for validation errors
-    class ValidationError < StandardError
-      attr_reader :errors
-
-      def initialize(errors)
-        @errors = errors
-        super("Validation failed: #{errors.join(' ')}")
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "json"
+
+module APIVerve
+  module Permutationcombination
+    # Client for the Permutation & Combination Calculator API
+    #
+    # @example Basic usage
+    #   client = APIVerve::Permutationcombination::Client.new(api_key: "your_api_key")
+    #   response = client.execute({ n: 10, r: 3 })
+    #   puts response
+    #
+    # @see https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=referral&utm_content=readme
+    class Client
+      BASE_URL = "https://api.apiverve.com/v1/permutationcombination"
+      DEFAULT_TIMEOUT = 30
+
+      # Validation rules for parameters
+      VALIDATION_RULES = { 'n' => { type: 'integer', required: true, min: 0, max: 170 }, 'r' => { type: 'integer', required: true, min: 0, max: 170 } }
+
+      # Format validation patterns
+      FORMAT_PATTERNS = {
+        'email' => /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+        'url' => /^https?:\/\/.+/,
+        'ip' => /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/,
+        'date' => /^\d{4}-\d{2}-\d{2}$/,
+        'hexColor' => /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/
+      }.freeze
+
+      # Initialize the client
+      #
+      # @param api_key [String] Your APIVerve API key
+      # @param timeout [Integer] Request timeout in seconds (default: 30)
+      # @param debug [Boolean] Enable debug logging (default: false)
+      # @raise [ArgumentError] If API key is invalid
+      def initialize(api_key:, timeout: DEFAULT_TIMEOUT, debug: false)
+        validate_api_key!(api_key)
+
+        @api_key = api_key
+        @timeout = timeout
+        @debug = debug
+
+        @connection = Faraday.new(url: BASE_URL) do |conn|
+          conn.request :multipart
+          conn.request :url_encoded
+          conn.adapter Faraday.default_adapter
+          conn.options.timeout = @timeout
+          conn.headers["x-api-key"] = @api_key
+          conn.headers["auth-mode"] = "rubygems-package"
+          conn.headers["Content-Type"] = "application/json"
+        end
+      end
+
+      # Execute the API request
+      #
+      # @param params [Hash] Query parameters or request body
+      # @return [Hash] API response
+      # @raise [APIError] If the request fails
+      # @raise [ValidationError] If parameter validation fails
+      def execute(params = {})
+        validate_params!(params)
+
+        log("Making GET request to #{BASE_URL}")
+        log("Parameters: #{params.inspect}") if params.any?
+
+        response = @connection.get do |req|
+          params.each { |k, v| req.params[k.to_s] = v }
+        end
+
+        handle_response(response)
+      end
+
+      private
+
+      def validate_api_key!(api_key)
+        raise ArgumentError, "API key is required. Get your API key at: https://apiverve.com" if api_key.nil? || api_key.strip.empty?
+
+        unless api_key.match?(/^[a-zA-Z0-9_-]+$/)
+          raise ArgumentError, "Invalid API key format. API key should only contain letters, numbers, hyphens, and underscores."
+        end
+      end
+
+      def validate_params!(params)
+        return if VALIDATION_RULES.empty?
+
+        errors = []
+
+        VALIDATION_RULES.each do |param_name, rules|
+          value = params[param_name.to_sym] || params[param_name]
+
+          # Check required
+          if rules[:required] && (value.nil? || value.to_s.empty?)
+            errors << "Required parameter [#{param_name}] is missing."
+            next
+          end
+
+          next if value.nil?
+
+          case rules[:type]
+          when "integer", "number"
+            begin
+              num_value = rules[:type] == "number" ? Float(value) : Integer(value)
+              errors << "Parameter [#{param_name}] must be at least #{rules[:min]}." if rules[:min] && num_value < rules[:min]
+              errors << "Parameter [#{param_name}] must be at most #{rules[:max]}." if rules[:max] && num_value > rules[:max]
+            rescue ArgumentError, TypeError
+              errors << "Parameter [#{param_name}] must be a valid #{rules[:type]}."
+            end
+          when "string"
+            unless value.is_a?(String)
+              errors << "Parameter [#{param_name}] must be a string."
+              next
+            end
+            errors << "Parameter [#{param_name}] must be at least #{rules[:min_length]} characters." if rules[:min_length] && value.length < rules[:min_length]
+            errors << "Parameter [#{param_name}] must be at most #{rules[:max_length]} characters." if rules[:max_length] && value.length > rules[:max_length]
+
+            if rules[:format] && FORMAT_PATTERNS[rules[:format]]
+              unless value.match?(FORMAT_PATTERNS[rules[:format]])
+                errors << "Parameter [#{param_name}] must be a valid #{rules[:format]}."
+              end
+            end
+          when "boolean"
+            unless [true, false, "true", "false"].include?(value)
+              errors << "Parameter [#{param_name}] must be a boolean."
+            end
+          end
+
+          # Enum validation
+          if rules[:enum] && !rules[:enum].include?(value)
+            errors << "Parameter [#{param_name}] must be one of: #{rules[:enum].join(', ')}."
+          end
+        end
+
+        raise ValidationError, errors unless errors.empty?
+      end
+
+      def handle_response(response)
+        log("Response status: #{response.status}")
+
+        data = JSON.parse(response.body)
+
+        if data["status"] == "error"
+          raise APIError.new(data["error"] || "Unknown API error", response.status, data)
+        end
+
+        unless response.success?
+          raise APIError.new(data["error"] || "HTTP #{response.status} error", response.status, data)
+        end
+
+        log("Request successful")
+        data
+      rescue JSON::ParserError => e
+        raise APIError.new("Invalid JSON response: #{e.message}", response.status)
+      end
+
+      def log(message)
+        puts "[APIVerve::Permutationcombination] #{message}" if @debug
+      end
+    end
+
+    # Custom error class for API errors
+    class APIError < StandardError
+      attr_reader :status_code, :response
+
+      def initialize(message, status_code = nil, response = nil)
+        @status_code = status_code
+        @response = response
+        super(message)
+      end
+    end
+
+    # Custom error class for validation errors
+    class ValidationError < StandardError
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+        super("Validation failed: #{errors.join(' ')}")
+      end
+    end
+  end
+end

data/lib/apiverve_permutationcombination.rb

@@ -1,9 +1,9 @@
-# frozen_string_literal: true
-
-require_relative "apiverve_permutationcombination/client"
-
-module APIVerve
-  module Permutationcombination
-    VERSION = "1.2.0"
-  end
-end
+# frozen_string_literal: true
+
+require_relative "apiverve_permutationcombination/client"
+
+module APIVerve
+  module Permutationcombination
+    VERSION = "1.2.2"
+  end
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: apiverve_permutationcombination
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.2
 platform: ruby
 authors:
 - APIVerve
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -67,17 +68,17 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- lib/apiverve/client.rb
 - lib/apiverve_permutationcombination.rb
 - lib/apiverve_permutationcombination/client.rb
-homepage: https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=homepage
+homepage: https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=referral&utm_content=homepage
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=homepage
+  homepage_uri: https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=referral&utm_content=homepage
   source_code_uri: https://github.com/apiverve/permutationcombination-API/tree/main/ruby
   changelog_uri: https://apiverve.com/changelog
   documentation_uri: https://docs.apiverve.com/ref/permutationcombination
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -92,7 +93,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Permutation & Combination Calculator API - Ruby Client
 test_files: []

data/lib/apiverve/client.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "faraday/multipart"
-require "json"
-
-module APIVerve
-  module Permutationcombination
-    # Client for the Permutation & Combination Calculator API
-    #
-    # @example Basic usage
-    #   client = APIVerve::Permutationcombination::Client.new(api_key: "your_api_key")
-    #   response = client.execute({ n: 10, r: 3 })
-    #   puts response
-    #
-    # @see https://apiverve.com/marketplace/permutationcombination?utm_source=ruby&utm_medium=readme
-    class Client
-      BASE_URL = "https://api.apiverve.com/v1/permutationcombination"
-      DEFAULT_TIMEOUT = 30
-
-      # Validation rules for parameters
-      VALIDATION_RULES = { 'n' => { type: 'integer', required: true, min: 0, max: 170 }, 'r' => { type: 'integer', required: true, min: 0, max: 170 } }
-
-      # Format validation patterns
-      FORMAT_PATTERNS = {
-        'email' => /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
-        'url' => /^https?:\/\/.+/,
-        'ip' => /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/,
-        'date' => /^\d{4}-\d{2}-\d{2}$/,
-        'hexColor' => /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/
-      }.freeze
-
-      # Initialize the client
-      #
-      # @param api_key [String] Your APIVerve API key
-      # @param timeout [Integer] Request timeout in seconds (default: 30)
-      # @param debug [Boolean] Enable debug logging (default: false)
-      # @raise [ArgumentError] If API key is invalid
-      def initialize(api_key:, timeout: DEFAULT_TIMEOUT, debug: false)
-        validate_api_key!(api_key)
-
-        @api_key = api_key
-        @timeout = timeout
-        @debug = debug
-
-        @connection = Faraday.new(url: BASE_URL) do |conn|
-          conn.request :multipart
-          conn.request :url_encoded
-          conn.adapter Faraday.default_adapter
-          conn.options.timeout = @timeout
-          conn.headers["x-api-key"] = @api_key
-          conn.headers["auth-mode"] = "rubygems-package"
-          conn.headers["Content-Type"] = "application/json"
-        end
-      end
-
-      # Execute the API request
-      #
-      # @param params [Hash] Query parameters or request body
-      # @return [Hash] API response
-      # @raise [APIError] If the request fails
-      # @raise [ValidationError] If parameter validation fails
-      def execute(params = {})
-        validate_params!(params)
-
-        log("Making GET request to #{BASE_URL}")
-        log("Parameters: #{params.inspect}") if params.any?
-
-        response = @connection.get do |req|
-          params.each { |k, v| req.params[k.to_s] = v }
-        end
-
-        handle_response(response)
-      end
-
-      private
-
-      def validate_api_key!(api_key)
-        raise ArgumentError, "API key is required. Get your API key at: https://apiverve.com" if api_key.nil? || api_key.strip.empty?
-
-        unless api_key.match?(/^[a-zA-Z0-9_-]+$/)
-          raise ArgumentError, "Invalid API key format. API key should only contain letters, numbers, hyphens, and underscores."
-        end
-      end
-
-      def validate_params!(params)
-        return if VALIDATION_RULES.empty?
-
-        errors = []
-
-        VALIDATION_RULES.each do |param_name, rules|
-          value = params[param_name.to_sym] || params[param_name]
-
-          # Check required
-          if rules[:required] && (value.nil? || value.to_s.empty?)
-            errors << "Required parameter [#{param_name}] is missing."
-            next
-          end
-
-          next if value.nil?
-
-          case rules[:type]
-          when "integer", "number"
-            begin
-              num_value = rules[:type] == "number" ? Float(value) : Integer(value)
-              errors << "Parameter [#{param_name}] must be at least #{rules[:min]}." if rules[:min] && num_value < rules[:min]
-              errors << "Parameter [#{param_name}] must be at most #{rules[:max]}." if rules[:max] && num_value > rules[:max]
-            rescue ArgumentError, TypeError
-              errors << "Parameter [#{param_name}] must be a valid #{rules[:type]}."
-            end
-          when "string"
-            unless value.is_a?(String)
-              errors << "Parameter [#{param_name}] must be a string."
-              next
-            end
-            errors << "Parameter [#{param_name}] must be at least #{rules[:min_length]} characters." if rules[:min_length] && value.length < rules[:min_length]
-            errors << "Parameter [#{param_name}] must be at most #{rules[:max_length]} characters." if rules[:max_length] && value.length > rules[:max_length]
-
-            if rules[:format] && FORMAT_PATTERNS[rules[:format]]
-              unless value.match?(FORMAT_PATTERNS[rules[:format]])
-                errors << "Parameter [#{param_name}] must be a valid #{rules[:format]}."
-              end
-            end
-          when "boolean"
-            unless [true, false, "true", "false"].include?(value)
-              errors << "Parameter [#{param_name}] must be a boolean."
-            end
-          end
-
-          # Enum validation
-          if rules[:enum] && !rules[:enum].include?(value)
-            errors << "Parameter [#{param_name}] must be one of: #{rules[:enum].join(', ')}."
-          end
-        end
-
-        raise ValidationError, errors unless errors.empty?
-      end
-
-      def handle_response(response)
-        log("Response status: #{response.status}")
-
-        data = JSON.parse(response.body)
-
-        if data["status"] == "error"
-          raise APIError.new(data["error"] || "Unknown API error", response.status, data)
-        end
-
-        unless response.success?
-          raise APIError.new(data["error"] || "HTTP #{response.status} error", response.status, data)
-        end
-
-        log("Request successful")
-        data
-      rescue JSON::ParserError => e
-        raise APIError.new("Invalid JSON response: #{e.message}", response.status)
-      end
-
-      def log(message)
-        puts "[APIVerve::Permutationcombination] #{message}" if @debug
-      end
-    end
-
-    # Custom error class for API errors
-    class APIError < StandardError
-      attr_reader :status_code, :response
-
-      def initialize(message, status_code = nil, response = nil)
-        @status_code = status_code
-        @response = response
-        super(message)
-      end
-    end
-
-    # Custom error class for validation errors
-    class ValidationError < StandardError
-      attr_reader :errors
-
-      def initialize(errors)
-        @errors = errors
-        super("Validation failed: #{errors.join(' ')}")
-      end
-    end
-  end
-end