amritk-scalar-test 0.1.1

data/lib/amritk-scalar-test/runtime.rb

@@ -0,0 +1,893 @@
+# frozen_string_literal: true
+
+# Code generated by Scalar SDK Generator. DO NOT EDIT.
+require "base64"
+require "json"
+require "net/http"
+require "openssl"
+require "securerandom"
+require "socket"
+require "time"
+require "uri"
+
+module ScalarRubyTest
+  module Runtime
+    RETRYABLE_STATUS = [408, 409, 429, 500, 502, 503, 504].freeze
+    module_function
+
+    def compact_hash(hash)
+      hash.each_with_object({}) { |(key, value), result| result[key] = value unless value.nil? }
+    end
+
+    def serialize(value)
+      return value.iso8601 if value.respond_to?(:iso8601)
+      return value.to_h if value.respond_to?(:to_h)
+      return value.map { |item| serialize(item) } if value.is_a?(Array)
+      return value.transform_values { |item| serialize(item) } if value.is_a?(Hash)
+      value
+    end
+
+    def deserialize(value, descriptor)
+      return value if value.nil? || descriptor.nil?
+      return value.map { |item| deserialize(item, descriptor.first) } if descriptor.is_a?(Array) && value.is_a?(Array)
+      return value unless descriptor.is_a?(String)
+      klass = Models.const_get(descriptor, false)
+      klass.respond_to?(:from_h) ? klass.from_h(value) : value
+    rescue NameError
+      value
+    end
+
+    class Page
+      include Enumerable
+
+      attr_reader :items, :response, :next_cursor
+
+      def initialize(items:, response:, next_cursor: nil, fetch_next: nil)
+        @items = items
+        @response = response
+        @next_cursor = next_cursor
+        @fetch_next = fetch_next
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block
+        @items.each(&block)
+      end
+
+      def each_page
+        return enum_for(:each_page) unless block_given?
+        page = self
+        loop do
+          yield page
+          break unless page.has_next_page?
+          page = page.next_page
+        end
+      end
+
+      def auto_paging_each
+        return enum_for(:auto_paging_each) unless block_given?
+        each_page { |page| page.each { |item| yield item } }
+      end
+
+      def has_next_page?
+        !@next_cursor.nil? && !@fetch_next.nil?
+      end
+
+      def next_page
+        raise RuntimeError, "No next page available" unless has_next_page?
+        @fetch_next.call(@next_cursor)
+      end
+    end
+
+    class RawResponse
+      attr_reader :data, :status, :headers, :body
+
+      def initialize(data:, status:, headers:, body:)
+        @data = data
+        @status = status
+        @headers = headers
+        @body = body
+      end
+
+      def map
+        self.class.new(data: yield(@data), status: @status, headers: @headers, body: @body)
+      end
+    end
+
+    class ResultResponse
+      attr_reader :data, :error, :status, :headers, :body
+
+      def initialize(data: nil, error: nil, status:, headers:, body:)
+        @data = data
+        @error = error
+        @status = status
+        @headers = headers
+        @body = body
+      end
+    end
+
+    class WebSocketMessageError < StandardError; end
+
+    class WebSocketConnection
+      attr_reader :socket, :request
+
+      def initialize(socket, request)
+        @socket = socket
+        @request = request
+      end
+
+      def send(message)
+        send_text(@request.serialize_send(message))
+      end
+
+      def send_text(payload)
+        data = payload.to_s.b
+        mask = SecureRandom.random_bytes(4)
+        header = [0x81]
+        if data.bytesize < 126
+          header << (0x80 | data.bytesize)
+        elsif data.bytesize < 65_536
+          header << (0x80 | 126)
+          header.concat([data.bytesize].pack("n").bytes)
+        else
+          header << (0x80 | 127)
+          header.concat([data.bytesize].pack("Q>").bytes)
+        end
+        masked = data.bytes.each_with_index.map { |byte, index| (byte ^ mask.getbyte(index % 4)).chr }.join
+        @socket.write(header.pack("C*") + mask + masked)
+      end
+
+      def receive
+        text = receive_text
+        text.nil? ? nil : @request.deserialize_receive(text)
+      end
+
+      def receive_text
+        header = read_exact(2).bytes
+        opcode = header[0] & 0x0f
+        length_byte = header[1]
+        masked = (length_byte & 0x80) != 0
+        length = length_byte & 0x7f
+        length = read_exact(2).unpack1("n") if length == 126
+        length = read_exact(8).unpack1("Q>") if length == 127
+        mask = masked ? read_exact(4).bytes : nil
+        payload = read_exact(length)
+        payload = payload.bytes.each_with_index.map { |byte, index| (byte ^ mask[index % 4]).chr }.join if mask
+        return nil if opcode == 0x8
+        raise WebSocketMessageError, "unsupported websocket frame opcode #{opcode}" unless opcode == 0x1
+        payload.force_encoding("UTF-8")
+      end
+
+      def close
+        @socket.close unless @socket.closed?
+      end
+
+      def closed?
+        @socket.closed?
+      end
+
+      private
+
+      def read_exact(size)
+        data = @socket.read(size)
+        raise WebSocketMessageError, "unexpected websocket EOF" if data.nil? || data.bytesize != size
+        data
+      end
+    end
+
+    class WebSocketRequest
+      attr_reader :url, :headers, :send_descriptor, :receive_descriptor, :event_name_separator, :reconnect_options, :heartbeat_options
+
+      def initialize(url:, headers: {}, send_descriptor: nil, receive_descriptor: nil, event_name_separator: nil, reconnect_options: nil, heartbeat_options: nil)
+        @url = url
+        @headers = headers
+        @send_descriptor = send_descriptor
+        @receive_descriptor = receive_descriptor
+        @event_name_separator = event_name_separator
+        @reconnect_options = reconnect_options
+        @heartbeat_options = heartbeat_options
+      end
+
+      def auth_headers
+        @headers.dup
+      end
+
+      def with_headers(extra = {})
+        self.class.new(url: @url, headers: @headers.merge(extra || {}), send_descriptor: @send_descriptor, receive_descriptor: @receive_descriptor, event_name_separator: @event_name_separator, reconnect_options: @reconnect_options, heartbeat_options: @heartbeat_options)
+      end
+
+      def with_reconnect(**options)
+        self.class.new(url: @url, headers: @headers, send_descriptor: @send_descriptor, receive_descriptor: @receive_descriptor, event_name_separator: @event_name_separator, reconnect_options: options, heartbeat_options: @heartbeat_options)
+      end
+
+      def with_heartbeat(interval:, message:)
+        self.class.new(url: @url, headers: @headers, send_descriptor: @send_descriptor, receive_descriptor: @receive_descriptor, event_name_separator: @event_name_separator, reconnect_options: @reconnect_options, heartbeat_options: { interval: interval, message: message })
+      end
+
+      def connect
+        uri = URI(@url)
+        raise WebSocketMessageError, "only ws:// and wss:// URLs are supported by the stdlib connector" unless ["ws", "wss"].include?(uri.scheme)
+        socket = TCPSocket.new(uri.host, uri.port || (uri.scheme == "wss" ? 443 : 80))
+        if uri.scheme == "wss"
+          context = OpenSSL::SSL::SSLContext.new
+          socket = OpenSSL::SSL::SSLSocket.new(socket, context)
+          socket.hostname = uri.host if socket.respond_to?(:hostname=)
+          socket.sync_close = true
+          socket.connect
+        end
+        key = SecureRandom.base64(16)
+        path = uri.path.empty? ? "/" : uri.path
+        path = "#{path}?#{uri.query}" if uri.query
+        headers = { "Host" => uri.host, "Upgrade" => "websocket", "Connection" => "Upgrade", "Sec-WebSocket-Key" => key, "Sec-WebSocket-Version" => "13" }.merge(auth_headers)
+        socket.write("GET #{path} HTTP/1.1\r\n")
+        headers.each { |name, value| socket.write("#{name}: #{value}\r\n") }
+        socket.write("\r\n")
+        status = socket.gets
+        raise WebSocketMessageError, "WebSocket upgrade failed: #{status}" unless status&.include?(" 101 ")
+        WebSocketConnection.new(socket, self)
+      rescue StandardError
+        socket&.close
+        raise
+      end
+
+      def serialize_send(message)
+        payload = Runtime.serialize(message)
+        return payload if payload.is_a?(String) && @send_descriptor.nil?
+        JSON.generate(payload)
+      rescue JSON::GeneratorError => e
+        raise WebSocketMessageError, "failed to serialize websocket payload: #{e.message}"
+      end
+
+      def deserialize_receive(payload)
+        parsed = parse_receive_payload(payload)
+        Runtime.deserialize(parsed, @receive_descriptor)
+      rescue JSON::ParserError => e
+        raise WebSocketMessageError, "failed to parse websocket payload: #{e.message}"
+      end
+
+      def normalize_event_name(name)
+        return name if name.nil? || @event_name_separator.nil? || @event_name_separator.empty?
+        name.to_s.tr(@event_name_separator, ".")
+      end
+
+      private
+
+      def parse_receive_payload(payload)
+        return payload if payload.nil? || payload.is_a?(Hash) || payload.is_a?(Array)
+        return payload unless payload.respond_to?(:to_str)
+        text = payload.to_str
+        return text if @receive_descriptor.nil?
+        JSON.parse(text)
+      end
+    end
+
+    class Stream
+      include Enumerable
+
+      def initialize(source:, descriptor:, format: :sse, handlers: [])
+        @source = source
+        @descriptor = descriptor
+        @format = format
+        @handlers = handlers
+        @closed = false
+        @retry_after = nil
+        @last_event_id = nil
+        @last_event_name = nil
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block
+        return if @closed
+        each_event do |data|
+          break if @closed
+          next if stream_action(data) == :skip
+          block.call(Runtime.deserialize(Runtime.parse_json(data), @descriptor))
+        end
+      ensure
+        close
+      end
+
+      def close
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+
+      attr_reader :retry_after, :last_event_id, :last_event_name
+
+      private
+
+      def each_event
+        return enum_for(:each_event) unless block_given?
+        return each_json_line { |line| yield line } if @format == :jsonl
+
+        buffer = +""
+        event = []
+        each_raw_event do |chunk|
+          buffer << chunk.to_s
+          while (line_end = buffer.index("\n"))
+            data = consume_sse_line(buffer.slice!(0, line_end + 1), event)
+            yield data unless data.nil? || data == "[DONE]" || @closed
+          end
+        end
+        data = flush_sse_event(event)
+        yield data unless data.nil? || data == "[DONE]" || @closed
+      end
+
+      def each_raw_event
+        @source.call do |chunk|
+          yield chunk unless @closed
+          !@closed
+        end
+      end
+
+      def each_json_line
+        buffer = +""
+        each_raw_event do |chunk|
+          buffer << chunk.to_s
+          while (line_end = buffer.index("\n"))
+            line = buffer.slice!(0, line_end + 1).strip
+            yield line unless line.empty? || @closed
+          end
+        end
+        line = buffer.strip
+        yield line unless line.empty? || @closed
+      end
+
+      def consume_sse_line(raw_line, event)
+        line = raw_line.delete_suffix("\n").delete_suffix("\r")
+        return flush_sse_event(event) if line.empty?
+        return nil if line.start_with?(":")
+        if line.start_with?("event:")
+          @last_event_name = line.delete_prefix("event:").strip
+          return nil
+        end
+        if line.start_with?("id:")
+          @last_event_id = line.delete_prefix("id:").strip
+          return nil
+        end
+        if line.start_with?("retry:")
+          @retry_after = line.delete_prefix("retry:").strip.to_i
+          return nil
+        end
+        return nil unless line.start_with?("data:")
+
+        data = line.delete_prefix("data:")
+        event << data.delete_prefix(" ")
+        nil
+      end
+
+      def flush_sse_event(event)
+        return nil if event.empty?
+        data = event.join("\n")
+        event.clear
+        data
+      end
+
+      def stream_action(data)
+        handler = @handlers.find { |entry| handler_matches?(entry, data) }
+        return :yield if handler.nil?
+        handle = handler["handle"] || handler[:handle]
+        return :skip if ["continue", "ignore"].include?(handle)
+        raise WebSocketMessageError, data if handle == "error"
+        :yield
+      end
+
+      def handler_matches?(handler, data)
+        kind = handler["kind"] || handler[:kind]
+        return false if kind == "event" && !event_type_matches?(handler)
+        prefix = handler["dataStartsWith"] || handler[:dataStartsWith]
+        return false if prefix && !data.to_s.start_with?(prefix.to_s)
+        true
+      end
+
+      def event_type_matches?(handler)
+        expected = handler["eventType"] || handler[:eventType]
+        return @last_event_name.nil? if expected.nil?
+        return expected.include?(@last_event_name) if expected.is_a?(Array)
+        expected.to_s == @last_event_name.to_s
+      end
+    end
+
+    def extra_keys(data, known)
+      data.reject { |key, _value| known.include?(key) }
+    end
+
+    def parse_json(text)
+      return nil if text.nil? || text.empty?
+      JSON.parse(text)
+    rescue JSON::ParserError
+      text
+    end
+
+    def value_at(value, path)
+      path.reduce(value) do |current, key|
+        break nil if current.nil?
+        current.is_a?(Hash) ? current[key] || current[key.to_s] : nil
+      end
+    end
+
+    def header_value(headers, name)
+      return nil unless headers.is_a?(Hash)
+      value = headers[name] || headers[name.to_s.downcase] || headers[name.to_s]
+      value.is_a?(Array) ? value.first : value
+    end
+
+    def link_header_url(headers, name, rel)
+      header = header_value(headers, name)
+      return nil if header.nil?
+      header.to_s.split(",").each do |part|
+        url = part[/<([^>]+)>/, 1]
+        rel_value = part[/rel="?([^";,]+)"?/, 1]
+        return url if url && rel_value == rel
+      end
+      nil
+    end
+
+    def extract_error_message(body)
+      return nil unless body.is_a?(Hash)
+      candidate = body["message"] || body["error"] || body["detail"]
+      return candidate if candidate.is_a?(String)
+      candidate["message"] if candidate.is_a?(Hash) && candidate["message"].is_a?(String)
+    end
+
+    def request_options_hash(options)
+      return {} if options.nil?
+      value = options.respond_to?(:to_h) ? options.to_h : options
+      value.is_a?(Hash) ? value : {}
+    end
+
+    def request_option_hash(options, *keys)
+      keys.each do |key|
+        value = request_option_value(options, key)
+        return value if value.is_a?(Hash)
+      end
+      {}
+    end
+
+    def request_option_value(options, key)
+      value = request_options_hash(options)
+      value[key] || value[key.to_s]
+    end
+
+    def safe_header_value(value)
+      text = value.to_s
+      raise ArgumentError, "header values cannot contain CR or LF" if text.match?(/[\r\n]/)
+      text
+    end
+
+    def safe_header_name(value)
+      text = value.to_s
+      raise ArgumentError, "header names cannot be empty" if text.empty?
+      raise ArgumentError, "invalid header name #{text.inspect}" unless text.match?(/\A[!#$%&'*+\-.^_`|~0-9A-Za-z]+\z/)
+      text
+    end
+
+    def safe_cookie_pair(name, value)
+      "#{URI.encode_www_form_component(name.to_s)}=#{URI.encode_www_form_component(safe_header_value(value))}"
+    end
+
+    def body_encoding_for_content_type(content_type)
+      value = content_type.to_s.downcase
+      return :multipart if value.include?("multipart/")
+      return :form if value.include?("x-www-form-urlencoded")
+      return :json if value.include?("json")
+      :binary
+    end
+  end
+
+  class APIClient
+    def initialize(base_url:, max_retries: 2, timeout: 60.0, initial_retry_delay: 0.5, max_retry_delay: 8.0, idempotency_header: "Idempotency-Key", logger: nil, default_headers: {}, default_query: {})
+      @base_url = base_url.to_s.delete_suffix("/")
+      @max_retries = max_retries
+      @timeout = timeout
+      @initial_retry_delay = initial_retry_delay
+      @max_retry_delay = max_retry_delay
+      @idempotency_header = idempotency_header
+      @logger = logger
+      @default_headers = default_headers
+      @default_query = default_query
+    end
+
+    def request(
+      method:, path:,
+      path_params: {}, path_settings: {},
+      query: {}, query_settings: {},
+      cookies: {}, cookie_settings: {},
+      body: nil, body_type: :json, content_type: nil,
+      headers: nil, request_options: nil
+    )
+      options = normalize_options(request_options)
+      merged_query = @default_query.merge(auth_query).merge(option_hash(options, :query, :extra_query)).merge(query || {})
+      # Link-header pagination passes the exact next-page URL via `url:`; use it
+      # directly instead of rebuilding base_url + path + query.
+      exact_url = option_value(options, :url)
+      uri = exact_url ? URI.parse(exact_url.to_s) : build_uri(
+        option_value(options, :base_url) || @base_url,
+        path,
+        path_params,
+        path_settings,
+        merged_query,
+        query_settings
+      )
+      cookie_header = build_cookie_header(cookies || {}, cookie_settings || {})
+      headers = (headers || {}).merge("Cookie" => [headers && headers["Cookie"], cookie_header].compact.reject(&:empty?).join("; ")) unless cookie_header.empty?
+      request = build_request(method, uri, body, body_type, content_type, headers || {}, options)
+      response = execute_with_retry(uri, request, option_value(options, :max_retries) || @max_retries, option_value(options, :timeout) || @timeout)
+      parsed = parse_response_body(response)
+      raise APIError.from_response(response, parsed) unless response.is_a?(Net::HTTPSuccess)
+      parsed
+    end
+
+    def request_raw(
+      method:, path:,
+      path_params: {}, path_settings: {},
+      query: {}, query_settings: {},
+      cookies: {}, cookie_settings: {},
+      body: nil, body_type: :json, content_type: nil,
+      headers: nil, request_options: nil
+    )
+      options = normalize_options(request_options)
+      merged_query = @default_query.merge(auth_query).merge(option_hash(options, :query, :extra_query)).merge(query || {})
+      exact_url = option_value(options, :url)
+      uri = exact_url ? URI.parse(exact_url.to_s) : build_uri(
+        option_value(options, :base_url) || @base_url,
+        path,
+        path_params,
+        path_settings,
+        merged_query,
+        query_settings
+      )
+      cookie_header = build_cookie_header(cookies || {}, cookie_settings || {})
+      headers = (headers || {}).merge("Cookie" => [headers && headers["Cookie"], cookie_header].compact.reject(&:empty?).join("; ")) unless cookie_header.empty?
+      request = build_request(method, uri, body, body_type, content_type, headers || {}, options)
+      response = execute_with_retry(uri, request, option_value(options, :max_retries) || @max_retries, option_value(options, :timeout) || @timeout)
+      parsed = parse_response_body(response)
+      raise APIError.from_response(response, parsed) unless response.is_a?(Net::HTTPSuccess)
+      Runtime::RawResponse.new(data: parsed, status: response.code.to_i, headers: response.to_hash, body: response.body)
+    end
+
+    def request_stream(
+      method:, path:,
+      path_params: {}, path_settings: {},
+      query: {}, query_settings: {},
+      cookies: {}, cookie_settings: {},
+      body: nil, body_type: :json, content_type: nil,
+      headers: nil, stream_format: :sse, descriptor: nil, handlers: [], request_options: nil
+    )
+      options = normalize_options(request_options)
+      merged_query = @default_query.merge(auth_query).merge(option_hash(options, :query, :extra_query)).merge(query || {})
+      uri = build_uri(
+        option_value(options, :base_url) || @base_url,
+        path,
+        path_params,
+        path_settings,
+        merged_query,
+        query_settings
+      )
+      cookie_header = build_cookie_header(cookies || {}, cookie_settings || {})
+      headers = (headers || {}).merge("Cookie" => [headers && headers["Cookie"], cookie_header].compact.reject(&:empty?).join("; ")) unless cookie_header.empty?
+      request = build_request(method, uri, body, body_type, content_type, headers || {}, options)
+      source = proc { |&chunk_handler| execute_stream_with_retry(uri, request, option_value(options, :max_retries) || @max_retries, option_value(options, :timeout) || @timeout, &chunk_handler) }
+      Runtime::Stream.new(source: source, descriptor: descriptor, format: stream_format, handlers: handlers)
+    end
+
+    def websocket_request(
+      method: "GET", path:,
+      path_params: {}, path_settings: {},
+      query: {}, query_settings: {},
+      cookies: {}, cookie_settings: {},
+      body: nil, body_type: :json, content_type: nil,
+      headers: nil, send_descriptor: nil, receive_descriptor: nil, event_name_separator: nil, request_options: nil
+    )
+      options = normalize_options(request_options)
+      merged_query = @default_query.merge(auth_query).merge(option_hash(options, :query, :extra_query)).merge(query || {})
+      uri = build_uri(
+        option_value(options, :base_url) || @base_url,
+        path,
+        path_params,
+        path_settings,
+        merged_query,
+        query_settings
+      )
+      uri.scheme = uri.scheme == "https" ? "wss" : "ws"
+      request_headers = sanitize_headers(@default_headers.merge(auth_headers_for(uri, options)).merge(headers || {}))
+      Runtime::WebSocketRequest.new(url: uri.to_s, headers: request_headers, send_descriptor: send_descriptor, receive_descriptor: receive_descriptor, event_name_separator: event_name_separator)
+    end
+
+    def auth_headers
+      {}
+    end
+
+    def auth_query
+      {}
+    end
+
+    private
+
+    def normalize_options(options)
+      Runtime.request_options_hash(options)
+    end
+
+    def option_value(options, *keys)
+      keys.each do |key|
+        value = Runtime.request_option_value(options, key)
+        return value unless value.nil?
+      end
+      nil
+    end
+
+    def option_hash(options, *keys)
+      Runtime.request_option_hash(options, *keys)
+    end
+
+    def sanitize_headers(headers)
+      headers.each_with_object({}) do |(key, value), out|
+        next if value.nil?
+        out[Runtime.safe_header_name(key)] = Runtime.safe_header_value(value)
+      end
+    end
+
+    def auth_headers_for(uri, options)
+      # Both `base_url:` and `url:` overrides suppress auth when the target
+      # crosses origins, unless the caller explicitly allows it.
+      override = option_value(options, :base_url) || option_value(options, :url)
+      return auth_headers if override.nil? || option_value(options, :allow_auth_to_base_url)
+      same_origin?(URI.parse(@base_url), uri) ? auth_headers : {}
+    rescue URI::InvalidURIError
+      {}
+    end
+
+    def same_origin?(left, right)
+      left.scheme == right.scheme && left.host == right.host && left.port == right.port
+    end
+
+    def log_debug(message)
+      return if @logger.nil?
+      @logger.respond_to?(:call) ? @logger.call(message) : @logger.puts(message)
+    end
+
+    def build_uri(base_url, path, path_params, path_settings, query, query_settings)
+      resolved = path.dup
+      path_params.each { |key, value| resolved = resolved.gsub("{#{key}}", serialize_path_param(key, value, path_settings[key] || {})) }
+      uri = URI.parse(base_url.to_s.delete_suffix("/") + resolved)
+      pairs = URI.decode_www_form(uri.query.to_s)
+      query.each { |key, value| append_query(pairs, key, value, query_settings[key] || {}) }
+      uri.query = pairs.empty? ? nil : URI.encode_www_form(pairs)
+      uri
+    end
+
+    def append_query(pairs, key, raw_value, setting = {})
+      value = parameter_value(raw_value, setting)
+      return if value.nil?
+      style = setting[:style] || "form"
+      explode = setting.key?(:explode) ? setting[:explode] : true
+      if value.is_a?(Array)
+        return value.each { |item| append_query(pairs, key, item, setting.merge(explode: false)) } if ["form", "spaceDelimited", "pipeDelimited"].include?(style) && explode
+        sep = style == "spaceDelimited" ? " " : style == "pipeDelimited" ? "|" : ","
+        pairs << [key, value.map { |item| parameter_value(item, setting).to_s }.join(sep)]
+      elsif value.is_a?(Hash)
+        entries = value.map { |prop, prop_value| [prop, parameter_value(prop_value, setting)] }.reject { |_, prop_value| prop_value.nil? }
+        return entries.each { |prop, prop_value| pairs << ["#{key}[#{prop}]", prop_value.to_s] } if style == "deepObject"
+        return entries.each { |prop, prop_value| pairs << [prop.to_s, prop_value.to_s] } if style == "form" && explode
+        pairs << [key, style == "form" ? entries.flat_map { |prop, prop_value| [prop, prop_value] }.join(",") : JSON.generate(value)]
+      else
+        pairs << [key, value.to_s]
+      end
+    end
+
+    def parameter_value(value, setting)
+      return setting[:default] if value.nil? && setting.key?(:default)
+      return "" if value.nil? && (setting[:nullable] || setting[:required] || setting[:allow_empty_value])
+      value
+    end
+
+    def encode_part(value, allow_reserved: false)
+      encoded = URI.encode_www_form_component(value.to_s)
+      return encoded unless allow_reserved
+      encoded.gsub(/%3A/i, ":").gsub(/%2F/i, "/").gsub(/%3F/i, "?").gsub(/%23/i, "#").gsub(/%5B/i, "[").gsub(/%5D/i, "]").gsub(/%40/i, "@").gsub(/%21/i, "!").gsub(/%24/i, "$").gsub(/%26/i, "&").gsub(/%27/i, "'").gsub(/%28/i, "(").gsub(/%29/i, ")").gsub(/%2A/i, "*").gsub(/%2B/i, "+").gsub(/%2C/i, ",").gsub(/%3B/i, ";").gsub(/%3D/i, "=")
+    end
+
+    def serialize_path_param(key, raw_value, setting = {})
+      value = parameter_value(raw_value, setting) || ""
+      style = setting[:style] || "simple"
+      explode = setting.key?(:explode) ? setting[:explode] : false
+      # `allow_reserved` keeps RFC 6570 reserved characters (notably `/`) so a path-like value such as a
+      # file path stays nested under the route instead of collapsing to a single `%2F`-encoded segment.
+      allow_reserved = setting.key?(:allow_reserved) ? setting[:allow_reserved] : false
+      return label_path_value(value, explode, allow_reserved: allow_reserved) if style == "label"
+      if style == "matrix"
+        return value.map { |item| ";#{encode_part(key)}=#{encode_part(parameter_value(item, setting) || "", allow_reserved: allow_reserved)}" }.join if value.is_a?(Array) && explode
+        return value.map { |prop, prop_value| ";#{encode_part(prop)}=#{encode_part(parameter_value(prop_value, setting) || "", allow_reserved: allow_reserved)}" }.join if value.is_a?(Hash) && explode
+        return ";#{encode_part(key)}=#{simple_path_value(value, false, allow_reserved: allow_reserved)}"
+      end
+      simple_path_value(value, explode, allow_reserved: allow_reserved)
+    end
+
+    def label_path_value(value, explode, allow_reserved: false)
+      return "." + value.map { |item| encode_part(parameter_value(item, {}) || "", allow_reserved: allow_reserved) }.join(".") if value.is_a?(Array) && explode
+      return "." + value.map { |prop, prop_value| "#{encode_part(prop)}=#{encode_part(parameter_value(prop_value, {}) || "", allow_reserved: allow_reserved)}" }.join(".") if value.is_a?(Hash) && explode
+      "." + simple_path_value(value, false, allow_reserved: allow_reserved)
+    end
+
+    def simple_path_value(value, explode, allow_reserved: false)
+      return value.map { |item| encode_part(parameter_value(item, {}) || "", allow_reserved: allow_reserved) }.join(",") if value.is_a?(Array)
+      return value.map { |prop, prop_value| explode ? "#{encode_part(prop)}=#{encode_part(parameter_value(prop_value, {}) || "", allow_reserved: allow_reserved)}" : [encode_part(prop), encode_part(parameter_value(prop_value, {}) || "", allow_reserved: allow_reserved)] }.flatten.join(",") if value.is_a?(Hash)
+      encode_part(value, allow_reserved: allow_reserved)
+    end
+
+    def build_cookie_header(cookies, cookie_settings)
+      parts = []
+      cookies.each do |key, raw_value|
+        setting = cookie_settings[key] || {}
+        value = parameter_value(raw_value, setting)
+        next if value.nil?
+        explode = setting.key?(:explode) ? setting[:explode] : true
+        if value.is_a?(Array) && explode
+          value.each { |item| parts << "#{encode_part(key)}=#{encode_part(parameter_value(item, setting) || "")}" }
+        elsif value.is_a?(Hash) && explode
+          value.each { |prop, prop_value| parts << "#{encode_part(prop)}=#{encode_part(parameter_value(prop_value, setting) || "")}" }
+        else
+          serialized = value.is_a?(Array) ? value.map { |item| parameter_value(item, setting).to_s }.join(",") : value.is_a?(Hash) ? value.flat_map { |prop, prop_value| [prop, parameter_value(prop_value, setting)] }.join(",") : value.to_s
+          parts << "#{encode_part(key)}=#{encode_part(serialized)}"
+        end
+      end
+      parts.join("; ")
+    end
+
+    def build_request(method, uri, body, body_type, content_type, extra_headers, options = {})
+      request = request_class(method).new(uri)
+      headers = { "Accept" => "application/json" }.merge(@default_headers).merge(auth_headers_for(uri, options)).merge(option_hash(options, :extra_headers)).merge(extra_headers)
+      if write_method?(method) && !@idempotency_header.nil? && !@idempotency_header.empty?
+        idempotency_key = option_value(options, :idempotency_key)
+        headers[@idempotency_header] = idempotency_key.to_s unless idempotency_key.nil? || idempotency_key.to_s.empty?
+      end
+      encoded_body, encoded_content_type = encode_body(body, body_type, content_type, options)
+      headers["Content-Type"] ||= encoded_content_type unless encoded_content_type.nil?
+      sanitize_headers(headers).each { |key, value| request[key] = value }
+      request.body = encoded_body unless encoded_body.nil?
+      request
+    end
+
+    def write_method?(method)
+      !["GET", "HEAD", "OPTIONS"].include?(method.to_s.upcase)
+    end
+
+    def request_class(method)
+      { "GET" => Net::HTTP::Get, "POST" => Net::HTTP::Post, "PUT" => Net::HTTP::Put, "PATCH" => Net::HTTP::Patch, "DELETE" => Net::HTTP::Delete, "HEAD" => Net::HTTP::Head, "OPTIONS" => Net::HTTP::Options }.fetch(method.to_s.upcase)
+    end
+
+    def encode_body(body, body_type, content_type, options = {})
+      return [nil, nil] if body.nil?
+      value = Runtime.serialize(body)
+      extra_body = option_hash(options, :extra_body)
+      value = value.merge(extra_body) if value.is_a?(Hash) && !extra_body.empty?
+      return [URI.encode_www_form(value || {}), "application/x-www-form-urlencoded"] if body_type == :form
+      return encode_multipart(value || {}, content_type) if body_type == :multipart
+      return [value, content_type || "application/octet-stream"] if body_type == :binary
+      [JSON.generate(value), content_type || "application/json"]
+    end
+
+    def encode_multipart(value, content_type)
+      boundary = "scalar-sdk-generator-#{object_id}-#{rand(1_000_000)}"
+      chunks = []
+      value.each do |key, part|
+        Array(part).each do |item|
+          filename = multipart_filename(item)
+          part_content_type = multipart_content_type(item)
+          chunks << "--#{boundary}\r\n"
+          disposition = "Content-Disposition: form-data; name=\"#{multipart_disposition_param(key)}\""
+          disposition += "; filename=\"#{multipart_disposition_param(filename)}\"" unless filename.nil?
+          chunks << "#{disposition}\r\n"
+          chunks << "Content-Type: #{multipart_header_value(part_content_type)}\r\n" unless part_content_type.nil?
+          chunks << "\r\n"
+          chunks << multipart_value(item)
+          chunks << "\r\n"
+        end
+      end
+      chunks << "--#{boundary}--\r\n"
+      [chunks.join, content_type || "multipart/form-data; boundary=#{boundary}"]
+    end
+
+    def multipart_disposition_param(value)
+      value.to_s.gsub(/["\\\r\n]/, "_")
+    end
+
+    def multipart_header_value(value)
+      value.to_s.gsub(/[\r\n]/, "")
+    end
+
+    def multipart_filename(value)
+      return File.basename(value.filename.to_s) if value.respond_to?(:filename) && value.filename
+      return File.basename(value.path) if value.respond_to?(:path) && value.path
+      nil
+    end
+
+    def multipart_content_type(value)
+      return value.content_type if value.respond_to?(:content_type) && value.content_type
+      return "application/octet-stream" unless multipart_filename(value).nil?
+      nil
+    end
+
+    def multipart_value(value)
+      source = value.respond_to?(:io) ? value.io : value
+      return source.read if source.respond_to?(:read)
+      source.to_s
+    end
+
+    def parse_response_body(response)
+      content_type = response["Content-Type"].to_s.downcase
+      body = response.body
+      return body unless content_type.empty? || content_type.include?("json") || content_type.start_with?("text/") || content_type.include?("xml")
+      Runtime.parse_json(body)
+    end
+
+    def execute_with_retry(uri, request, retries_left, timeout)
+      response = nil
+      log_debug("#{request.method} #{uri}")
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", read_timeout: timeout, open_timeout: timeout) { |http| response = http.request(request) }
+      log_debug("#{response.code} #{request.method} #{uri}")
+      if Runtime::RETRYABLE_STATUS.include?(response.code.to_i) && retries_left.positive?
+        sleep retry_delay(retries_left, response)
+        return execute_with_retry(uri, request, retries_left - 1, timeout)
+      end
+      response
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      raise APIConnectionTimeoutError.new(e.message) unless retries_left.positive?
+      sleep retry_delay(retries_left)
+      execute_with_retry(uri, request, retries_left - 1, timeout)
+    rescue StandardError => e
+      raise APIConnectionError.new(e.message) unless retries_left.positive?
+      sleep retry_delay(retries_left)
+      execute_with_retry(uri, request, retries_left - 1, timeout)
+    end
+
+    def execute_stream_with_retry(uri, request, retries_left, timeout, &chunk_handler)
+      log_debug("#{request.method} #{uri} stream")
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", read_timeout: timeout, open_timeout: timeout) do |http|
+        http.request(request) do |response|
+          log_debug("#{response.code} #{request.method} #{uri} stream")
+          unless response.is_a?(Net::HTTPSuccess)
+            error_body = +""
+            response.read_body { |chunk| error_body << chunk.to_s }
+            if Runtime::RETRYABLE_STATUS.include?(response.code.to_i) && retries_left.positive?
+              sleep retry_delay(retries_left, response)
+              return execute_stream_with_retry(uri, request, retries_left - 1, timeout, &chunk_handler)
+            end
+            raise APIError.from_response(response, Runtime.parse_json(error_body))
+          end
+
+          response.read_body do |chunk|
+            break if chunk_handler.call(chunk) == false
+          end
+        end
+      end
+    rescue APIError
+      raise
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      raise APIConnectionTimeoutError.new(e.message) unless retries_left.positive?
+      sleep retry_delay(retries_left)
+      execute_stream_with_retry(uri, request, retries_left - 1, timeout, &chunk_handler)
+    rescue StandardError => e
+      raise APIConnectionError.new(e.message) unless retries_left.positive?
+      sleep retry_delay(retries_left)
+      execute_stream_with_retry(uri, request, retries_left - 1, timeout, &chunk_handler)
+    end
+
+    def retry_delay(retries_left, response = nil)
+      retry_after = response&.[]("Retry-After")
+      unless retry_after.nil? || retry_after.empty?
+        seconds = Float(retry_after, exception: false)
+        return seconds if !seconds.nil? && seconds >= 0
+        begin
+          return [Time.httpdate(retry_after) - Time.now, 0].max
+        rescue ArgumentError
+          # Fall through to exponential delay.
+        end
+      end
+      [@initial_retry_delay * (2**(@max_retries - retries_left)), @max_retry_delay].min + rand * 0.25
+    end
+  end
+end