ding_sdk 0.26.36 → 0.26.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08d9bc5cc7d546efa59e6cf9547364e7902890a3e8eda07fef77cea8dfb2c49e'
-  data.tar.gz: c182bb5c09c293ebbc39a9e676e538a83d83e1ab2a4503f51bf8198dfdc0906d
+  metadata.gz: 30b1adb998b0df2700640b6566780cf1bcad9be2a53ea5f529158b9ef0cfe441
+  data.tar.gz: cbae7c04eca74d11e2cfc806512085c48514a92c1ad08350a0263621b1daedb6
 SHA512:
-  metadata.gz: 2b81a60539caa78a9d6d159eeb0f5f4bde5cbce67780c7c3361e02c3999b99202192f26d79b9b24d3b229d90665364637a81e92b6a4379edce8f27c5596cfe28
-  data.tar.gz: fae2d6db64588fdc7bc1b0e0f8b348168551903eccffd804e51673abe67f1ddae4cd37073a9baa31343ecc4a64ca891abaddec9e80f939b61a8a52d198f07c81
+  metadata.gz: 6ba7ca25688fe2096e7c30370a39eeca1932310d90c989b8a2d396f3368e0fca5feaf029985a9e976bc18f36b5453929dd5a060f8909d4ba619860750707f07b
+  data.tar.gz: ad28e1288e16b125ff179421462ac3d5388ce8cc39cc5a044bda56ece341babb7cdf2cdf2eaae6918f69879003294d7b9fcb60c02e533b2c85f3c0d7a724fad4

data/lib/ding_sdk/sdkconfiguration.rb

@@ -63,9 +63,9 @@ module DingSDK
       end
       @language = 'ruby'
       @openapi_doc_version = '1.0.0'
-      @sdk_version = '0.26.36'
+      @sdk_version = '0.26.37'
       @gen_version = '2.578.0'
-      @user_agent = 'speakeasy-sdk/ruby 0.26.36 2.578.0 1.0.0 ding_sdk'
+      @user_agent = 'speakeasy-sdk/ruby 0.26.37 2.578.0 1.0.0 ding_sdk'
     end
 
     sig { returns([String, T::Hash[Symbol, String]]) }

data/lib/ding_sdk/utils/forms.rb

@@ -0,0 +1,186 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'sorbet-runtime'
+require 'base64'
+
+module DingSDK
+  module Utils
+    extend T::Sig
+
+    sig do
+      params(field_name: String, explode: T::Boolean, obj: Object, delimiter: String,
+             get_field_name_lambda: T.proc.params(obj_field: ::Crystalline::MetadataFields::Field).returns(String))
+        .returns(T::Hash[Symbol, T::Array[String]])
+    end
+    def self._populate_form(field_name, explode, obj, delimiter, &get_field_name_lambda)
+      params = {}
+
+      return params if obj.nil?
+
+      if obj.respond_to? :fields
+        items = []
+        obj_fields = obj.fields
+        obj_fields.each do |obj_field|
+          obj_field_name = get_field_name_lambda.call(obj_field)
+          next if obj_field_name == ''
+
+          val = obj.send(obj_field.name.to_sym)
+          next if val.nil?
+
+          if explode
+            params[obj_field_name] = [val_to_string(val)]
+          else
+            items.append("#{obj_field_name}#{delimiter}#{val_to_string(val)}")
+          end
+        end
+
+        params[field_name] = [items.join(delimiter)] if !items.empty?
+      elsif obj.is_a? Hash
+        items = []
+        obj.each do |key, value|
+          next if value.nil?
+
+          if explode
+            params[key] = val_to_string(value)
+          else
+            items.append("#{key}#{delimiter}#{val_to_string(value)}")
+          end
+        end
+        params[field_name] = [items.join(delimiter)] if !items.empty?
+
+      elsif obj.is_a? Array
+        items = []
+        obj.each do |value|
+          next if value.nil?
+
+          if explode
+            params[field_name] = [] if !params.key? field_name
+
+            params[field_name].append(val_to_string(value))
+          else
+            items.append(val_to_string(value))
+          end
+        end
+        params[field_name] = items.map(&:to_s).join(delimiter) if !items.empty?
+
+      else
+        params[field_name] = val_to_string(obj)
+      end
+      params
+    end
+
+    sig { params(media_type: String, request: Object).returns([String, Object, T::Array[T::Array[Object]]]) }
+    def self.serialize_multipart_form(media_type, request)
+      form = []
+      request_fields = request.fields
+      request_fields.each do |field|
+        val = request.send(field.name)
+        next if val.nil?
+
+        field_metadata = field.metadata[:multipart_form]
+        next if field_metadata.nil?
+
+        if field_metadata[:file] == true
+          file_fields = val.fields
+
+          file_name = ''
+          field_name = field_metadata[:field_name]
+          content = nil
+
+          file_fields.each do |file_field|
+            file_metadata = file_field.metadata[:multipart_form]
+            next if file_metadata.nil?
+
+            if file_metadata[:content] == true
+              content = val.send(file_field.name)
+            else
+              file_name = val.send(file_field.name)
+            end
+          end
+          raise StandardError, 'invalid multipart/form-data file' if file_name == '' || content == nil?
+
+          form.append([field_name, [file_name, content]])
+        elsif field_metadata[:json] == true
+          to_append = [
+            field_metadata.fetch(:field_name, field.name), [
+              nil, ::Crystalline.to_json(val), 'application/json'
+            ]
+          ]
+          form.append(to_append)
+        else
+          field_name = field_metadata.fetch(
+            :field_name, field.name
+          )
+          if val.is_a? Array
+            val.each do |value|
+              next if value.nil?
+
+              form.append(
+                ["#{field_name}[]", [nil, val_to_string(value)]]
+              )
+            end
+          else
+            form.append([field_name, [nil, val_to_string(val)]])
+          end
+        end
+      end
+      [media_type, nil, form]
+    end
+
+
+    sig do
+      params(field_name: Symbol, data: T.any(Object, T::Hash[Symbol, String]))
+        .returns(T::Hash[Symbol, Object])
+    end
+    def self.serialize_form_data(field_name, data)
+      get_form_field_name = lambda do |obj_field|
+        obj_param_metadata = obj_field.metadata[:form]
+
+        return '' if obj_param_metadata.nil?
+
+        return obj_param_metadata.fetch(:field_name, obj_field.name)
+      end
+
+      form = {}
+      if data.respond_to? :fields
+        data.fields.each do |field|
+          val = data.send(field.name)
+          next if val.nil?
+
+          metadata = field.metadata[:form]
+
+          next if metadata.nil?
+
+          field_name = metadata.fetch(:field_name, field.name)
+
+          if metadata[:json]
+            form[field_name] = ::Crystalline.to_json(val)
+          else
+            if metadata.fetch(:style, 'form') == 'form'
+              form = form.merge(
+                _populate_form(
+                  field_name, metadata.fetch(:explode, true), val, ',', &get_form_field_name
+                )
+              )
+            else
+              raise StandardError, "Invalid form style for field #{field.name}"
+            end
+          end
+        end
+      elsif data.is_a? Hash
+        data.each do |key, value|
+          form[key] = [val_to_string(value)]
+        end
+      else
+        raise StandardError, "Invalid request body type for field #{field_name}"
+      end
+
+      form
+    end
+  end
+end

data/lib/ding_sdk/utils/headers.rb

@@ -0,0 +1,79 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'sorbet-runtime'
+require 'base64'
+
+module DingSDK
+  module Utils
+    extend T::Sig
+
+    sig { params(headers_params: Object, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(T::Hash[Symbol, String]) }
+    def self.get_headers(headers_params, gbls = nil)
+      return {} if headers_params.nil?
+
+      headers = {}
+      param_fields = headers_params.fields
+      param_fields.each do |f|
+        metadata = f.metadata[:header]
+        next if metadata.nil?
+
+        value = _populate_from_globals(f.name, headers_params&.send(f.name), 'header', gbls)
+        value = _serialize_header(metadata.fetch(:explode, false), value)
+        headers[metadata.fetch(:field_name, f.name)] = value if !value.empty?
+      end
+      headers
+    end
+
+    sig { params(explode: T::Boolean, obj: Object).returns(String) }
+    def self._serialize_header(explode, obj)
+      return '' if obj.nil?
+
+      if obj.respond_to? :fields
+        items = []
+        obj_fields = obj.fields
+        obj_fields.each do |obj_field|
+          obj_param_metadata = obj_field.metadata[:header]
+          next if obj_param_metadata.nil?
+
+          obj_field_name = obj_param_metadata.fetch(:field_name, obj_field.name)
+          next if obj_field_name == ''
+
+          val = obj.send(obj_field.name)
+          next if val.nil?
+
+          if explode
+            items.append("#{obj_field_name}=#{val_to_string(val)}")
+          else
+            items.append(obj_field_name)
+            items.append(val_to_string(val))
+          end
+        end
+
+        items.join(',') if !items.empty?
+      elsif obj.is_a? Hash
+        items = []
+        obj.each do |key, value|
+          next if value.nil?
+
+          if explode
+            items.append("#{key}=#{val_to_string(value)}")
+          else
+            items.append(key)
+            items.append(val_to_string(value))
+          end
+        end
+
+        items.join(',') if !items.empty?
+      elsif obj.is_a? Array
+        items = obj.filter { |v| !v.nil? }.map { |v| val_to_string(v) }.join(',')
+      else
+        val_to_string(obj)
+      end
+    end
+  end
+end

data/lib/ding_sdk/utils/query_params.rb

@@ -0,0 +1,133 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'sorbet-runtime'
+require 'base64'
+
+module DingSDK
+  module Utils
+    extend T::Sig
+
+    sig { params(clazz: Class, query_params: Object, url_override: T.nilable(::String), gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(T::Hash[Symbol, T::Array[String]]) }
+    def self.get_query_params(clazz, query_params, url_override = nil, gbls = nil)
+      parsed_params = {}
+      if !url_override.nil?
+        parsed_url = URI.parse url_override
+        parsed_params = CGI.parse parsed_url.query
+      end
+      params = {}
+      param_fields = clazz.fields
+      param_fields.each do |f|
+        request_metadata = f.metadata[:request]
+        next if !request_metadata.nil?
+
+        metadata = f.metadata[:query_param]
+        next if metadata.nil?
+
+        param_name = f.name
+        value = query_params&.send(param_name.to_sym)
+        value = _populate_from_globals(param_name, value, 'queryParam', gbls)
+
+        f_name = metadata[:field_name]
+        serialization = metadata.fetch(:serialization, '')
+        if serialization != ''
+          params = params.merge _get_serialized_params(
+            metadata, f_name, value
+          )
+        else
+          style = metadata.fetch(:style, 'form')
+          case style
+          when 'deepObject'
+            params = params.merge _get_deep_object_query_params(
+              metadata, f_name, value
+            )
+          when 'form'
+            params = params.merge _get_delimited_query_params(
+              metadata, f_name, value, ','
+            )
+          when 'pipeDelimited'
+            params = params.merge _get_delimited_query_params(
+              metadata, f_name, value, '|'
+            )
+          else
+            raise StandardError, 'not yet implemented'
+          end
+        end
+      end
+      params.merge parsed_params
+    end
+
+    sig do
+      params(metadata: T::Hash[Symbol, String], field_name: String, obj: Object)
+        .returns(T::Hash[Symbol, T::Array[String]])
+    end
+    def self._get_deep_object_query_params(metadata, field_name, obj)
+      params = {}
+
+      return params if obj.nil?
+
+      if obj.respond_to? :fields
+        obj_fields = obj.fields
+        obj_fields.each do |obj_field|
+          obj_param_metadata = obj_field.metadata[:query_param]
+          next if obj_param_metadata.nil?
+
+          val = obj.send(obj_field.name)
+          next if val.nil?
+
+          key = "#{metadata.fetch(:field_name, field_name)}[#{obj_param_metadata.fetch(:field_name, obj_field.name)}]"
+          if val.is_a? Array
+            val.each do |v|
+              next if v.nil?
+
+              params[key] = [] if !params.include? key
+
+              params[key] << val_to_string(v)
+            end
+          else
+            params[key] = [val_to_string(val)]
+          end
+        end
+      elsif obj.is_a? Hash
+        obj.each do |key, value|
+          next if value.nil?
+
+          param_key = "#{metadata.fetch(:field_name, field_name)}[#{key}]"
+          if value.is_a? Array
+            value.each do |val|
+              next if val.nil?
+
+              params[param_key] = [] if !params.include? param_key
+
+              params[param_key].append(val_to_string(val))
+            end
+          else
+            params[param_key] = [val_to_string(value)]
+          end
+        end
+      end
+      params
+    end
+
+
+    sig do
+      params(metadata: T::Hash[Symbol, String], field_name: String, obj: Object, delimiter: String)
+        .returns(T::Hash[Symbol, T::Array[String]])
+    end
+    def self._get_delimited_query_params(metadata, field_name, obj, delimiter)
+      get_query_param_field_name = lambda do |obj_field|
+        obj_param_metadata = obj_field.metadata[:query_param]
+
+        return '' if obj_param_metadata.nil?
+
+        return obj_param_metadata.fetch(:field_name, obj_field.name)
+      end
+
+      _populate_form(field_name, metadata.fetch(:explode, true), obj, delimiter, &get_query_param_field_name)
+    end
+  end
+end

data/lib/ding_sdk/utils/request_bodies.rb

@@ -0,0 +1,62 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'sorbet-runtime'
+require 'base64'
+
+module DingSDK
+  module Utils
+    extend T::Sig
+
+    SERIALIZATION_METHOD_TO_CONTENT_TYPE = {
+        'json': 'application/json',
+        'form': 'application/x-www-form-urlencoded',
+        'multipart': 'multipart/form-data',
+        'raw': 'application/octet-stream',
+        'string': 'text/plain'
+      }.freeze
+  
+    sig do
+      params(request: Object, nullable: T::Boolean, optional: T::Boolean, request_field_name: Symbol, serialization_method: Symbol)
+        .returns([String, Object, Object])
+    end
+    def self.serialize_request_body(request, nullable, optional, request_field_name, serialization_method)
+      return ['', nil, nil] if request.nil? && !nullable && optional
+
+      return serialize_content_type(request_field_name, SERIALIZATION_METHOD_TO_CONTENT_TYPE[serialization_method], request) if !request.respond_to?(:fields) || !request.respond_to?(request_field_name)
+
+      request_val = request.send(request_field_name)
+
+      request_fields = request.fields
+      request_metadata = nil
+      request_fields.each do |f|
+        if f.name == request_field_name
+          request_metadata = f.metadata[:request]
+          break
+        end
+      end
+      raise StandardError, 'invalid request type' if request_metadata.nil?
+
+      serialize_content_type(
+        :request, request_metadata.fetch(:media_type, 'application/octet-stream'), request_val
+      )
+    end
+
+    sig do
+      params(field_name: Symbol, media_type: String, request: Object)
+        .returns([String, Object, T.nilable(T::Array[T::Array[Object]])])
+    end
+    def self.serialize_content_type(field_name, media_type, request)
+      return media_type, ::Crystalline.to_json(request), nil if media_type.match('(application|text)\/.*?\+*json.*')
+      return serialize_multipart_form(media_type, request) if media_type.match('multipart\/.*')
+      return media_type, serialize_form_data(field_name, request), nil if media_type.match('application\/x-www-form-urlencoded.*')
+      return media_type, request, nil if request.is_a?(String) || request.is_a?(Array)
+
+      raise StandardError, "invalid request body type #{type(request)} for mediaType {metadata['media_type']}"
+    end
+  end
+end

data/lib/ding_sdk/utils/security.rb

@@ -0,0 +1,133 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'sorbet-runtime'
+require 'base64'
+
+module DingSDK
+  module Utils
+    extend T::Sig
+
+    sig { params(req: Faraday::Request, security: Object).void }
+    def self.configure_request_security(req, security)
+      return if security.nil?
+      sec_fields = security.fields
+      sec_fields.each do |sec_field|
+        value = security.send(sec_field.name)
+        next if value.nil?
+
+        metadata = sec_field.metadata[:security]
+        next if metadata.nil?
+
+        _parse_security_option(req, value) if metadata[:option]
+
+        if metadata[:scheme]
+          # Special case for basic auth which could be a flattened struct
+          if metadata[:sub_type] == 'basic' && !value.respond_to?(:fields)
+            _parse_security_scheme(req, metadata, security)
+          else
+            _parse_security_scheme(req, metadata, value)
+          end
+        end
+      end
+    end
+
+    sig { params(req: Faraday::Request, option: Object).void }
+    def self._parse_security_option(req, option)
+      opt_fields = option.fields
+      opt_fields.each do |opt_field|
+        metadata = opt_field.metadata[:security]
+        next if metadata.nil? || !metadata.include?(:scheme)
+
+        _parse_security_scheme(req, metadata, option.send(opt_field.name))
+      end
+    end
+
+    sig { params(req: Faraday::Request, scheme_metadata: T::Hash[Symbol, String], scheme: Object).void }
+    def self._parse_security_scheme(req, scheme_metadata, scheme)
+      scheme_type = scheme_metadata[:type]
+      sub_type = scheme_metadata[:sub_type]
+
+      if scheme.respond_to? :fields
+        if scheme_type == 'http' && sub_type == 'basic'
+          _parse_basic_auth_scheme(req, scheme)
+          return
+        end
+
+        scheme_fields = scheme.fields
+        scheme_fields.each do |field|
+          metadata = field.metadata[:security]
+          next if metadata.nil? || metadata[:field_name].nil?
+
+          value = scheme.send(field.name)
+          _parse_security_scheme_value(req, scheme_metadata, metadata, value)
+        end
+      else
+        _parse_security_scheme_value(req, scheme_metadata, scheme_metadata, scheme)
+      end
+    end
+
+    sig do
+      params(req: Faraday::Request, scheme_metadata: T::Hash[Symbol, String],
+             security_metadata: T::Hash[Symbol, String], value: Object).void
+    end
+    def self._parse_security_scheme_value(req, scheme_metadata, security_metadata, value)
+      scheme_type = scheme_metadata[:type]
+      sub_type = scheme_metadata[:sub_type]
+
+      header_name = security_metadata[:field_name]
+
+      case scheme_type
+      when 'apiKey'
+        case sub_type
+        when 'header'
+          req.headers[header_name] = value
+        when 'query'
+          req.params[header_name] = value
+        when 'cookie'
+          req.cookies[header_name] = value
+        else
+          raise StandardError, 'not supported'
+        end
+      when 'openIdConnect'
+        req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
+      when 'oauth2'
+        req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
+      when 'http'
+        if sub_type == 'bearer'
+          req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
+        elsif sub_type != 'custom'
+          raise StandardError, 'not supported'
+        end
+      else
+        raise StandardError, 'not supported'
+      end
+    end
+
+    sig { params(req: Faraday::Request, scheme: Object).void }
+    def self._parse_basic_auth_scheme(req, scheme)
+      username, password = ''
+
+      scheme_fields = scheme.fields
+      scheme_fields.each do |scheme_field|
+        metadata = scheme_field.metadata[:security]
+        next if metadata.nil? || !metadata.include?(:field_name)
+
+        field_name = metadata[:field_name]
+        value = scheme.send(scheme_field.name)
+
+        username = value if field_name == 'username'
+        password = value if field_name == 'password'
+      end
+
+      data = "#{username}:#{password}".encode
+      # Use strict_encode, because encode adds newlines after 60 chars
+      # https://docs.ruby-lang.org/en/3.0/Base64.html#method-i-encode64
+      req.headers['Authorization'] = "Basic #{Base64.strict_encode64(data)}"
+    end
+  end
+end

data/lib/ding_sdk/utils/url.rb

@@ -0,0 +1,102 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday/retry'
+require 'sorbet-runtime'
+
+module DingSDK
+  module Utils
+    sig { params(clazz: Class, server_url: String, path: String, path_params: Object, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(String) }
+    def self.generate_url(clazz, server_url, path, path_params, gbls = nil)
+      clazz.fields.each do |f|
+        param_metadata = f.metadata[:path_param]
+        next if param_metadata.nil?
+
+        if param_metadata.fetch(:style, 'simple') == 'simple'
+          param = path_params.send(f.name) if !path_params.nil?
+          param = _populate_from_globals(f.name, param, 'pathParam', gbls)
+        end
+
+        f_name = param_metadata.fetch(:field_name, f.name)
+        serialization = param_metadata.fetch(:serialization, '')
+        if serialization != ''
+          serialized_params = _get_serialized_params(param_metadata, f_name, param)
+          serialized_params.each do |k, v|
+            path = path.sub("{#{k}}", v)
+          end
+        else
+          if param.is_a? Array
+            pp_vals = []
+            param.each do |pp_val|
+              pp_vals.append(pp_val.to_s)
+            end
+            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
+          elsif param.is_a? Hash
+            pp_vals = []
+            param.each do |pp_key, pp_val|
+              value = val_to_string(pp_val)
+
+              if param_metadata.fetch(:explode, false)
+                pp_vals.append("#{pp_key}=#{value}")
+              else
+                pp_vals.append("#{pp_key},#{value}")
+              end
+            end
+            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
+          elsif !(param.is_a?(String) || param.is_a?(Integer) ||
+            param.is_a?(Float) || param.is_a?(Complex) || param.is_a?(TrueClass) ||
+            param.is_a?(FalseClass))
+            pp_vals = []
+            attrs = param.fields.filter { |field| field.name && param.respond_to?(field.name.to_sym) }.map(&:name)
+            attrs.each do |attr|
+              field = param.field(attr)
+
+              param_value_metadata = field.metadata[:path_param]
+
+              next if param_value_metadata.nil?
+
+              parm_name = param_value_metadata.fetch(:field_name, f.name)
+
+              param_field_val = param.send(attr)
+
+              if param_field_val.is_a? T::Enum
+                param_field_val = param_field_val.serialize
+              elsif param_field_val.is_a? DateTime
+                param_field_val = param_field_val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+              end
+              if !field.nil? && T::Utils::Nilable.is_union_with_nilclass(field.type) && param_field_val.nil?
+                next
+              elsif param_metadata.fetch(:explode, false)
+                pp_vals.append("#{parm_name}=#{param_field_val}")
+              else
+                pp_vals.append("#{parm_name},#{param_field_val}")
+              end
+            end
+            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
+          else
+            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", param.to_s)
+          end
+        end
+      end
+
+      server_url.delete_suffix('/') + path
+    end
+
+    sig { params(url_with_params: String, params: T::Hash[Symbol, String]).returns(String) }
+    def self.template_url(url_with_params, params)
+      params.each do |key, value|
+        if value.respond_to? :serialize
+          val_str = value.serialize
+        else
+          val_str = value
+        end
+        url_with_params = url_with_params.gsub("{#{key}}", val_str)
+      end
+
+      url_with_params
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ding_sdk
 version: !ruby/object:Gem::Version
-  version: 0.26.36
+  version: 0.26.37
 platform: ruby
 authors:
 - Ding
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-06-04 00:00:00.000000000 Z
+date: 2025-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -242,7 +242,13 @@ files:
 - lib/ding_sdk/sdk_hooks/hooks.rb
 - lib/ding_sdk/sdk_hooks/types.rb
 - lib/ding_sdk/sdkconfiguration.rb
+- lib/ding_sdk/utils/forms.rb
+- lib/ding_sdk/utils/headers.rb
+- lib/ding_sdk/utils/query_params.rb
+- lib/ding_sdk/utils/request_bodies.rb
 - lib/ding_sdk/utils/retries.rb
+- lib/ding_sdk/utils/security.rb
+- lib/ding_sdk/utils/url.rb
 - lib/ding_sdk/utils/utils.rb
 homepage: https://github.com/ding-live/ding-ruby.git
 licenses: