avalara_sdk 24.2.29 → 24.12.0

data/vendor/bundle/ruby/2.7.0/gems/faraday-multipart-1.1.0/README.md

@@ -0,0 +1,170 @@
+# Faraday Multipart
+
+[![ci](https://github.com/lostisland/faraday-multipart/actions/workflows/ci.yaml/badge.svg)](https://github.com/lostisland/faraday-multipart/actions/workflows/ci.yaml)
+[![Gem](https://img.shields.io/gem/v/faraday-multipart.svg?style=flat-square)](https://rubygems.org/gems/faraday-multipart)
+[![License](https://img.shields.io/github/license/lostisland/faraday-multipart.svg?style=flat-square)](LICENSE.md)
+
+The `Multipart` middleware converts a `Faraday::Request#body` Hash of key/value pairs into a multipart form request, but
+only under these conditions:
+
+* The request's Content-Type is "multipart/form-data"
+* Content-Type is unspecified, AND one of the values in the Body responds to
+  `#content_type`.
+
+Faraday contains a couple helper classes for multipart values:
+
+* `Faraday::Multipart::FilePart` wraps binary file data with a Content-Type. The file data can be specified with a String path to a
+  local file, or an IO object.
+* `Faraday::Multipart::ParamPart` wraps a String value with a Content-Type, and optionally a Content-ID.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'faraday-multipart'
+```
+
+And then execute:
+
+```shell
+bundle install
+```
+
+Or install it yourself as:
+
+```shell
+gem install faraday-multipart
+```
+
+## Usage
+
+First of all, you'll need to add the multipart middleware to your Faraday connection:
+
+```ruby
+require 'faraday'
+require 'faraday/multipart'
+
+conn = Faraday.new(...) do |f|
+  f.request :multipart, **options
+  # ...
+end
+```
+
+If you need to [specify a different content type for the multipart
+request](https://www.iana.org/assignments/media-types/media-types.xhtml#multipart),
+you can do so by providing the `content_type` option but it must start with
+`multipart/`
+otherwise it will default to `multipart/form-data`:
+
+```ruby
+conn = Faraday.new(...) do |f|
+  f.request :multipart, content_type: 'multipart/mixed'
+  # ...
+end
+```
+
+Payload can be a mix of POST data and multipart values.
+
+```ruby
+# regular POST form value
+payload = { string: 'value' }
+
+# filename for this value is File.basename(__FILE__)
+payload[:file] = Faraday::Multipart::FilePart.new(__FILE__, 'text/x-ruby')
+
+# specify filename because IO object doesn't know it
+payload[:file_with_name] = Faraday::Multipart::FilePart.new(
+  File.open(__FILE__),
+  'text/x-ruby',
+  File.basename(__FILE__)
+)
+
+# Sets a custom Content-Disposition:
+# nil filename still defaults to File.basename(__FILE__)
+payload[:file_with_header] = Faraday::Multipart::FilePart.new(
+  __FILE__,
+  'text/x-ruby',
+  nil,
+  'Content-Disposition' => 'form-data; foo=1'
+)
+
+# Upload raw json with content type
+payload[:raw_data] = Faraday::Multipart::ParamPart.new(
+  { a: 1 }.to_json,
+  'application/json'
+)
+
+# optionally sets Content-ID too
+payload[:raw_with_id] = Faraday::Multipart::ParamPart.new(
+  { a: 1 }.to_json,
+  'application/json',
+  'foo-123'
+)
+
+conn.post('/', payload)
+```
+
+### Sending an array of documents
+
+Sometimes, the server you're calling will expect an array of documents or other values for the same key.
+The `multipart` middleware will automatically handle this scenario for you:
+
+```ruby
+payload = {
+  files: [
+    Faraday::Multipart::FilePart.new(__FILE__, 'text/x-ruby'),
+    Faraday::Multipart::FilePart.new(__FILE__, 'text/x-pdf')
+  ],
+  url: [
+    'http://mydomain.com/callback1',
+    'http://mydomain.com/callback2'
+  ]
+}
+
+conn.post(url, payload)
+#=> POST url[]=http://mydomain.com/callback1&url[]=http://mydomain.com/callback2
+#=>   and includes both files in the request under the `files[]` name
+```
+
+However, by default these will be sent with `files[]` key and the URLs with `url[]`, similarly to arrays in URL parameters.
+Some servers (e.g. Mailgun) expect each document to have the same parameter key instead.
+You can instruct the `multipart` middleware to do so by providing the `flat_encode` option:
+
+```ruby
+require 'faraday'
+require 'faraday/multipart'
+
+conn = Faraday.new(...) do |f|
+  f.request :multipart, flat_encode: true
+  # ...
+end
+
+payload = ... # see example above
+
+conn.post(url, payload)
+#=> POST url=http://mydomain.com/callback1&url=http://mydomain.com/callback2
+#=>   and includes both files in the request under the `files` name
+```
+
+This works for both `UploadIO` and normal parameters alike.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+
+Then, run `bin/test` to run the tests.
+
+To install this gem onto your local machine, run `rake build`.
+
+### Releasing a new version
+
+To release a new version, make a commit with a message such as "Bumped to 0.0.2", and change the _Unreleased_ heading in `CHANGELOG.md` to a heading like "0.0.2 (2022-01-01)", and then use GitHub Releases to author a release. A GitHub Actions workflow then publishes a new gem to [RubyGems.org](https://rubygems.org/gems/faraday-multipart).
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/lostisland/faraday-multipart).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/vendor/bundle/ruby/2.7.0/gems/faraday-multipart-1.1.0/lib/faraday/multipart/middleware.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Faraday
+  module Multipart
+    # Middleware for supporting multi-part requests.
+    class Middleware < Faraday::Middleware
+      CONTENT_TYPE = 'Content-Type'
+      DEFAULT_BOUNDARY_PREFIX = '-----------RubyMultipartPost'
+
+      def initialize(app = nil, options = {})
+        super(app)
+        @options = options
+      end
+
+      # Checks for files in the payload, otherwise leaves everything untouched.
+      #
+      # @param env [Faraday::Env]
+      def call(env)
+        match_content_type(env) do |params|
+          env.request.boundary ||= unique_boundary
+          env.request_headers[CONTENT_TYPE] +=
+            "; boundary=#{env.request.boundary}"
+          env.body = create_multipart(env, params)
+        end
+        @app.call env
+      end
+
+      private
+
+      # @param env [Faraday::Env]
+      # @yield [request_body] Body of the request
+      def match_content_type(env)
+        return unless process_request?(env)
+
+        env.request_headers[CONTENT_TYPE] ||= mime_type
+        return if env.body.respond_to?(:to_str) || env.body.respond_to?(:read)
+
+        yield(env.body)
+      end
+
+      # @param env [Faraday::Env]
+      def process_request?(env)
+        type = request_type(env)
+        env.body.respond_to?(:each_key) && !env.body.empty? && (
+          (type.empty? && has_multipart?(env.body)) ||
+            (type == mime_type)
+        )
+      end
+
+      # @param env [Faraday::Env]
+      #
+      # @return [String]
+      def request_type(env)
+        type = env.request_headers[CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+
+      # Returns true if obj is an enumerable with values that are multipart.
+      #
+      # @param obj [Object]
+      # @return [Boolean]
+      def has_multipart?(obj)
+        if obj.respond_to?(:each)
+          (obj.respond_to?(:values) ? obj.values : obj).each do |val|
+            return true if val.respond_to?(:content_type) || has_multipart?(val)
+          end
+        end
+        false
+      end
+
+      # @param env [Faraday::Env]
+      # @param params [Hash]
+      def create_multipart(env, params)
+        boundary = env.request.boundary
+        parts = process_params(params) do |key, value|
+          part(boundary, key, value)
+        end
+        parts << Faraday::Multipart::Parts::EpiloguePart.new(boundary)
+
+        body = Faraday::Multipart::CompositeReadIO.new(parts)
+        env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
+        body
+      end
+
+      def part(boundary, key, value)
+        if value.respond_to?(:to_part)
+          value.to_part(boundary, key)
+        else
+          Faraday::Multipart::Parts::Part.new(boundary, key, value)
+        end
+      end
+
+      # @return [String]
+      def unique_boundary
+        "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
+      end
+
+      # @param params [Hash]
+      # @param prefix [String]
+      # @param pieces [Array]
+      def process_params(params, prefix = nil, pieces = nil, &block)
+        params.inject(pieces || []) do |all, (key, value)|
+          if prefix
+            key = @options[:flat_encode] ? prefix.to_s : "#{prefix}[#{key}]"
+          end
+
+          case value
+          when Array
+            values = value.inject([]) { |a, v| a << [nil, v] }
+            process_params(values, key, all, &block)
+          when Hash
+            process_params(value, key, all, &block)
+          else
+            all << block.call(key, value) # rubocop:disable Performance/RedundantBlockCall
+          end
+        end
+      end
+
+      # Determines and provides the multipart mime type for the request.
+      #
+      # @return [String] the multipart mime type
+      def mime_type
+        @mime_type ||= if @options[:content_type].to_s.match?(%r{\Amultipart/.+})
+                         @options[:content_type].to_s
+                       else
+                         'multipart/form-data'
+                       end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/faraday-multipart-1.1.0/lib/faraday/multipart/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Faraday
+  # #:nodoc:
+  module Multipart
+    VERSION = '1.1.0'
+
+    def self.multipart_post_version
+      require 'multipart/post/version'
+      ::Gem::Version.new(::Multipart::Post::VERSION)
+    rescue LoadError
+      require 'multipart_post'
+      ::Gem::Version.new(::MultipartPost::VERSION)
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/faraday-net_http-1.0.2/lib/faraday/adapter/net_http.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+begin
+  require 'net/https'
+rescue LoadError
+  warn 'Warning: no such file to load -- net/https. ' \
+    'Make sure openssl is installed if you want ssl support'
+  require 'net/http'
+end
+require 'zlib'
+
+module Faraday
+  class Adapter
+    class NetHttp < Faraday::Adapter
+      exceptions = [
+        IOError,
+        Errno::EADDRNOTAVAIL,
+        Errno::ECONNABORTED,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::EHOSTUNREACH,
+        Errno::EINVAL,
+        Errno::ENETUNREACH,
+        Errno::EPIPE,
+        Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError,
+        Net::ProtocolError,
+        SocketError,
+        Zlib::GzipFile::Error
+      ]
+
+      exceptions << ::OpenSSL::SSL::SSLError if defined?(::OpenSSL::SSL::SSLError)
+      exceptions << ::Net::OpenTimeout if defined?(::Net::OpenTimeout)
+
+      NET_HTTP_EXCEPTIONS = exceptions.freeze
+
+      def initialize(app = nil, opts = {}, &block)
+        @ssl_cert_store = nil
+        super(app, opts, &block)
+      end
+
+      def build_connection(env)
+        net_http_connection(env).tap do |http|
+          configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' && env[:ssl]
+          configure_request(http, env[:request])
+        end
+      end
+
+      def net_http_connection(env)
+        proxy = env[:request][:proxy]
+        port = env[:url].port || (env[:url].scheme == 'https' ? 443 : 80)
+        if proxy
+          Net::HTTP.new(env[:url].hostname, port,
+                        proxy[:uri].hostname, proxy[:uri].port,
+                        proxy[:user], proxy[:password])
+        else
+          Net::HTTP.new(env[:url].hostname, port, nil)
+        end
+      end
+
+      def call(env)
+        super
+        http_response = connection(env) do |http|
+          begin
+            perform_request(http, env)
+          rescue *NET_HTTP_EXCEPTIONS => e
+            raise Faraday::SSLError, e if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
+
+            raise Faraday::ConnectionFailed, e
+          end
+        end
+
+        save_response(env, http_response.code.to_i,
+                      http_response.body || +'', nil,
+                      http_response.message) do |response_headers|
+          http_response.each_header do |key, value|
+            response_headers[key] = value
+          end
+        end
+
+        @app.call env
+      rescue Timeout::Error, Errno::ETIMEDOUT => e
+        raise Faraday::TimeoutError, e
+      end
+
+      private
+
+      def create_request(env)
+        request = Net::HTTPGenericRequest.new \
+          env[:method].to_s.upcase, # request method
+          !!env[:body], # is there request body
+          env[:method] != :head, # is there response body
+          env[:url].request_uri, # request uri path
+          env[:request_headers] # request headers
+
+        if env[:body].respond_to?(:read)
+          request.body_stream = env[:body]
+        else
+          request.body = env[:body]
+        end
+        request
+      end
+
+      def perform_request(http, env)
+        if env[:request].stream_response?
+          size = 0
+          yielded = false
+          http_response = request_with_wrapped_block(http, env) do |chunk|
+            if chunk.bytesize.positive? || size.positive?
+              yielded = true
+              size += chunk.bytesize
+              env[:request].on_data.call(chunk, size)
+            end
+          end
+          env[:request].on_data.call(+'', 0) unless yielded
+          # Net::HTTP returns something,
+          # but it's not meaningful according to the docs.
+          http_response.body = nil
+          http_response
+        else
+          request_with_wrapped_block(http, env)
+        end
+      end
+
+      def request_with_wrapped_block(http, env, &block)
+        if (env[:method] == :get) && !env[:body]
+          # prefer `get` to `request` because the former handles gzip (ruby 1.9)
+          request_via_get_method(http, env, &block)
+        else
+          request_via_request_method(http, env, &block)
+        end
+      end
+
+      def request_via_get_method(http, env, &block)
+        # Must use Net::HTTP#start and pass it a block otherwise the server's
+        # TCP socket does not close correctly.
+        http.start do |opened_http|
+          opened_http.get env[:url].request_uri, env[:request_headers], &block
+        end
+      end
+
+      def request_via_request_method(http, env, &block)
+        # Must use Net::HTTP#start and pass it a block otherwise the server's
+        # TCP socket does not close correctly.
+        http.start do |opened_http|
+          if block_given?
+            opened_http.request create_request(env) do |response|
+              response.read_body(&block)
+            end
+          else
+            opened_http.request create_request(env)
+          end
+        end
+      end
+
+      def configure_ssl(http, ssl)
+        http.use_ssl = true if http.respond_to?(:use_ssl=)
+
+        http.verify_mode = ssl_verify_mode(ssl)
+        http.cert_store = ssl_cert_store(ssl)
+
+        http.cert = ssl[:client_cert] if ssl[:client_cert]
+        http.key = ssl[:client_key] if ssl[:client_key]
+        http.ca_file = ssl[:ca_file] if ssl[:ca_file]
+        http.ca_path = ssl[:ca_path] if ssl[:ca_path]
+        http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
+        http.ssl_version = ssl[:version] if ssl[:version]
+        http.min_version = ssl[:min_version] if ssl[:min_version]
+        http.max_version = ssl[:max_version] if ssl[:max_version]
+      end
+
+      def configure_request(http, req)
+        if (sec = request_timeout(:read, req))
+          http.read_timeout = sec
+        end
+
+        if (sec = http.respond_to?(:write_timeout=) &&
+          request_timeout(:write, req))
+          http.write_timeout = sec
+        end
+
+        if (sec = request_timeout(:open, req))
+          http.open_timeout = sec
+        end
+
+        # Only set if Net::Http supports it, since Ruby 2.5.
+        http.max_retries = 0 if http.respond_to?(:max_retries=)
+
+        @config_block&.call(http)
+      end
+
+      def ssl_cert_store(ssl)
+        return ssl[:cert_store] if ssl[:cert_store]
+
+        @ssl_cert_store ||= begin
+                              # Use the default cert store by default, i.e. system ca certs
+                              OpenSSL::X509::Store.new.tap(&:set_default_paths)
+                            end
+      end
+
+      def ssl_verify_mode(ssl)
+        ssl[:verify_mode] || begin
+                               if ssl.fetch(:verify, true)
+                                 OpenSSL::SSL::VERIFY_PEER
+                               else
+                                 OpenSSL::SSL::VERIFY_NONE
+                               end
+                             end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/faraday-net_http-1.0.2/lib/faraday/net_http/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Faraday
+  module NetHttp
+    VERSION = '1.0.2'
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/jaro_winkler-1.5.4/ext/jaro_winkler/Makefile

@@ -31,8 +31,8 @@ rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
 vendorarchdir = $(vendorlibdir)/$(sitearch)
 vendorlibdir = $(vendordir)/$(ruby_version)
 vendordir = $(rubylibprefix)/vendor_ruby
-sitearchdir = $(DESTDIR)./.gem.20240321-1763-tpid33
-sitelibdir = $(DESTDIR)./.gem.20240321-1763-tpid33
+sitearchdir = $(DESTDIR)./.gem.20250103-1740-1lqicp5
+sitelibdir = $(DESTDIR)./.gem.20250103-1740-1lqicp5
 sitedir = $(rubylibprefix)/site_ruby
 rubyarchdir = $(rubylibdir)/$(arch)
 rubylibdir = $(rubylibprefix)/$(ruby_version)
@@ -142,7 +142,7 @@ LIBS = $(LIBRUBYARG_SHARED)  -lm   -lc
 ORIG_SRCS = adj_matrix.c codepoints.c jaro.c jaro_winkler.c
 SRCS = $(ORIG_SRCS) 
 OBJS = adj_matrix.o codepoints.o jaro.o jaro_winkler.o
-HDRS = $(srcdir)/codepoints.h $(srcdir)/adj_matrix.h $(srcdir)/jaro.h
+HDRS = $(srcdir)/jaro.h $(srcdir)/adj_matrix.h $(srcdir)/codepoints.h
 LOCAL_HDRS = 
 TARGET = jaro_winkler_ext
 TARGET_NAME = jaro_winkler_ext

data/vendor/bundle/ruby/2.7.0/gems/multipart-post-2.4.1/lib/multipart/post/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2019, by Patrick Davey.
+# Copyright, 2021-2024, by Samuel Williams.
+
+module Multipart
+  module Post
+    VERSION = "2.4.1"
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/psych-4.0.4/ext/psych/Makefile

@@ -31,8 +31,8 @@ rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
 vendorarchdir = $(vendorlibdir)/$(sitearch)
 vendorlibdir = $(vendordir)/$(ruby_version)
 vendordir = $(rubylibprefix)/vendor_ruby
-sitearchdir = $(DESTDIR)./.gem.20240321-1763-zrd253
-sitelibdir = $(DESTDIR)./.gem.20240321-1763-zrd253
+sitearchdir = $(DESTDIR)./.gem.20250103-1740-olubin
+sitelibdir = $(DESTDIR)./.gem.20250103-1740-olubin
 sitedir = $(rubylibprefix)/site_ruby
 rubyarchdir = $(rubylibdir)/$(arch)
 rubylibdir = $(rubylibprefix)/$(ruby_version)
@@ -142,7 +142,7 @@ LIBS = $(LIBRUBYARG_SHARED) -lyaml  -lm   -lc
 ORIG_SRCS = psych.c psych_emitter.c psych_parser.c psych_to_ruby.c psych_yaml_tree.c
 SRCS = $(ORIG_SRCS) 
 OBJS = psych.o psych_emitter.o psych_parser.o psych_to_ruby.o psych_yaml_tree.o
-HDRS = $(srcdir)/psych_parser.h $(srcdir)/psych_emitter.h $(srcdir)/psych_yaml_tree.h $(srcdir)/psych_to_ruby.h $(srcdir)/psych.h
+HDRS = $(srcdir)/psych_parser.h $(srcdir)/psych_to_ruby.h $(srcdir)/psych_emitter.h $(srcdir)/psych.h $(srcdir)/psych_yaml_tree.h
 LOCAL_HDRS = 
 TARGET = psych
 TARGET_NAME = psych

data/vendor/bundle/ruby/2.7.0/gems/stringio-3.0.2/ext/stringio/Makefile

@@ -31,8 +31,8 @@ rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
 vendorarchdir = $(vendorlibdir)/$(sitearch)
 vendorlibdir = $(vendordir)/$(ruby_version)
 vendordir = $(rubylibprefix)/vendor_ruby
-sitearchdir = $(DESTDIR)./.gem.20240321-1763-1izz0pm
-sitelibdir = $(DESTDIR)./.gem.20240321-1763-1izz0pm
+sitearchdir = $(DESTDIR)./.gem.20250103-1740-1mrlwww
+sitelibdir = $(DESTDIR)./.gem.20250103-1740-1mrlwww
 sitedir = $(rubylibprefix)/site_ruby
 rubyarchdir = $(rubylibdir)/$(arch)
 rubylibdir = $(rubylibprefix)/$(ruby_version)

data/vendor/bundle/ruby/2.7.0/specifications/debase-ruby_core_source-3.3.6.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+# stub: debase-ruby_core_source 3.3.6 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "debase-ruby_core_source".freeze
+  s.version = "3.3.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.3.6".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Mark Moseley".freeze, "Gabriel Horner".freeze, "JetBrains RubyMine Team".freeze]
+  s.date = "2024-10-10"
+  s.description = "Provide Ruby core source files for C extensions that need them.".freeze
+  s.email = "os97673@gmail.com".freeze
+  s.extra_rdoc_files = ["README.md".freeze]
+  s.files = ["README.md".freeze]
+  s.homepage = "https://github.com/ruby-debug/debase-ruby_core_source".freeze
+  s.licenses = ["MIT".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.0.0".freeze)
+  s.rubygems_version = "3.1.6".freeze
+  s.summary = "Provide Ruby core source files".freeze
+
+  s.installed_by_version = "3.1.6" if s.respond_to? :installed_by_version
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+  end
+
+  if s.respond_to? :add_runtime_dependency then
+    s.add_development_dependency(%q<archive-tar-minitar>.freeze, [">= 0.5.2"])
+    s.add_development_dependency(%q<rake>.freeze, [">= 0.9.2"])
+    s.add_development_dependency(%q<minitar-cli>.freeze, [">= 0"])
+  else
+    s.add_dependency(%q<archive-tar-minitar>.freeze, [">= 0.5.2"])
+    s.add_dependency(%q<rake>.freeze, [">= 0.9.2"])
+    s.add_dependency(%q<minitar-cli>.freeze, [">= 0"])
+  end
+end

data/vendor/bundle/ruby/2.7.0/specifications/faraday-multipart-1.1.0.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+# stub: faraday-multipart 1.1.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "faraday-multipart".freeze
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "bug_tracker_uri" => "https://github.com/lostisland/faraday-multipart/issues", "changelog_uri" => "https://github.com/lostisland/faraday-multipart/blob/v1.1.0/CHANGELOG.md", "documentation_uri" => "http://www.rubydoc.info/gems/faraday-multipart/1.1.0", "homepage_uri" => "https://github.com/lostisland/faraday-multipart", "source_code_uri" => "https://github.com/lostisland/faraday-multipart", "wiki_uri" => "https://github.com/lostisland/faraday-multipart/wiki" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Mattia Giuffrida".freeze]
+  s.date = "2024-12-17"
+  s.description = "Perform multipart-post requests using Faraday.\n".freeze
+  s.email = ["giuffrida.mattia@gmail.com".freeze]
+  s.homepage = "https://github.com/lostisland/faraday-multipart".freeze
+  s.licenses = ["MIT".freeze]
+  s.required_ruby_version = Gem::Requirement.new([">= 2.4".freeze, "< 4".freeze])
+  s.rubygems_version = "3.1.6".freeze
+  s.summary = "Perform multipart-post requests using Faraday.".freeze
+
+  s.installed_by_version = "3.1.6" if s.respond_to? :installed_by_version
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+  end
+
+  if s.respond_to? :add_runtime_dependency then
+    s.add_runtime_dependency(%q<multipart-post>.freeze, ["~> 2.0"])
+  else
+    s.add_dependency(%q<multipart-post>.freeze, ["~> 2.0"])
+  end
+end