From 5e5200f749b690e18a1cbba9ef65ba44410b444a Mon Sep 17 00:00:00 2001
From: Juan Calderon-Perez <835733+gaby@users.noreply.github.com>
Date: Thu, 12 Dec 2024 22:47:29 -0500
Subject: [PATCH] Update client package inline documentation

---
 client/client.go    | 295 +++++++++++++--------------------
 client/cookiejar.go |  86 +++++-----
 client/core.go      | 102 +++++-------
 client/hooks.go     |  91 +++++------
 client/request.go   | 389 +++++++++++++++++++-------------------------
 client/response.go  |  73 ++++-----
 6 files changed, 443 insertions(+), 593 deletions(-)

diff --git a/client/client.go b/client/client.go
index 2c4086aed3..fc9171c8ab 100644
--- a/client/client.go
+++ b/client/client.go
@@ -24,16 +24,13 @@ import (
 
 var ErrFailedToAppendCert = errors.New("failed to append certificate")
 
-// The Client is used to create a Fiber Client with
-// client-level settings that apply to all requests
-// raise from the client.
+// Client is used to create a Fiber client with client-level settings that
+// apply to all requests made by the client.
 //
-// Fiber Client also provides an option to override
-// or merge most of the client settings at the request.
+// The Fiber client also provides an option to override or merge most of the
+// client settings at the request level.
 type Client struct {
-	// logger
-	logger log.CommonLogger
-
+	logger   log.CommonLogger
 	fasthttp *fasthttp.Client
 
 	header  *Header
@@ -48,45 +45,32 @@ type Client struct {
 	cborMarshal   utils.CBORMarshal
 	cborUnmarshal utils.CBORUnmarshal
 
-	cookieJar *CookieJar
-
-	// retry
-	retryConfig *RetryConfig
-
-	baseURL   string
-	userAgent string
-	referer   string
-
-	// user defined request hooks
-	userRequestHooks []RequestHook
-
-	// client package defined request hooks
+	cookieJar    *CookieJar
+	retryConfig  *RetryConfig
+	baseURL      string
+	userAgent    string
+	referer      string
+	userRequestHooks    []RequestHook
 	builtinRequestHooks []RequestHook
-
-	// user defined response hooks
-	userResponseHooks []ResponseHook
-
-	// client package defined response hooks
+	userResponseHooks   []ResponseHook
 	builtinResponseHooks []ResponseHook
 
 	timeout time.Duration
-
-	mu sync.RWMutex
-
-	debug bool
+	mu      sync.RWMutex
+	debug   bool
 }
 
-// R raise a request from the client.
+// R creates a new Request associated with the client.
 func (c *Client) R() *Request {
 	return AcquireRequest().SetClient(c)
 }
 
-// RequestHook Request returns user-defined request hooks.
+// RequestHook returns the user-defined request hooks.
 func (c *Client) RequestHook() []RequestHook {
 	return c.userRequestHooks
 }
 
-// AddRequestHook Add user-defined request hooks.
+// AddRequestHook adds user-defined request hooks.
 func (c *Client) AddRequestHook(h ...RequestHook) *Client {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -95,12 +79,12 @@ func (c *Client) AddRequestHook(h ...RequestHook) *Client {
 	return c
 }
 
-// ResponseHook return user-define response hooks.
+// ResponseHook returns the user-defined response hooks.
 func (c *Client) ResponseHook() []ResponseHook {
 	return c.userResponseHooks
 }
 
-// AddResponseHook Add user-defined response hooks.
+// AddResponseHook adds user-defined response hooks.
 func (c *Client) AddResponseHook(h ...ResponseHook) *Client {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -109,74 +93,74 @@ func (c *Client) AddResponseHook(h ...ResponseHook) *Client {
 	return c
 }
 
-// JSONMarshal returns json marshal function in Core.
+// JSONMarshal returns the JSON marshal function used by the client.
 func (c *Client) JSONMarshal() utils.JSONMarshal {
 	return c.jsonMarshal
 }
 
-// SetJSONMarshal sets the JSON encoder.
+// SetJSONMarshal sets the JSON marshal function to use.
 func (c *Client) SetJSONMarshal(f utils.JSONMarshal) *Client {
 	c.jsonMarshal = f
 	return c
 }
 
-// JSONUnmarshal returns json unmarshal function in Core.
+// JSONUnmarshal returns the JSON unmarshal function used by the client.
 func (c *Client) JSONUnmarshal() utils.JSONUnmarshal {
 	return c.jsonUnmarshal
 }
 
-// Set json decoder.
+// SetJSONUnmarshal sets the JSON unmarshal function to use.
 func (c *Client) SetJSONUnmarshal(f utils.JSONUnmarshal) *Client {
 	c.jsonUnmarshal = f
 	return c
 }
 
-// XMLMarshal returns xml marshal function in Core.
+// XMLMarshal returns the XML marshal function used by the client.
 func (c *Client) XMLMarshal() utils.XMLMarshal {
 	return c.xmlMarshal
 }
 
-// SetXMLMarshal Set xml encoder.
+// SetXMLMarshal sets the XML marshal function to use.
 func (c *Client) SetXMLMarshal(f utils.XMLMarshal) *Client {
 	c.xmlMarshal = f
 	return c
 }
 
-// XMLUnmarshal returns xml unmarshal function in Core.
+// XMLUnmarshal returns the XML unmarshal function used by the client.
 func (c *Client) XMLUnmarshal() utils.XMLUnmarshal {
 	return c.xmlUnmarshal
 }
 
-// SetXMLUnmarshal Set xml decoder.
+// SetXMLUnmarshal sets the XML unmarshal function to use.
 func (c *Client) SetXMLUnmarshal(f utils.XMLUnmarshal) *Client {
 	c.xmlUnmarshal = f
 	return c
 }
 
-// CBORMarshal returns CBOR marshal function in Core.
+// CBORMarshal returns the CBOR marshal function used by the client.
 func (c *Client) CBORMarshal() utils.CBORMarshal {
 	return c.cborMarshal
 }
 
-// SetCBORMarshal sets CBOR encoder.
+// SetCBORMarshal sets the CBOR marshal function to use.
 func (c *Client) SetCBORMarshal(f utils.CBORMarshal) *Client {
 	c.cborMarshal = f
 	return c
 }
 
-// CBORUnmarshal returns CBOR unmarshal function in Core.
+// CBORUnmarshal returns the CBOR unmarshal function used by the client.
 func (c *Client) CBORUnmarshal() utils.CBORUnmarshal {
 	return c.cborUnmarshal
 }
 
-// SetCBORUnmarshal sets CBOR decoder.
+// SetCBORUnmarshal sets the CBOR unmarshal function to use.
 func (c *Client) SetCBORUnmarshal(f utils.CBORUnmarshal) *Client {
 	c.cborUnmarshal = f
 	return c
 }
 
-// TLSConfig returns tlsConfig in client.
-// If client don't have tlsConfig, this function will init it.
+// TLSConfig returns the client's TLS configuration.
+// If none is set, it initializes a new one.
 func (c *Client) TLSConfig() *tls.Config {
 	if c.fasthttp.TLSConfig == nil {
 		c.fasthttp.TLSConfig = &tls.Config{
@@ -187,20 +171,20 @@ func (c *Client) TLSConfig() *tls.Config {
 	return c.fasthttp.TLSConfig
 }
 
-// SetTLSConfig sets tlsConfig in client.
+// SetTLSConfig sets the TLS configuration for the client.
 func (c *Client) SetTLSConfig(config *tls.Config) *Client {
 	c.fasthttp.TLSConfig = config
 	return c
 }
 
-// SetCertificates method sets client certificates into client.
+// SetCertificates adds certificates to the client's TLS configuration.
 func (c *Client) SetCertificates(certs ...tls.Certificate) *Client {
 	config := c.TLSConfig()
 	config.Certificates = append(config.Certificates, certs...)
 	return c
 }
 
-// SetRootCertificate adds one or more root certificates into client.
+// SetRootCertificate adds one or more root certificates to the client's TLS configuration.
 func (c *Client) SetRootCertificate(path string) *Client {
 	cleanPath := filepath.Clean(path)
 	file, err := os.Open(cleanPath)
@@ -230,7 +214,7 @@ func (c *Client) SetRootCertificate(path string) *Client {
 	return c
 }
 
-// SetRootCertificateFromString method adds one or more root certificates into client.
+// SetRootCertificateFromString adds one or more root certificates from a string to the client's TLS configuration.
 func (c *Client) SetRootCertificateFromString(pem string) *Client {
 	config := c.TLSConfig()
 
@@ -245,19 +229,18 @@ func (c *Client) SetRootCertificateFromString(pem string) *Client {
 	return c
 }
 
-// SetProxyURL sets proxy url in client. It will apply via core to hostclient.
+// SetProxyURL sets the proxy URL for the client. This affects all subsequent requests.
 func (c *Client) SetProxyURL(proxyURL string) error {
 	c.fasthttp.Dial = fasthttpproxy.FasthttpHTTPDialer(proxyURL)
-
 	return nil
 }
 
-// RetryConfig returns retry config in client.
+// RetryConfig returns the current retry configuration.
 func (c *Client) RetryConfig() *RetryConfig {
 	return c.retryConfig
 }
 
-// SetRetryConfig sets retry config in client which is impl by addon/retry package.
+// SetRetryConfig sets the retry configuration for the client.
 func (c *Client) SetRetryConfig(config *RetryConfig) *Client {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -266,58 +249,47 @@ func (c *Client) SetRetryConfig(config *RetryConfig) *Client {
 	return c
 }
 
-// BaseURL returns baseurl in Client instance.
+// BaseURL returns the client's base URL.
 func (c *Client) BaseURL() string {
 	return c.baseURL
 }
 
-// SetBaseURL Set baseUrl which is prefix of real url.
+// SetBaseURL sets the base URL prefix for all requests made by the client.
 func (c *Client) SetBaseURL(url string) *Client {
 	c.baseURL = url
 	return c
 }
 
-// Header method returns header value via key,
-// this method will visit all field in the header,
-// then sort them.
+// Header returns all header values associated with the provided key.
 func (c *Client) Header(key string) []string {
 	return c.header.PeekMultiple(key)
 }
 
-// AddHeader method adds a single header field and its value in the client instance.
-// These headers will be applied to all requests raised from this client instance.
-// Also, it can be overridden at request level header options.
+// AddHeader adds a single header field and its value to the client. These headers apply to all requests.
 func (c *Client) AddHeader(key, val string) *Client {
 	c.header.Add(key, val)
 	return c
 }
 
-// SetHeader method sets a single header field and its value in the client instance.
-// These headers will be applied to all requests raised from this client instance.
-// Also, it can be overridden at request level header options.
+// SetHeader sets a single header field and its value in the client.
 func (c *Client) SetHeader(key, val string) *Client {
 	c.header.Set(key, val)
 	return c
 }
 
-// AddHeaders method adds multiple headers field and its values at one go in the client instance.
-// These headers will be applied to all requests raised from this client instance. Also it can be
-// overridden at request level headers options.
+// AddHeaders adds multiple header fields and their values to the client.
 func (c *Client) AddHeaders(h map[string][]string) *Client {
 	c.header.AddHeaders(h)
 	return c
 }
 
-// SetHeaders method sets multiple headers field and its values at one go in the client instance.
-// These headers will be applied to all requests raised from this client instance. Also it can be
-// overridden at request level headers options.
+// SetHeaders sets multiple header fields and their values in the client.
 func (c *Client) SetHeaders(h map[string]string) *Client {
 	c.header.SetHeaders(h)
 	return c
 }
 
-// Param method returns params value via key,
-// this method will visit all field in the query param.
+// Param returns all values of the specified query parameter.
 func (c *Client) Param(key string) []string {
 	res := []string{}
 	tmp := c.params.PeekMulti(key)
@@ -328,47 +300,37 @@ func (c *Client) Param(key string) []string {
 	return res
 }
 
-// AddParam method adds a single query param field and its value in the client instance.
-// These params will be applied to all requests raised from this client instance.
-// Also, it can be overridden at request level param options.
+// AddParam adds a single query parameter and its value to the client.
 func (c *Client) AddParam(key, val string) *Client {
 	c.params.Add(key, val)
 	return c
 }
 
-// SetParam method sets a single query param field and its value in the client instance.
-// These params will be applied to all requests raised from this client instance.
-// Also, it can be overridden at request level param options.
+// SetParam sets a single query parameter and its value in the client.
 func (c *Client) SetParam(key, val string) *Client {
 	c.params.Set(key, val)
 	return c
 }
 
-// AddParams method adds multiple query params field and its values at one go in the client instance.
-// These params will be applied to all requests raised from this client instance. Also it can be
-// overridden at request level params options.
+// AddParams adds multiple query parameters and their values to the client.
 func (c *Client) AddParams(m map[string][]string) *Client {
 	c.params.AddParams(m)
 	return c
 }
 
-// SetParams method sets multiple params field and its values at one go in the client instance.
-// These params will be applied to all requests raised from this client instance. Also it can be
-// overridden at request level params options.
+// SetParams sets multiple query parameters and their values in the client.
 func (c *Client) SetParams(m map[string]string) *Client {
 	c.params.SetParams(m)
 	return c
 }
 
-// SetParamsWithStruct method sets multiple params field and its values at one go in the client instance.
-// These params will be applied to all requests raised from this client instance. Also it can be
-// overridden at request level params options.
+// SetParamsWithStruct sets multiple query parameters and their values using a struct.
 func (c *Client) SetParamsWithStruct(v any) *Client {
 	c.params.SetParamsWithStruct(v)
 	return c
 }
 
-// DelParams method deletes single or multiple params field and its values in client.
+// DelParams deletes one or more query parameters and their values from the client.
 func (c *Client) DelParams(key ...string) *Client {
 	for _, v := range key {
 		c.params.Del(v)
@@ -376,64 +338,51 @@ func (c *Client) DelParams(key ...string) *Client {
 	return c
 }
 
-// SetUserAgent method sets userAgent field and its value in the client instance.
-// This ua will be applied to all requests raised from this client instance.
-// Also it can be overridden at request level ua options.
+// SetUserAgent sets the User-Agent header for the client.
 func (c *Client) SetUserAgent(ua string) *Client {
 	c.userAgent = ua
 	return c
 }
 
-// SetReferer method sets referer field and its value in the client instance.
-// This referer will be applied to all requests raised from this client instance.
-// Also it can be overridden at request level referer options.
+// SetReferer sets the Referer header for the client.
 func (c *Client) SetReferer(r string) *Client {
 	c.referer = r
 	return c
 }
 
-// PathParam returns the path param be set in request instance.
-// if path param doesn't exist, return empty string.
+// PathParam returns the value of the specified path parameter. Returns an empty string if it does not exist.
 func (c *Client) PathParam(key string) string {
 	if val, ok := (*c.path)[key]; ok {
 		return val
 	}
-
 	return ""
 }
 
-// SetPathParam method sets a single path param field and its value in the client instance.
-// These path params will be applied to all requests raised from this client instance.
-// Also it can be overridden at request level path params options.
+// SetPathParam sets a single path parameter and its value in the client.
 func (c *Client) SetPathParam(key, val string) *Client {
 	c.path.SetParam(key, val)
 	return c
 }
 
-// SetPathParams method sets multiple path params field and its values at one go in the client instance.
-// These path params will be applied to all requests raised from this client instance. Also it can be
-// overridden at request level path params options.
+// SetPathParams sets multiple path parameters and their values in the client.
 func (c *Client) SetPathParams(m map[string]string) *Client {
 	c.path.SetParams(m)
 	return c
 }
 
-// SetPathParamsWithStruct method sets multiple path params field and its values at one go in the client instance.
-// These path params will be applied to all requests raised from this client instance. Also it can be
-// overridden at request level path params options.
+// SetPathParamsWithStruct sets multiple path parameters and their values using a struct.
 func (c *Client) SetPathParamsWithStruct(v any) *Client {
 	c.path.SetParamsWithStruct(v)
 	return c
 }
 
-// DelPathParams method deletes single or multiple path params field and its values in client.
+// DelPathParams deletes one or more path parameters and their values from the client.
 func (c *Client) DelPathParams(key ...string) *Client {
 	c.path.DelParams(key...)
 	return c
 }
 
-// Cookie returns the cookie be set in request instance.
-// if cookie doesn't exist, return empty string.
+// Cookie returns the value of the specified cookie. Returns an empty string if it does not exist.
 func (c *Client) Cookie(key string) string {
 	if val, ok := (*c.cookies)[key]; ok {
 		return val
@@ -441,127 +390,111 @@ func (c *Client) Cookie(key string) string {
 	return ""
 }
 
-// SetCookie method sets a single cookie field and its value in the client instance.
-// These cookies will be applied to all requests raised from this client instance.
-// Also it can be overridden at request level cookie options.
+// SetCookie sets a single cookie and its value in the client.
 func (c *Client) SetCookie(key, val string) *Client {
 	c.cookies.SetCookie(key, val)
 	return c
 }
 
-// SetCookies method sets multiple cookies field and its values at one go in the client instance.
-// These cookies will be applied to all requests raised from this client instance. Also it can be
-// overridden at request level cookie options.
+// SetCookies sets multiple cookies and their values in the client.
 func (c *Client) SetCookies(m map[string]string) *Client {
 	c.cookies.SetCookies(m)
 	return c
 }
 
-// SetCookiesWithStruct method sets multiple cookies field and its values at one go in the client instance.
-// These cookies will be applied to all requests raised from this client instance. Also it can be
-// overridden at request level cookies options.
+// SetCookiesWithStruct sets multiple cookies and their values using a struct.
 func (c *Client) SetCookiesWithStruct(v any) *Client {
 	c.cookies.SetCookiesWithStruct(v)
 	return c
 }
 
-// DelCookies method deletes single or multiple cookies field and its values in client.
+// DelCookies deletes one or more cookies and their values from the client.
 func (c *Client) DelCookies(key ...string) *Client {
 	c.cookies.DelCookies(key...)
 	return c
 }
 
-// SetTimeout method sets timeout val in client instance.
-// This value will be applied to all requests raised from this client instance.
-// Also, it can be overridden at request level timeout options.
+// SetTimeout sets the timeout value for the client. This applies to all requests unless overridden at the request level.
 func (c *Client) SetTimeout(t time.Duration) *Client {
 	c.timeout = t
 	return c
 }
 
-// Debug enable log debug level output.
+// Debug enables debug-level logging output.
 func (c *Client) Debug() *Client {
 	c.debug = true
 	return c
 }
 
-// DisableDebug disables log debug level output.
+// DisableDebug disables debug-level logging output.
 func (c *Client) DisableDebug() *Client {
 	c.debug = false
 	return c
 }
 
-// SetCookieJar sets cookie jar in client instance.
+// SetCookieJar sets the cookie jar for the client.
 func (c *Client) SetCookieJar(cookieJar *CookieJar) *Client {
 	c.cookieJar = cookieJar
 	return c
 }
 
-// Get provide an API like axios which send get request.
+// Get sends a GET request to the specified URL, similar to axios.
 func (c *Client) Get(url string, cfg ...Config) (*Response, error) {
 	req := AcquireRequest().SetClient(c)
 	setConfigToRequest(req, cfg...)
-
 	return req.Get(url)
 }
 
-// Post provide an API like axios which send post request.
+// Post sends a POST request to the specified URL, similar to axios.
 func (c *Client) Post(url string, cfg ...Config) (*Response, error) {
 	req := AcquireRequest().SetClient(c)
 	setConfigToRequest(req, cfg...)
-
 	return req.Post(url)
 }
 
-// Head provide a API like axios which send head request.
+// Head sends a HEAD request to the specified URL, similar to axios.
 func (c *Client) Head(url string, cfg ...Config) (*Response, error) {
 	req := AcquireRequest().SetClient(c)
 	setConfigToRequest(req, cfg...)
-
 	return req.Head(url)
 }
 
-// Put provide an API like axios which send put request.
+// Put sends a PUT request to the specified URL, similar to axios.
 func (c *Client) Put(url string, cfg ...Config) (*Response, error) {
 	req := AcquireRequest().SetClient(c)
 	setConfigToRequest(req, cfg...)
-
 	return req.Put(url)
 }
 
-// Delete provide an API like axios which send delete request.
+// Delete sends a DELETE request to the specified URL, similar to axios.
 func (c *Client) Delete(url string, cfg ...Config) (*Response, error) {
 	req := AcquireRequest().SetClient(c)
 	setConfigToRequest(req, cfg...)
-
 	return req.Delete(url)
 }
 
-// Options provide an API like axios which send options request.
+// Options sends an OPTIONS request to the specified URL, similar to axios.
 func (c *Client) Options(url string, cfg ...Config) (*Response, error) {
 	req := AcquireRequest().SetClient(c)
 	setConfigToRequest(req, cfg...)
-
 	return req.Options(url)
 }
 
-// Patch provide an API like axios which send patch request.
+// Patch sends a PATCH request to the specified URL, similar to axios.
 func (c *Client) Patch(url string, cfg ...Config) (*Response, error) {
 	req := AcquireRequest().SetClient(c)
 	setConfigToRequest(req, cfg...)
-
 	return req.Patch(url)
 }
 
-// Custom provide an API like axios which send custom request.
+// Custom sends a request with a custom method to the specified URL, similar to axios.
 func (c *Client) Custom(url, method string, cfg ...Config) (*Response, error) {
 	req := AcquireRequest().SetClient(c)
 	setConfigToRequest(req, cfg...)
-
 	return req.Custom(url, method)
 }
 
-// SetDial sets dial function in client.
+// SetDial sets the custom dial function for the client.
 func (c *Client) SetDial(dial fasthttp.DialFunc) *Client {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -570,7 +503,7 @@ func (c *Client) SetDial(dial fasthttp.DialFunc) *Client {
 	return c
 }
 
-// SetLogger sets logger instance in client.
+// SetLogger sets the logger instance used by the client.
 func (c *Client) SetLogger(logger log.CommonLogger) *Client {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -579,12 +512,12 @@ func (c *Client) SetLogger(logger log.CommonLogger) *Client {
 	return c
 }
 
-// Logger returns logger instance of client.
+// Logger returns the logger instance used by the client.
 func (c *Client) Logger() log.CommonLogger {
 	return c.logger
 }
 
-// Reset clears the Client object
+// Reset resets the client to its default state, clearing most configurations.
 func (c *Client) Reset() {
 	c.fasthttp = &fasthttp.Client{}
 	c.baseURL = ""
@@ -605,31 +538,25 @@ func (c *Client) Reset() {
 	c.params.Reset()
 }
 
-// Config for easy to set the request parameters, it should be
-// noted that when setting the request body will use JSON as
-// the default serialization mechanism, while the priority of
-// Body is higher than FormData, and the priority of FormData
-// is higher than File.
+// Config is used to easily set request parameters. Note that when setting a request body,
+// JSON is used as the default serialization mechanism. The priority is:
+// Body > FormData > File.
 type Config struct {
-	Ctx context.Context //nolint:containedctx // It's needed to be stored in the config.
-
-	Body      any
-	Header    map[string]string
-	Param     map[string]string
-	Cookie    map[string]string
-	PathParam map[string]string
-
-	FormData map[string]string
-
-	UserAgent string
-	Referer   string
-	File      []*File
-
-	Timeout      time.Duration
+	Ctx         context.Context //nolint:containedctx // It's needed to be stored in the config.
+	Body        any
+	Header      map[string]string
+	Param       map[string]string
+	Cookie      map[string]string
+	PathParam   map[string]string
+	FormData    map[string]string
+	UserAgent   string
+	Referer     string
+	File        []*File
+	Timeout     time.Duration
 	MaxRedirects int
 }
 
-// setConfigToRequest Set the parameters passed via Config to Request.
+// setConfigToRequest sets the parameters passed via Config to the Request.
 func setConfigToRequest(req *Request, config ...Config) {
 	if len(config) == 0 {
 		return
@@ -694,21 +621,19 @@ var (
 	defaultUserAgent = "fiber"
 )
 
-// init acquire a default client.
 func init() {
 	defaultClient = New()
 }
 
 // New creates and returns a new Client object.
 func New() *Client {
-	// FOllOW-UP performance optimization
-	// trie to use a pool to reduce the cost of memory allocation
-	// for the fiber client and the fasthttp client
-	// if possible also for other structs -> request header, cookie, query param, path param...
+	// Follow-up performance optimizations:
+	// Try to use a pool to reduce the memory allocation cost for the Fiber client and the fasthttp client.
+	// If possible, also consider pooling other structs (e.g., request headers, cookies, query parameters, path parameters).
 	return NewWithClient(&fasthttp.Client{})
 }
 
-// NewWithClient creates and returns a new Client object from an existing client.
+// NewWithClient creates and returns a new Client object from an existing fasthttp.Client.
 func NewWithClient(c *fasthttp.Client) *Client {
 	if c == nil {
 		panic("fasthttp.Client must not be nil")
@@ -738,12 +663,12 @@ func NewWithClient(c *fasthttp.Client) *Client {
 	}
 }
 
-// C get default client.
+// C returns the default client.
 func C() *Client {
 	return defaultClient
 }
 
-// Replace the defaultClient, the returned function can undo.
+// Replace replaces the defaultClient with a new one, returning a function to restore the old client.
 func Replace(c *Client) func() {
 	replaceMu.Lock()
 	defer replaceMu.Unlock()
@@ -759,37 +684,37 @@ func Replace(c *Client) func() {
 	}
 }
 
-// Get send a get request use defaultClient, a convenient method.
+// Get sends a GET request using the default client.
 func Get(url string, cfg ...Config) (*Response, error) {
 	return C().Get(url, cfg...)
 }
 
-// Post send a post request use defaultClient, a convenient method.
+// Post sends a POST request using the default client.
 func Post(url string, cfg ...Config) (*Response, error) {
 	return C().Post(url, cfg...)
 }
 
-// Head send a head request use defaultClient, a convenient method.
+// Head sends a HEAD request using the default client.
 func Head(url string, cfg ...Config) (*Response, error) {
 	return C().Head(url, cfg...)
 }
 
-// Put send a put request use defaultClient, a convenient method.
+// Put sends a PUT request using the default client.
 func Put(url string, cfg ...Config) (*Response, error) {
 	return C().Put(url, cfg...)
 }
 
-// Delete send a delete request use defaultClient, a convenient method.
+// Delete sends a DELETE request using the default client.
 func Delete(url string, cfg ...Config) (*Response, error) {
 	return C().Delete(url, cfg...)
 }
 
-// Options send a options request use defaultClient, a convenient method.
+// Options sends an OPTIONS request using the default client.
 func Options(url string, cfg ...Config) (*Response, error) {
 	return C().Options(url, cfg...)
 }
 
-// Patch send a patch request use defaultClient, a convenient method.
+// Patch sends a PATCH request using the default client.
 func Patch(url string, cfg ...Config) (*Response, error) {
 	return C().Patch(url, cfg...)
 }
diff --git a/client/cookiejar.go b/client/cookiejar.go
index 834357fbbe..92669b70b0 100644
--- a/client/cookiejar.go
+++ b/client/cookiejar.go
@@ -1,4 +1,4 @@
-// The code has been taken from https://github.com/valyala/fasthttp/pull/526 originally.
+// The code was originally taken from https://github.com/valyala/fasthttp/pull/526.
 package client
 
 import (
@@ -18,7 +18,7 @@ var cookieJarPool = sync.Pool{
 	},
 }
 
-// AcquireCookieJar returns an empty CookieJar object from pool.
+// AcquireCookieJar returns an empty CookieJar object from the pool.
 func AcquireCookieJar() *CookieJar {
 	jar, ok := cookieJarPool.Get().(*CookieJar)
 	if !ok {
@@ -28,22 +28,23 @@ func AcquireCookieJar() *CookieJar {
 	return jar
 }
 
-// ReleaseCookieJar returns CookieJar to the pool.
+// ReleaseCookieJar returns a CookieJar object to the pool.
 func ReleaseCookieJar(c *CookieJar) {
 	c.Release()
 	cookieJarPool.Put(c)
 }
 
-// CookieJar manages cookie storage. It is used by the client to store cookies.
+// CookieJar manages cookie storage for the client. It stores cookies keyed by host.
 type CookieJar struct {
 	hostCookies map[string][]*fasthttp.Cookie
 	mu          sync.Mutex
 }
 
-// Get returns the cookies stored from a specific domain.
-// If there were no cookies related with host returned slice will be nil.
+// Get returns all cookies stored for a given URI. If there are no cookies for the
+// provided host, the returned slice will be nil.
 //
-// CookieJar keeps a copy of the cookies, so the returned cookies can be released safely.
+// The CookieJar keeps its own copies of cookies, so it is safe to release the returned
+// cookies after use.
 func (cj *CookieJar) Get(uri *fasthttp.URI) []*fasthttp.Cookie {
 	if uri == nil {
 		return nil
@@ -52,7 +53,7 @@ func (cj *CookieJar) Get(uri *fasthttp.URI) []*fasthttp.Cookie {
 	return cj.getByHostAndPath(uri.Host(), uri.Path())
 }
 
-// get returns the cookies stored from a specific host and path.
+// getByHostAndPath returns cookies stored for a specific host and path.
 func (cj *CookieJar) getByHostAndPath(host, path []byte) []*fasthttp.Cookie {
 	if cj.hostCookies == nil {
 		return nil
@@ -84,8 +85,7 @@ func (cj *CookieJar) getByHostAndPath(host, path []byte) []*fasthttp.Cookie {
 	return newCookies
 }
 
-// getCookiesByHost returns the cookies stored from a specific host.
-// If cookies are expired they will be deleted.
+// getCookiesByHost returns cookies stored for a specific host, removing any that have expired.
 func (cj *CookieJar) getCookiesByHost(host string) []*fasthttp.Cookie {
 	cj.mu.Lock()
 	defer cj.mu.Unlock()
@@ -95,7 +95,8 @@ func (cj *CookieJar) getCookiesByHost(host string) []*fasthttp.Cookie {
 
 	for i := 0; i < len(cookies); i++ {
 		c := cookies[i]
-		if !c.Expire().Equal(fasthttp.CookieExpireUnlimited) && c.Expire().Before(now) { // release cookie if expired
+		// Remove expired cookies.
+		if !c.Expire().Equal(fasthttp.CookieExpireUnlimited) && c.Expire().Before(now) {
 			cookies = append(cookies[:i], cookies[i+1:]...)
 			fasthttp.ReleaseCookie(c)
 			i--
@@ -105,23 +106,21 @@ func (cj *CookieJar) getCookiesByHost(host string) []*fasthttp.Cookie {
 	return cookies
 }
 
-// Set sets cookies for a specific host.
-// The host is get from uri.Host().
-// If the cookie key already exists it will be replaced by the new cookie value.
+// Set stores the given cookies for the specified URI host. If a cookie key already exists,
+// it will be replaced by the new cookie value.
 //
-// CookieJar keeps a copy of the cookies, so the parsed cookies can be released safely.
+// CookieJar stores copies of the provided cookies, so they may be safely released after use.
 func (cj *CookieJar) Set(uri *fasthttp.URI, cookies ...*fasthttp.Cookie) {
 	if uri == nil {
 		return
 	}
-
 	cj.SetByHost(uri.Host(), cookies...)
 }
 
-// SetByHost sets cookies for a specific host.
-// If the cookie key already exists it will be replaced by the new cookie value.
+// SetByHost stores the given cookies for the specified host. If a cookie key already exists,
+// it will be replaced by the new cookie value.
 //
-// CookieJar keeps a copy of the cookies, so the parsed cookies can be released safely.
+// CookieJar stores copies of the provided cookies, so they may be safely released after use.
 func (cj *CookieJar) SetByHost(host []byte, cookies ...*fasthttp.Cookie) {
 	hostStr := utils.UnsafeString(host)
 
@@ -134,26 +133,25 @@ func (cj *CookieJar) SetByHost(host []byte, cookies ...*fasthttp.Cookie) {
 
 	hostCookies, ok := cj.hostCookies[hostStr]
 	if !ok {
-		// If the key does not exist in the map, then we must make a copy for the key to avoid unsafe usage.
+		// If the key does not exist in the map, make a copy to avoid unsafe usage.
 		hostStr = string(host)
 	}
 
 	for _, cookie := range cookies {
-		c := searchCookieByKeyAndPath(cookie.Key(), cookie.Path(), hostCookies)
-		if c == nil {
-			// If the cookie does not exist in the slice, let's acquire new cookie and store it.
-			c = fasthttp.AcquireCookie()
-			hostCookies = append(hostCookies, c)
+		existing := searchCookieByKeyAndPath(cookie.Key(), cookie.Path(), hostCookies)
+		if existing == nil {
+			// If the cookie does not exist, acquire a new one.
+			existing = fasthttp.AcquireCookie()
+			hostCookies = append(hostCookies, existing)
 		}
-		c.CopyTo(cookie) // override cookie properties
+		existing.CopyTo(cookie) // Override cookie properties.
 	}
 	cj.hostCookies[hostStr] = hostCookies
 }
 
-// SetKeyValue sets a cookie by key and value for a specific host.
+// SetKeyValue sets a cookie for the specified host with the given key and value.
 //
-// This function prevents extra allocations by making repeated cookies
-// not being duplicated.
+// This function helps prevent extra allocations by avoiding duplication of repeated cookies.
 func (cj *CookieJar) SetKeyValue(host, key, value string) {
 	c := fasthttp.AcquireCookie()
 	c.SetKey(key)
@@ -162,10 +160,9 @@ func (cj *CookieJar) SetKeyValue(host, key, value string) {
 	cj.SetByHost(utils.UnsafeBytes(host), c)
 }
 
-// SetKeyValueBytes sets a cookie by key and value for a specific host.
+// SetKeyValueBytes sets a cookie for the specified host using byte slices for the key and value.
 //
-// This function prevents extra allocations by making repeated cookies
-// not being duplicated.
+// This function helps prevent extra allocations by avoiding duplication of repeated cookies.
 func (cj *CookieJar) SetKeyValueBytes(host string, key, value []byte) {
 	c := fasthttp.AcquireCookie()
 	c.SetKeyBytes(key)
@@ -174,17 +171,16 @@ func (cj *CookieJar) SetKeyValueBytes(host string, key, value []byte) {
 	cj.SetByHost(utils.UnsafeBytes(host), c)
 }
 
-// dumpCookiesToReq dumps the stored cookies to the request.
+// dumpCookiesToReq writes the stored cookies to the given request.
 func (cj *CookieJar) dumpCookiesToReq(req *fasthttp.Request) {
 	uri := req.URI()
-
 	cookies := cj.getByHostAndPath(uri.Host(), uri.Path())
 	for _, cookie := range cookies {
 		req.Header.SetCookieBytesKV(cookie.Key(), cookie.Value())
 	}
 }
 
-// parseCookiesFromResp parses the response cookies and stores them.
+// parseCookiesFromResp parses the cookies from the response and stores them for the specified host and path.
 func (cj *CookieJar) parseCookiesFromResp(host, path []byte, resp *fasthttp.Response) {
 	hostStr := utils.UnsafeString(host)
 
@@ -194,35 +190,36 @@ func (cj *CookieJar) parseCookiesFromResp(host, path []byte, resp *fasthttp.Resp
 	if cj.hostCookies == nil {
 		cj.hostCookies = make(map[string][]*fasthttp.Cookie)
 	}
+
 	cookies, ok := cj.hostCookies[hostStr]
 	if !ok {
-		// If the key does not exist in the map then
-		// we must make a copy for the key to avoid unsafe usage.
+		// If the key does not exist in the map, make a copy to avoid unsafe usage.
 		hostStr = string(host)
 	}
 
 	now := time.Now()
 	resp.Header.VisitAllCookie(func(key, value []byte) {
-		isCreated := false
+		created := false
 		c := searchCookieByKeyAndPath(key, path, cookies)
 		if c == nil {
-			c, isCreated = fasthttp.AcquireCookie(), true
+			c, created = fasthttp.AcquireCookie(), true
 		}
 
 		_ = c.ParseBytes(value) //nolint:errcheck // ignore error
 		if c.Expire().Equal(fasthttp.CookieExpireUnlimited) || c.Expire().After(now) {
 			cookies = append(cookies, c)
-		} else if isCreated {
+		} else if created {
 			fasthttp.ReleaseCookie(c)
 		}
 	})
 	cj.hostCookies[hostStr] = cookies
 }
 
-// Release releases all cookie values.
+// Release releases all stored cookies. After this, the CookieJar is empty.
 func (cj *CookieJar) Release() {
-	// FOllOW-UP performance optimization
-	// currently a race condition is found because the reset method modifies a value which is not a copy but a reference -> solution should be to make a copy
+	// FOLLOW-UP performance optimization:
+	// Currently, a race condition is found because the reset method modifies a value
+	// that is not a copy but a reference. A solution would be to make a copy.
 	// for _, v := range cj.hostCookies {
 	//	  for _, c := range v {
 	//		fasthttp.ReleaseCookie(c)
@@ -231,7 +228,7 @@ func (cj *CookieJar) Release() {
 	cj.hostCookies = nil
 }
 
-// searchCookieByKeyAndPath searches for a cookie by key and path.
+// searchCookieByKeyAndPath looks up a cookie by its key and path from the provided slice of cookies.
 func searchCookieByKeyAndPath(key, path []byte, cookies []*fasthttp.Cookie) *fasthttp.Cookie {
 	for _, c := range cookies {
 		if bytes.Equal(key, c.Key()) {
@@ -240,6 +237,5 @@ func searchCookieByKeyAndPath(key, path []byte, cookies []*fasthttp.Cookie) *fas
 			}
 		}
 	}
-
 	return nil
 }
diff --git a/client/core.go b/client/core.go
index 315d12d474..c669d3ac82 100644
--- a/client/core.go
+++ b/client/core.go
@@ -16,23 +16,21 @@ import (
 
 var boundary = "--FiberFormBoundary"
 
-// RequestHook is a function that receives Agent and Request,
-// it can change the data in Request and Agent.
-//
-// Called before a request is sent.
+// RequestHook is a function invoked before the request is sent.
+// It receives a Client and a Request, allowing you to modify the Request or Client data.
 type RequestHook func(*Client, *Request) error
 
-// ResponseHook is a function that receives Agent, Response and Request,
-// it can change the data is Response or deal with some effects.
-//
-// Called after a response has been received.
+// ResponseHook is a function invoked after a response is received.
+// It receives a Client, Response, and Request, allowing you to modify the Response data
+// or perform actions based on the response.
 type ResponseHook func(*Client, *Response, *Request) error
 
-// RetryConfig is an alias for config in the `addon/retry` package.
+// RetryConfig is an alias for the `retry.Config` type from the `addon/retry` package.
 type RetryConfig = retry.Config
 
-// addMissingPort will add the corresponding port number for host.
-func addMissingPort(addr string, isTLS bool) string { //revive:disable-line:flag-parameter // Accepting a bool param named isTLS if fine here
+// addMissingPort appends the appropriate port number to the given address if it doesn't have one.
+// If isTLS is true, it uses port 443; otherwise, it uses port 80.
+func addMissingPort(addr string, isTLS bool) string { //revive:disable-line:flag-parameter
 	n := strings.Index(addr, ":")
 	if n >= 0 {
 		return addr
@@ -44,15 +42,14 @@ func addMissingPort(addr string, isTLS bool) string { //revive:disable-line:flag
 	return net.JoinHostPort(addr, strconv.Itoa(port))
 }
 
-// `core` stores middleware and plugin definitions,
-// and defines the execution process
+// core stores middleware and plugin definitions and defines the request execution process.
 type core struct {
 	client *Client
 	req    *Request
-	ctx    context.Context //nolint:containedctx // It's needed to be stored in the core.
+	ctx    context.Context //nolint:containedctx // Context is needed here.
 }
 
-// getRetryConfig returns the retry configuration of the client.
+// getRetryConfig returns a copy of the client's retry configuration.
 func (c *core) getRetryConfig() *RetryConfig {
 	c.client.mu.RLock()
 	defer c.client.mu.RUnlock()
@@ -70,19 +67,16 @@ func (c *core) getRetryConfig() *RetryConfig {
 	}
 }
 
-// execFunc is the core function of the client.
-// It sends the request and receives the response.
+// execFunc is the core logic to send the request and receive the response.
+// It leverages the fasthttp client, optionally with retries or redirects.
 func (c *core) execFunc() (*Response, error) {
 	resp := AcquireResponse()
 	resp.setClient(c.client)
 	resp.setRequest(c.req)
 
-	// To avoid memory allocation reuse of data structures such as errch.
 	done := int32(0)
 	errCh, reqv := acquireErrChan(), fasthttp.AcquireRequest()
-	defer func() {
-		releaseErrChan(errCh)
-	}()
+	defer releaseErrChan(errCh)
 
 	c.req.RawRequest.CopyTo(reqv)
 	cfg := c.getRetryConfig()
@@ -96,11 +90,11 @@ func (c *core) execFunc() (*Response, error) {
 		}()
 
 		if cfg != nil {
+			// Use an exponential backoff retry strategy.
 			err = retry.NewExponentialBackoff(*cfg).Retry(func() error {
 				if c.req.maxRedirects > 0 && (string(reqv.Header.Method()) == fiber.MethodGet || string(reqv.Header.Method()) == fiber.MethodHead) {
 					return c.client.fasthttp.DoRedirects(reqv, respv, c.req.maxRedirects)
 				}
-
 				return c.client.fasthttp.Do(reqv, respv)
 			})
 		} else {
@@ -124,7 +118,7 @@ func (c *core) execFunc() (*Response, error) {
 	select {
 	case err := <-errCh:
 		if err != nil {
-			// When get error should release Response
+			// Release the response if an error occurs.
 			ReleaseResponse(resp)
 			return nil, err
 		}
@@ -136,21 +130,19 @@ func (c *core) execFunc() (*Response, error) {
 	}
 }
 
-// preHooks Exec request hook
+// preHooks runs all request hooks before sending the request.
 func (c *core) preHooks() error {
 	c.client.mu.Lock()
 	defer c.client.mu.Unlock()
 
 	for _, f := range c.client.userRequestHooks {
-		err := f(c.client, c.req)
-		if err != nil {
+		if err := f(c.client, c.req); err != nil {
 			return err
 		}
 	}
 
 	for _, f := range c.client.builtinRequestHooks {
-		err := f(c.client, c.req)
-		if err != nil {
+		if err := f(c.client, c.req); err != nil {
 			return err
 		}
 	}
@@ -158,21 +150,19 @@ func (c *core) preHooks() error {
 	return nil
 }
 
-// afterHooks Exec response hooks
+// afterHooks runs all response hooks after receiving the response.
 func (c *core) afterHooks(resp *Response) error {
 	c.client.mu.Lock()
 	defer c.client.mu.Unlock()
 
 	for _, f := range c.client.builtinResponseHooks {
-		err := f(c.client, resp, c.req)
-		if err != nil {
+		if err := f(c.client, resp, c.req); err != nil {
 			return err
 		}
 	}
 
 	for _, f := range c.client.userResponseHooks {
-		err := f(c.client, resp, c.req)
-		if err != nil {
+		if err := f(c.client, resp, c.req); err != nil {
 			return err
 		}
 	}
@@ -180,7 +170,7 @@ func (c *core) afterHooks(resp *Response) error {
 	return nil
 }
 
-// timeout deals with timeout
+// timeout applies the configured timeout to the request, if any.
 func (c *core) timeout() context.CancelFunc {
 	var cancel context.CancelFunc
 
@@ -193,35 +183,32 @@ func (c *core) timeout() context.CancelFunc {
 	return cancel
 }
 
-// execute will exec each hooks and plugins.
+// execute runs all hooks, applies timeouts, sends the request, and runs response hooks.
 func (c *core) execute(ctx context.Context, client *Client, req *Request) (*Response, error) {
-	// keep a reference, because pass param is boring
+	// Store references locally.
 	c.ctx = ctx
 	c.client = client
 	c.req = req
 
-	// The built-in hooks will be executed only
-	// after the user-defined hooks are executed.
-	err := c.preHooks()
-	if err != nil {
+	// Execute pre request hooks (user-defined and built-in).
+	if err := c.preHooks(); err != nil {
 		return nil, err
 	}
 
+	// Apply timeout if specified.
 	cancel := c.timeout()
 	if cancel != nil {
 		defer cancel()
 	}
 
-	// Do http request
+	// Perform the actual HTTP request.
 	resp, err := c.execFunc()
 	if err != nil {
 		return nil, err
 	}
 
-	// The built-in hooks will be executed only
-	// before the user-defined hooks are executed.
-	err = c.afterHooks(resp)
-	if err != nil {
+	// Execute after response hooks (built-in and then user-defined).
+	if err := c.afterHooks(resp); err != nil {
 		resp.Close()
 		return nil, err
 	}
@@ -235,38 +222,35 @@ var errChanPool = &sync.Pool{
 	},
 }
 
-// acquireErrChan returns an empty error chan from the pool.
+// acquireErrChan returns an empty error channel from the pool.
 //
-// The returned error chan may be returned to the pool with releaseErrChan when no longer needed.
-// This allows reducing GC load.
+// The returned channel may be returned to the pool with releaseErrChan when no longer needed,
+// reducing GC load.
 func acquireErrChan() chan error {
 	ch, ok := errChanPool.Get().(chan error)
 	if !ok {
 		panic(errors.New("failed to type-assert to chan error"))
 	}
-
 	return ch
 }
 
-// releaseErrChan returns the object acquired via acquireErrChan to the pool.
+// releaseErrChan returns the error channel to the pool.
 //
-// Do not access the released core object, otherwise data races may occur.
+// Do not use the released channel afterward to avoid data races.
 func releaseErrChan(ch chan error) {
 	errChanPool.Put(ch)
 }
 
-// newCore returns an empty core object.
+// newCore returns a new core object.
 func newCore() *core {
-	c := &core{}
-
-	return c
+	return &core{}
 }
 
 var (
 	ErrTimeoutOrCancel      = errors.New("timeout or cancel")
-	ErrURLFormat            = errors.New("the url is a mistake")
-	ErrNotSupportSchema     = errors.New("the protocol is not support, only http or https")
-	ErrFileNoName           = errors.New("the file should have name")
+	ErrURLFormat            = errors.New("the URL is incorrect")
+	ErrNotSupportSchema     = errors.New("protocol not supported; only http or https are allowed")
+	ErrFileNoName           = errors.New("the file should have a name")
 	ErrBodyType             = errors.New("the body type should be []byte")
-	ErrNotSupportSaveMethod = errors.New("file path and io.Writer are supported")
+	ErrNotSupportSaveMethod = errors.New("only file paths and io.Writer are supported")
 )
diff --git a/client/hooks.go b/client/hooks.go
index 4c36145f2f..9dbfc89e72 100644
--- a/client/hooks.go
+++ b/client/hooks.go
@@ -28,12 +28,12 @@ var (
 	multipartFormData = "multipart/form-data"
 
 	letterBytes   = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-	letterIdxBits = 6                    // 6 bits to represent a letter index
-	letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
-	letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
+	letterIdxBits = 6                     // 6 bits to represent a letter index
+	letterIdxMask = 1<<letterIdxBits - 1  // All 1-bits, as many as letterIdxBits
+	letterIdxMax  = 63 / letterIdxBits    // # of letter indices fitting into 63 bits
 )
 
-// randString returns a random string with n length
+// randString returns a random string of length n.
 func randString(n int) string {
 	b := make([]byte, n)
 	length := len(letterBytes)
@@ -55,17 +55,14 @@ func randString(n int) string {
 	return utils.UnsafeString(b)
 }
 
-// parserRequestURL will set the options for the hostclient
-// and normalize the url.
-// The baseUrl will be merge with request uri.
-// Query params and path params deal in this function.
+// parserRequestURL sets options for the hostclient and normalizes the URL.
+// It merges the baseURL with the request URI if needed and applies query and path parameters.
 func parserRequestURL(c *Client, req *Request) error {
 	splitURL := strings.Split(req.url, "?")
-	// I don't want to judge splitURL length.
+	// Ensure splitURL has at least two elements.
 	splitURL = append(splitURL, "")
 
-	// Determine whether to superimpose baseurl based on
-	// whether the URL starts with the protocol
+	// If the URL doesn't start with http/https, prepend the baseURL.
 	uri := splitURL[0]
 	if !protocolCheck.MatchString(uri) {
 		uri = c.baseURL + uri
@@ -74,7 +71,7 @@ func parserRequestURL(c *Client, req *Request) error {
 		}
 	}
 
-	// set path params
+	// Set path parameters from the request and client.
 	req.path.VisitAll(func(key, val string) {
 		uri = strings.ReplaceAll(uri, ":"+key, val)
 	})
@@ -82,47 +79,47 @@ func parserRequestURL(c *Client, req *Request) error {
 		uri = strings.ReplaceAll(uri, ":"+key, val)
 	})
 
-	// set uri to request and other related setting
+	// Set the URI in the raw request.
 	req.RawRequest.SetRequestURI(uri)
 
-	// merge query params
+	// Merge query parameters.
 	hashSplit := strings.Split(splitURL[1], "#")
 	hashSplit = append(hashSplit, "")
 	args := fasthttp.AcquireArgs()
-	defer func() {
-		fasthttp.ReleaseArgs(args)
-	}()
+	defer fasthttp.ReleaseArgs(args)
 
 	args.Parse(hashSplit[0])
+
 	c.params.VisitAll(func(key, value []byte) {
 		args.AddBytesKV(key, value)
 	})
 	req.params.VisitAll(func(key, value []byte) {
 		args.AddBytesKV(key, value)
 	})
+
 	req.RawRequest.URI().SetQueryStringBytes(utils.CopyBytes(args.QueryString()))
 	req.RawRequest.URI().SetHash(hashSplit[1])
 
 	return nil
 }
 
-// parserRequestHeader will make request header up.
-// It will merge headers from client and request.
-// Header should be set automatically based on data.
-// User-Agent should be set.
+// parserRequestHeader merges client and request headers, and sets headers automatically based on the request data.
+// It also sets the User-Agent and Referer headers, and applies any cookies from the cookie jar.
 func parserRequestHeader(c *Client, req *Request) error {
-	// set method
+	// Set HTTP method.
 	req.RawRequest.Header.SetMethod(req.Method())
-	// merge header
+
+	// Merge headers from the client.
 	c.header.VisitAll(func(key, value []byte) {
 		req.RawRequest.Header.AddBytesKV(key, value)
 	})
 
+	// Merge headers from the request.
 	req.header.VisitAll(func(key, value []byte) {
 		req.RawRequest.Header.AddBytesKV(key, value)
 	})
 
-	// according to data set content-type
+	// Set Content-Type and Accept headers based on the request body type.
 	switch req.bodyType {
 	case jsonBody:
 		req.RawRequest.Header.SetContentType(applicationJSON)
@@ -135,15 +132,16 @@ func parserRequestHeader(c *Client, req *Request) error {
 		req.RawRequest.Header.SetContentType(applicationForm)
 	case filesBody:
 		req.RawRequest.Header.SetContentType(multipartFormData)
-		// set boundary
+		// If boundary is default, append a random string to it.
 		if req.boundary == boundary {
 			req.boundary += randString(16)
 		}
 		req.RawRequest.Header.SetMultipartFormBoundary(req.boundary)
 	default:
+		// noBody or rawBody do not require special handling here.
 	}
 
-	// set useragent
+	// Set User-Agent header.
 	req.RawRequest.Header.SetUserAgent(defaultUserAgent)
 	if c.userAgent != "" {
 		req.RawRequest.Header.SetUserAgent(c.userAgent)
@@ -152,22 +150,23 @@ func parserRequestHeader(c *Client, req *Request) error {
 		req.RawRequest.Header.SetUserAgent(req.userAgent)
 	}
 
-	// set referer
+	// Set Referer header.
 	req.RawRequest.Header.SetReferer(c.referer)
 	if req.referer != "" {
 		req.RawRequest.Header.SetReferer(req.referer)
 	}
 
-	// set cookie
-	// add cookie form jar to req
+	// Set cookies from the cookie jar if available.
 	if c.cookieJar != nil {
 		c.cookieJar.dumpCookiesToReq(req.RawRequest)
 	}
 
+	// Set cookies from the client.
 	c.cookies.VisitAll(func(key, val string) {
 		req.RawRequest.Header.SetCookie(key, val)
 	})
 
+	// Set cookies from the request.
 	req.cookies.VisitAll(func(key, val string) {
 		req.RawRequest.Header.SetCookie(key, val)
 	})
@@ -175,8 +174,7 @@ func parserRequestHeader(c *Client, req *Request) error {
 	return nil
 }
 
-// parserRequestBody automatically serializes the data according to
-// the data type and stores it in the body of the rawRequest
+// parserRequestBody serializes the request body based on its type and sets it into the RawRequest.
 func parserRequestBody(c *Client, req *Request) error {
 	switch req.bodyType {
 	case jsonBody:
@@ -208,14 +206,14 @@ func parserRequestBody(c *Client, req *Request) error {
 			return ErrBodyType
 		}
 	case noBody:
+		// No body to set.
 		return nil
 	}
 
 	return nil
 }
 
-// parserRequestBodyFile parses request body if body type is file
-// this is an addition of parserRequestBody.
+// parserRequestBodyFile handles the case where the request contains files to be uploaded.
 func parserRequestBodyFile(req *Request) error {
 	mw := multipart.NewWriter(req.RawRequest.BodyWriter())
 	err := mw.SetBoundary(req.boundary)
@@ -223,13 +221,14 @@ func parserRequestBodyFile(req *Request) error {
 		return fmt.Errorf("set boundary error: %w", err)
 	}
 	defer func() {
-		err := mw.Close()
-		if err != nil {
+		e := mw.Close()
+		if e != nil {
+			// Close errors are typically ignored.
 			return
 		}
 	}()
 
-	// add formdata
+	// Add form data.
 	req.formData.VisitAll(func(key, value []byte) {
 		if err != nil {
 			return
@@ -240,25 +239,25 @@ func parserRequestBodyFile(req *Request) error {
 		return fmt.Errorf("write formdata error: %w", err)
 	}
 
-	// add files
-	fileBuf := make([]byte, 1<<20) // Allocate 1MB buffer
+	// Add files.
+	fileBuf := make([]byte, 1<<20) // 1MB buffer
 	for i, v := range req.files {
 		if v.name == "" && v.path == "" {
 			return ErrFileNoName
 		}
 
-		// if name is not exist, set name
+		// Set the file name if not provided.
 		if v.name == "" && v.path != "" {
 			v.path = filepath.Clean(v.path)
 			v.name = filepath.Base(v.path)
 		}
 
-		// if field name is not exist, set it
+		// Set the field name if not provided.
 		if v.fieldName == "" {
 			v.fieldName = "file" + strconv.Itoa(i+1)
 		}
 
-		// check the reader
+		// If reader is not set, open the file.
 		if v.reader == nil {
 			v.reader, err = os.Open(v.path)
 			if err != nil {
@@ -266,13 +265,12 @@ func parserRequestBodyFile(req *Request) error {
 			}
 		}
 
-		// write file
+		// Create form file and copy the content.
 		w, err := mw.CreateFormFile(v.fieldName, v.name)
 		if err != nil {
 			return fmt.Errorf("create file error: %w", err)
 		}
 
-		// Copy the file from reader to multipart writer
 		if _, err := io.CopyBuffer(w, v.reader, fileBuf); err != nil {
 			return fmt.Errorf("failed to copy file data: %w", err)
 		}
@@ -285,7 +283,7 @@ func parserRequestBodyFile(req *Request) error {
 	return nil
 }
 
-// parserResponseCookie will parse the response header and store it in the response
+// parserResponseCookie parses the Set-Cookie headers from the response and stores them.
 func parserResponseCookie(c *Client, resp *Response, req *Request) error {
 	var err error
 	resp.RawResponse.Header.VisitAllCookie(func(key, value []byte) {
@@ -295,7 +293,6 @@ func parserResponseCookie(c *Client, resp *Response, req *Request) error {
 			return
 		}
 		cookie.SetKeyBytes(key)
-
 		resp.cookie = append(resp.cookie, cookie)
 	})
 
@@ -303,7 +300,7 @@ func parserResponseCookie(c *Client, resp *Response, req *Request) error {
 		return err
 	}
 
-	// store cookies to jar
+	// Store cookies in the cookie jar if available.
 	if c.cookieJar != nil {
 		c.cookieJar.parseCookiesFromResp(req.RawRequest.URI().Host(), req.RawRequest.URI().Path(), resp.RawResponse)
 	}
@@ -311,7 +308,7 @@ func parserResponseCookie(c *Client, resp *Response, req *Request) error {
 	return nil
 }
 
-// logger is a response hook that logs the request and response
+// logger is a response hook that logs request and response data if debug mode is enabled.
 func logger(c *Client, resp *Response, req *Request) error {
 	if !c.debug {
 		return nil
diff --git a/client/request.go b/client/request.go
index f303fb7490..ede9670d62 100644
--- a/client/request.go
+++ b/client/request.go
@@ -18,17 +18,16 @@ import (
 	"github.com/valyala/fasthttp"
 )
 
-// WithStruct Implementing this interface allows data to
-// be stored from a struct via reflect.
+// WithStruct is implemented by types that allow data to be stored from a struct via reflection.
 type WithStruct interface {
 	Add(name, obj string)
 	Del(name string)
 }
 
-// Types of request bodies.
+// bodyType defines the type of request body.
 type bodyType int
 
-// Enumeration definition of the request body type.
+// Enumeration of request body types.
 const (
 	noBody bodyType = iota
 	jsonBody
@@ -39,11 +38,11 @@ const (
 	cborBody
 )
 
-var ErrClientNil = errors.New("client can not be nil")
+var ErrClientNil = errors.New("client cannot be nil")
 
-// Request is a struct which contains the request data.
+// Request contains all data related to an HTTP request.
 type Request struct {
-	ctx context.Context //nolint:containedctx // It's needed to be stored in the request.
+	ctx context.Context //nolint:containedctx // Context is needed to be stored in the request.
 
 	body    any
 	header  *Header
@@ -69,35 +68,35 @@ type Request struct {
 	bodyType bodyType
 }
 
-// Method returns http method in request.
+// Method returns the HTTP method set in the Request.
 func (r *Request) Method() string {
 	return r.method
 }
 
-// SetMethod will set method for Request object,
-// user should use request method to set method.
+// SetMethod sets the HTTP method for the Request.
+// It is recommended to use the specialized methods (e.g., Get, Post) instead.
 func (r *Request) SetMethod(method string) *Request {
 	r.method = method
 	return r
 }
 
-// URL returns request url in Request instance.
+// URL returns the URL set in the Request.
 func (r *Request) URL() string {
 	return r.url
 }
 
-// SetURL will set url for Request object.
+// SetURL sets the URL for the Request.
 func (r *Request) SetURL(url string) *Request {
 	r.url = url
 	return r
 }
 
-// Client get Client instance in Request.
+// Client returns the Client instance associated with this Request.
 func (r *Request) Client() *Client {
 	return r.client
 }
 
-// SetClient method sets client in request instance.
+// SetClient sets the Client instance for the Request.
 func (r *Request) SetClient(c *Client) *Request {
 	if c == nil {
 		panic(ErrClientNil)
@@ -107,8 +106,8 @@ func (r *Request) SetClient(c *Client) *Request {
 	return r
 }
 
-// Context returns the Context if its already set in request
-// otherwise it creates new one using `context.Background()`.
+// Context returns the context associated with the Request.
+// If not set, a background context is returned.
 func (r *Request) Context() context.Context {
 	if r.ctx == nil {
 		return context.Background()
@@ -116,26 +115,22 @@ func (r *Request) Context() context.Context {
 	return r.ctx
 }
 
-// SetContext sets the context.Context for current Request. It allows
-// to interrupt the request execution if ctx.Done() channel is closed.
-// See https://blog.golang.org/context article and the "context" package
-// documentation.
+// SetContext sets the context for the Request, allowing request cancellation if ctx is done.
 func (r *Request) SetContext(ctx context.Context) *Request {
 	r.ctx = ctx
 	return r
 }
 
-// Header method returns header value via key,
-// this method will visit all field in the header.
+// Header returns all values associated with the given header key.
 func (r *Request) Header(key string) []string {
 	return r.header.PeekMultiple(key)
 }
 
-// Headers returns all headers in the request using an iterator.
-// You can use maps.Collect() to collect all headers into a map.
+// Headers returns an iterator over all headers in the Request.
+// Use maps.Collect() to gather them into a map if needed.
 //
-// The returned value is valid until the request object is released.
-// Any future calls to Headers method will return the modified value. Do not store references to returned value. Make copies instead.
+// The returned values are only valid until the request object is released.
+// Do not store references to returned values; make copies instead.
 func (r *Request) Headers() iter.Seq2[string, []string] {
 	return func(yield func(string, []string) bool) {
 		peekKeys := r.header.PeekKeys()
@@ -156,50 +151,46 @@ func (r *Request) Headers() iter.Seq2[string, []string] {
 	}
 }
 
-// AddHeader method adds a single header field and its value in the request instance.
+// AddHeader adds a single header field and value to the Request.
 func (r *Request) AddHeader(key, val string) *Request {
 	r.header.Add(key, val)
 	return r
 }
 
-// SetHeader method sets a single header field and its value in the request instance.
-// It will override header which has been set in client instance.
+// SetHeader sets a single header field and value in the Request, overriding any previously set value.
 func (r *Request) SetHeader(key, val string) *Request {
 	r.header.Del(key)
 	r.header.Set(key, val)
 	return r
 }
 
-// AddHeaders method adds multiple header fields and its values at one go in the request instance.
+// AddHeaders adds multiple header fields and values at once.
 func (r *Request) AddHeaders(h map[string][]string) *Request {
 	r.header.AddHeaders(h)
 	return r
 }
 
-// SetHeaders method sets multiple header fields and its values at one go in the request instance.
-// It will override header which has been set in client instance.
+// SetHeaders sets multiple header fields and values at once, overriding previously set values.
 func (r *Request) SetHeaders(h map[string]string) *Request {
 	r.header.SetHeaders(h)
 	return r
 }
 
-// Param method returns params value via key,
-// this method will visit all field in the query param.
+// Param returns all values associated with the given query parameter.
 func (r *Request) Param(key string) []string {
 	var res []string
 	tmp := r.params.PeekMulti(key)
 	for _, v := range tmp {
 		res = append(res, utils.UnsafeString(v))
 	}
-
 	return res
 }
 
-// Params returns all params in the request using an iterator.
-// You can use maps.Collect() to collect all params into a map.
+// Params returns an iterator over all query parameters in the Request.
+// Use maps.Collect() to gather them into a map if needed.
 //
-// The returned value is valid until the request object is released.
-// Any future calls to Params method will return the modified value. Do not store references to returned value. Make copies instead.
+// The returned values are only valid until the request object is released.
+// Do not store references to returned values; make copies instead.
 func (r *Request) Params() iter.Seq2[string, []string] {
 	return func(yield func(string, []string) bool) {
 		keys := r.params.Keys()
@@ -222,40 +213,37 @@ func (r *Request) Params() iter.Seq2[string, []string] {
 	}
 }
 
-// AddParam method adds a single param field and its value in the request instance.
+// AddParam adds a single query parameter and value to the Request.
 func (r *Request) AddParam(key, val string) *Request {
 	r.params.Add(key, val)
 	return r
 }
 
-// SetParam method sets a single param field and its value in the request instance.
-// It will override param which has been set in client instance.
+// SetParam sets a single query parameter and value in the Request, overriding any previously set value.
 func (r *Request) SetParam(key, val string) *Request {
 	r.params.Set(key, val)
 	return r
 }
 
-// AddParams method adds multiple param fields and its values at one go in the request instance.
+// AddParams adds multiple query parameters and their values at once.
 func (r *Request) AddParams(m map[string][]string) *Request {
 	r.params.AddParams(m)
 	return r
 }
 
-// SetParams method sets multiple param fields and its values at one go in the request instance.
-// It will override param which has been set in client instance.
+// SetParams sets multiple query parameters and their values at once, overriding previously set values.
 func (r *Request) SetParams(m map[string]string) *Request {
 	r.params.SetParams(m)
 	return r
 }
 
-// SetParamsWithStruct method sets multiple param fields and its values at one go in the request instance.
-// It will override param which has been set in client instance.
+// SetParamsWithStruct sets multiple query parameters from a struct, overriding previously set values.
 func (r *Request) SetParamsWithStruct(v any) *Request {
 	r.params.SetParamsWithStruct(v)
 	return r
 }
 
-// DelParams method deletes single or multiple param fields ant its values.
+// DelParams deletes one or more query parameters.
 func (r *Request) DelParams(key ...string) *Request {
 	for _, v := range key {
 		r.params.Del(v)
@@ -263,44 +251,41 @@ func (r *Request) DelParams(key ...string) *Request {
 	return r
 }
 
-// UserAgent returns user agent in request instance.
+// UserAgent returns the User-Agent header set in the Request.
 func (r *Request) UserAgent() string {
 	return r.userAgent
 }
 
-// SetUserAgent method sets user agent in request.
-// It will override user agent which has been set in client instance.
+// SetUserAgent sets the User-Agent header, overriding any previously set value.
 func (r *Request) SetUserAgent(ua string) *Request {
 	r.userAgent = ua
 	return r
 }
 
-// Boundary returns boundary in multipart boundary.
+// Boundary returns the multipart boundary used by the Request.
 func (r *Request) Boundary() string {
 	return r.boundary
 }
 
-// SetBoundary method sets multipart boundary.
+// SetBoundary sets the multipart boundary.
 func (r *Request) SetBoundary(b string) *Request {
 	r.boundary = b
-
 	return r
 }
 
-// Referer returns referer in request instance.
+// Referer returns the Referer header set in the Request.
 func (r *Request) Referer() string {
 	return r.referer
 }
 
-// SetReferer method sets referer in request.
-// It will override referer which set in client instance.
+// SetReferer sets the Referer header, overriding any previously set value.
 func (r *Request) SetReferer(referer string) *Request {
 	r.referer = referer
 	return r
 }
 
-// Cookie returns the cookie be set in request instance.
-// if cookie doesn't exist, return empty string.
+// Cookie returns the value of a named cookie.
+// If the cookie does not exist, an empty string is returned.
 func (r *Request) Cookie(key string) string {
 	if val, ok := (*r.cookies)[key]; ok {
 		return val
@@ -308,8 +293,8 @@ func (r *Request) Cookie(key string) string {
 	return ""
 }
 
-// Cookies returns all cookies in the cookies using an iterator.
-// You can use maps.Collect() to collect all cookies into a map.
+// Cookies returns an iterator over all cookies.
+// Use maps.Collect() to gather them into a map if needed.
 func (r *Request) Cookies() iter.Seq2[string, string] {
 	return func(yield func(string, string) bool) {
 		r.cookies.VisitAll(func(key, val string) {
@@ -320,45 +305,41 @@ func (r *Request) Cookies() iter.Seq2[string, string] {
 	}
 }
 
-// SetCookie method sets a single cookie field and its value in the request instance.
-// It will override cookie which set in client instance.
+// SetCookie sets a single cookie, overriding any previously set value.
 func (r *Request) SetCookie(key, val string) *Request {
 	r.cookies.SetCookie(key, val)
 	return r
 }
 
-// SetCookies method sets multiple cookie fields and its values at one go in the request instance.
-// It will override cookie which set in client instance.
+// SetCookies sets multiple cookies at once, overriding previously set values.
 func (r *Request) SetCookies(m map[string]string) *Request {
 	r.cookies.SetCookies(m)
 	return r
 }
 
-// SetCookiesWithStruct method sets multiple cookie fields and its values at one go in the request instance.
-// It will override cookie which set in client instance.
+// SetCookiesWithStruct sets multiple cookies from a struct, overriding previously set values.
 func (r *Request) SetCookiesWithStruct(v any) *Request {
 	r.cookies.SetCookiesWithStruct(v)
 	return r
 }
 
-// DelCookies method deletes single or multiple cookie fields ant its values.
+// DelCookies deletes one or more cookies.
 func (r *Request) DelCookies(key ...string) *Request {
 	r.cookies.DelCookies(key...)
 	return r
 }
 
-// PathParam returns the path param be set in request instance.
-// if path param doesn't exist, return empty string.
+// PathParam returns the value of a named path parameter.
+// If the parameter does not exist, an empty string is returned.
 func (r *Request) PathParam(key string) string {
 	if val, ok := (*r.path)[key]; ok {
 		return val
 	}
-
 	return ""
 }
 
-// PathParams returns all path params in request instance.
-// You can use maps.Collect() to collect all cookies into a map.
+// PathParams returns an iterator over all path parameters.
+// Use maps.Collect() to gather them into a map if needed.
 func (r *Request) PathParams() iter.Seq2[string, string] {
 	return func(yield func(string, string) bool) {
 		r.path.VisitAll(func(key, val string) {
@@ -369,96 +350,91 @@ func (r *Request) PathParams() iter.Seq2[string, string] {
 	}
 }
 
-// SetPathParam method sets a single path param field and its value in the request instance.
-// It will override path param which set in client instance.
+// SetPathParam sets a single path parameter and value, overriding any previously set value.
 func (r *Request) SetPathParam(key, val string) *Request {
 	r.path.SetParam(key, val)
 	return r
 }
 
-// SetPathParams method sets multiple path param fields and its values at one go in the request instance.
-// It will override path param which set in client instance.
+// SetPathParams sets multiple path parameters and values at once, overriding previously set values.
 func (r *Request) SetPathParams(m map[string]string) *Request {
 	r.path.SetParams(m)
 	return r
 }
 
-// SetPathParamsWithStruct method sets multiple path param fields and its values at one go in the request instance.
-// It will override path param which set in client instance.
+// SetPathParamsWithStruct sets multiple path parameters from a struct, overriding previously set values.
 func (r *Request) SetPathParamsWithStruct(v any) *Request {
 	r.path.SetParamsWithStruct(v)
 	return r
 }
 
-// DelPathParams method deletes single or multiple path param fields ant its values.
+// DelPathParams deletes one or more path parameters.
 func (r *Request) DelPathParams(key ...string) *Request {
 	r.path.DelParams(key...)
 	return r
 }
 
-// ResetPathParams deletes all path params.
+// ResetPathParams deletes all path parameters.
 func (r *Request) ResetPathParams() *Request {
 	r.path.Reset()
 	return r
 }
 
-// SetJSON method sets JSON body in request.
+// SetJSON sets the request body to a JSON-encoded value.
 func (r *Request) SetJSON(v any) *Request {
 	r.body = v
 	r.bodyType = jsonBody
 	return r
 }
 
-// SetXML method sets XML body in request.
+// SetXML sets the request body to an XML-encoded value.
 func (r *Request) SetXML(v any) *Request {
 	r.body = v
 	r.bodyType = xmlBody
 	return r
 }
 
-// SetCBOR method sets CBOR body in request.
+// SetCBOR sets the request body to a CBOR-encoded value.
 func (r *Request) SetCBOR(v any) *Request {
 	r.body = v
 	r.bodyType = cborBody
 	return r
 }
 
-// SetRawBody method sets body with raw data in request.
+// SetRawBody sets the request body to raw bytes.
 func (r *Request) SetRawBody(v []byte) *Request {
 	r.body = v
 	r.bodyType = rawBody
 	return r
 }
 
-// resetBody will clear body object and set bodyType
-// if body type is formBody and filesBody, the new body type will be ignored.
+// resetBody clears the existing body. If the current body type is filesBody and
+// the new type is formBody, the formBody setting is ignored to preserve files.
 func (r *Request) resetBody(t bodyType) {
 	r.body = nil
 
-	// Set form data after set file ignore.
+	// If bodyType is filesBody and we attempt to set formBody, ignore the change.
 	if r.bodyType == filesBody && t == formBody {
 		return
 	}
 	r.bodyType = t
 }
 
-// FormData method returns form data value via key,
-// this method will visit all field in the form data.
+// FormData returns all values associated with a form field.
 func (r *Request) FormData(key string) []string {
 	var res []string
 	tmp := r.formData.PeekMulti(key)
 	for _, v := range tmp {
 		res = append(res, utils.UnsafeString(v))
 	}
-
 	return res
 }
 
-// AllFormData method returns all form datas in request instance.
-// You can use maps.Collect() to collect all cookies into a map.
+// AllFormData returns an iterator over all form fields.
+// Use maps.Collect() to gather them into a map if needed.
 //
-// The returned value is valid until the request object is released.
-// Any future calls to FormDatas method will return the modified value. Do not store references to returned value. Make copies instead.
+// The returned values are only valid until the request object is released.
+// Do not store references to returned values; make copies instead.
 func (r *Request) AllFormData() iter.Seq2[string, []string] {
 	return func(yield func(string, []string) bool) {
 		keys := r.formData.Keys()
@@ -481,51 +457,50 @@ func (r *Request) AllFormData() iter.Seq2[string, []string] {
 	}
 }
 
-// AddFormData method adds a single form data field and its value in the request instance.
+// AddFormData adds a single form field and value to the Request.
 func (r *Request) AddFormData(key, val string) *Request {
 	r.formData.AddData(key, val)
 	r.resetBody(formBody)
 	return r
 }
 
-// SetFormData method sets a single form data field and its value in the request instance.
+// SetFormData sets a single form field and value, overriding any previously set value.
 func (r *Request) SetFormData(key, val string) *Request {
 	r.formData.SetData(key, val)
 	r.resetBody(formBody)
 	return r
 }
 
-// AddFormDatas method adds multiple form data fields and its values in the request instance.
+// AddFormDatas adds multiple form fields and values to the Request.
 func (r *Request) AddFormDatas(m map[string][]string) *Request {
 	r.formData.AddDatas(m)
 	r.resetBody(formBody)
 	return r
 }
 
-// SetFormDatas method sets multiple form data fields and its values in the request instance.
+// SetFormDatas sets multiple form fields and values at once, overriding previously set values.
 func (r *Request) SetFormDatas(m map[string]string) *Request {
 	r.formData.SetDatas(m)
 	r.resetBody(formBody)
 	return r
 }
 
-// SetFormDatasWithStruct method sets multiple form data fields
-// and its values in the request instance via struct.
+// SetFormDatasWithStruct sets multiple form fields from a struct, overriding previously set values.
 func (r *Request) SetFormDatasWithStruct(v any) *Request {
 	r.formData.SetDatasWithStruct(v)
 	r.resetBody(formBody)
 	return r
 }
 
-// DelFormDatas method deletes multiple form data fields and its value in the request instance.
+// DelFormDatas deletes one or more form fields.
 func (r *Request) DelFormDatas(key ...string) *Request {
 	r.formData.DelDatas(key...)
 	r.resetBody(formBody)
 	return r
 }
 
-// File returns file ptr store in request obj by name.
-// If name field is empty, it will try to match path.
+// File returns the file associated with the given name.
+// If no name was provided during addition, it attempts to match by the file's base name.
 func (r *Request) File(name string) *File {
 	for _, v := range r.files {
 		if v.name == "" {
@@ -536,132 +511,125 @@ func (r *Request) File(name string) *File {
 			return v
 		}
 	}
-
 	return nil
 }
 
-// Files method returns all files in request instance.
+// Files returns all files added to the Request.
 //
-// The returned value is valid until the request object is released.
-// Any future calls to Files method will return the modified value. Do not store references to returned value. Make copies instead.
+// The returned values are only valid until the request object is released.
+// Do not store references to returned values; make copies instead.
 func (r *Request) Files() []*File {
 	return r.files
 }
 
-// FileByPath returns file ptr store in request obj by path.
+// FileByPath returns the file associated with the given file path.
 func (r *Request) FileByPath(path string) *File {
 	for _, v := range r.files {
 		if v.path == path {
 			return v
 		}
 	}
-
 	return nil
 }
 
-// AddFile method adds single file field
-// and its value in the request instance via file path.
+// AddFile adds a single file by its path.
 func (r *Request) AddFile(path string) *Request {
 	r.files = append(r.files, AcquireFile(SetFilePath(path)))
 	r.resetBody(filesBody)
 	return r
 }
 
-// AddFileWithReader method adds single field
-// and its value in the request instance via reader.
+// AddFileWithReader adds a file using an io.ReadCloser.
 func (r *Request) AddFileWithReader(name string, reader io.ReadCloser) *Request {
 	r.files = append(r.files, AcquireFile(SetFileName(name), SetFileReader(reader)))
 	r.resetBody(filesBody)
 	return r
 }
 
-// AddFiles method adds multiple file fields
-// and its value in the request instance via File instance.
+// AddFiles adds multiple files at once.
 func (r *Request) AddFiles(files ...*File) *Request {
 	r.files = append(r.files, files...)
 	r.resetBody(filesBody)
 	return r
 }
 
-// Timeout returns the length of timeout in request.
+// Timeout returns the timeout duration set in the Request.
 func (r *Request) Timeout() time.Duration {
 	return r.timeout
 }
 
-// SetTimeout method sets timeout field and its values at one go in the request instance.
-// It will override timeout which set in client instance.
+// SetTimeout sets the timeout for the Request, overriding any previously set value.
 func (r *Request) SetTimeout(t time.Duration) *Request {
 	r.timeout = t
 	return r
 }
 
-// MaxRedirects returns the max redirects count in request.
+// MaxRedirects returns the maximum number of redirects configured for the Request.
 func (r *Request) MaxRedirects() int {
 	return r.maxRedirects
 }
 
-// SetMaxRedirects method sets the maximum number of redirects at one go in the request instance.
-// It will override max redirect which set in client instance.
+// SetMaxRedirects sets the maximum number of redirects, overriding any previously set value.
 func (r *Request) SetMaxRedirects(count int) *Request {
 	r.maxRedirects = count
 	return r
 }
 
-// checkClient method checks whether the client has been set in request.
+// checkClient ensures that a Client is set. If none is set, it defaults to the global defaultClient.
 func (r *Request) checkClient() {
 	if r.client == nil {
 		r.SetClient(defaultClient)
 	}
 }
 
-// Get Send get request.
+// Get sends a GET request to the given URL.
 func (r *Request) Get(url string) (*Response, error) {
 	return r.SetURL(url).SetMethod(fiber.MethodGet).Send()
 }
 
-// Post Send post request.
+// Post sends a POST request to the given URL.
 func (r *Request) Post(url string) (*Response, error) {
 	return r.SetURL(url).SetMethod(fiber.MethodPost).Send()
 }
 
-// Head Send head request.
+// Head sends a HEAD request to the given URL.
 func (r *Request) Head(url string) (*Response, error) {
 	return r.SetURL(url).SetMethod(fiber.MethodHead).Send()
 }
 
-// Put Send put request.
+// Put sends a PUT request to the given URL.
 func (r *Request) Put(url string) (*Response, error) {
 	return r.SetURL(url).SetMethod(fiber.MethodPut).Send()
 }
 
-// Delete Send Delete request.
+// Delete sends a DELETE request to the given URL.
 func (r *Request) Delete(url string) (*Response, error) {
 	return r.SetURL(url).SetMethod(fiber.MethodDelete).Send()
 }
 
-// Options Send Options request.
+// Options sends an OPTIONS request to the given URL.
 func (r *Request) Options(url string) (*Response, error) {
 	return r.SetURL(url).SetMethod(fiber.MethodOptions).Send()
 }
 
-// Patch Send patch request.
+// Patch sends a PATCH request to the given URL.
 func (r *Request) Patch(url string) (*Response, error) {
 	return r.SetURL(url).SetMethod(fiber.MethodPatch).Send()
 }
 
-// Custom Send custom request.
+// Custom sends a request with a custom HTTP method to the given URL.
 func (r *Request) Custom(url, method string) (*Response, error) {
 	return r.SetURL(url).SetMethod(method).Send()
 }
 
-// Send a request.
+// Send executes the Request.
 func (r *Request) Send() (*Response, error) {
 	r.checkClient()
-
 	return newCore().execute(r.Context(), r.Client(), r)
 }
 
-// Reset clear Request object, used by ReleaseRequest method.
+// Reset clears the Request object, returning it to its default state.
+// Used by ReleaseRequest to recycle the object.
 func (r *Request) Reset() {
 	r.url = ""
 	r.method = fiber.MethodGet
@@ -688,26 +656,24 @@ func (r *Request) Reset() {
 	r.RawRequest.Reset()
 }
 
-// Header is a wrapper which wrap http.Header,
-// the header in client and request will store in it.
+// Header wraps fasthttp.RequestHeader, storing headers for both client and request.
 type Header struct {
 	*fasthttp.RequestHeader
 }
 
-// PeekMultiple methods returns multiple field in header with same key.
+// PeekMultiple returns multiple values of a header field with the same key.
 func (h *Header) PeekMultiple(key string) []string {
 	var res []string
 	byteKey := []byte(key)
-	h.RequestHeader.VisitAll(func(key, value []byte) {
-		if bytes.EqualFold(key, byteKey) {
+	h.RequestHeader.VisitAll(func(k, value []byte) {
+		if bytes.EqualFold(k, byteKey) {
 			res = append(res, utils.UnsafeString(value))
 		}
 	})
-
 	return res
 }
 
-// AddHeaders receives a map and add each value to header.
+// AddHeaders adds multiple headers from a map.
 func (h *Header) AddHeaders(r map[string][]string) {
 	for k, v := range r {
 		for _, vv := range v {
@@ -716,7 +682,7 @@ func (h *Header) AddHeaders(r map[string][]string) {
 	}
 }
 
-// SetHeaders will override all headers.
+// SetHeaders sets multiple headers from a map, overriding previously set values.
 func (h *Header) SetHeaders(r map[string]string) {
 	for k, v := range r {
 		h.Del(k)
@@ -724,23 +690,21 @@ func (h *Header) SetHeaders(r map[string]string) {
 	}
 }
 
-// QueryParam is a wrapper which wrap url.Values,
-// the query string and formdata in client and request will store in it.
+// QueryParam wraps fasthttp.Args for query parameters.
 type QueryParam struct {
 	*fasthttp.Args
 }
 
-// Keys method returns all keys in the query params.
+// Keys returns all keys from the query parameters.
 func (p *QueryParam) Keys() []string {
 	keys := make([]string, 0, p.Len())
 	p.VisitAll(func(key, _ []byte) {
 		keys = append(keys, utils.UnsafeString(key))
 	})
-
 	return slices.Compact(keys)
 }
 
-// AddParams receive a map and add each value to param.
+// AddParams adds multiple parameters from a map.
 func (p *QueryParam) AddParams(r map[string][]string) {
 	for k, v := range r {
 		for _, vv := range v {
@@ -749,148 +713,148 @@ func (p *QueryParam) AddParams(r map[string][]string) {
 	}
 }
 
-// SetParams will override all params.
+// SetParams sets multiple parameters from a map, overriding previously set values.
 func (p *QueryParam) SetParams(r map[string]string) {
 	for k, v := range r {
 		p.Set(k, v)
 	}
 }
 
-// SetParamsWithStruct will override all params with struct or pointer of struct.
-// Now nested structs are not currently supported.
+// SetParamsWithStruct sets multiple parameters from a struct.
+// Nested structs are not currently supported.
 func (p *QueryParam) SetParamsWithStruct(v any) {
 	SetValWithStruct(p, "param", v)
 }
 
-// Cookie is a map which to store the cookies.
+// Cookie is a map used to store cookies.
 type Cookie map[string]string
 
-// Add method impl the method in WithStruct interface.
+// Add adds a cookie key-value pair.
 func (c Cookie) Add(key, val string) {
 	c[key] = val
 }
 
-// Del method impl the method in WithStruct interface.
+// Del deletes a cookie by key.
 func (c Cookie) Del(key string) {
 	delete(c, key)
 }
 
-// SetCookie method sets a single val in Cookie.
+// SetCookie sets a single cookie value.
 func (c Cookie) SetCookie(key, val string) {
 	c[key] = val
 }
 
-// SetCookies method sets multiple val in Cookie.
+// SetCookies sets multiple cookies from a map.
 func (c Cookie) SetCookies(m map[string]string) {
 	for k, v := range m {
 		c[k] = v
 	}
 }
 
-// SetCookiesWithStruct method sets multiple val in Cookie via a struct.
+// SetCookiesWithStruct sets cookies from a struct.
+// Nested structs are not currently supported.
 func (c Cookie) SetCookiesWithStruct(v any) {
 	SetValWithStruct(c, "cookie", v)
 }
 
-// DelCookies method deletes multiple val in Cookie.
+// DelCookies deletes multiple cookies by keys.
 func (c Cookie) DelCookies(key ...string) {
 	for _, v := range key {
 		c.Del(v)
 	}
 }
 
-// VisitAll method receive a function which can travel the all val.
+// VisitAll iterates through all cookies, calling f for each.
 func (c Cookie) VisitAll(f func(key, val string)) {
 	for k, v := range c {
 		f(k, v)
 	}
 }
 
-// Reset clears the Cookie object.
+// Reset clears the Cookie map.
 func (c Cookie) Reset() {
 	for k := range c {
 		delete(c, k)
 	}
 }
 
-// PathParam is a map which to store path params.
+// PathParam is a map used to store path parameters.
 type PathParam map[string]string
 
-// Add method impl the method in WithStruct interface.
+// Add adds a path parameter key-value pair.
 func (p PathParam) Add(key, val string) {
 	p[key] = val
 }
 
-// Del method impl the method in WithStruct interface.
+// Del deletes a path parameter by key.
 func (p PathParam) Del(key string) {
 	delete(p, key)
 }
 
-// SetParam method sets a single val in PathParam.
+// SetParam sets a single path parameter.
 func (p PathParam) SetParam(key, val string) {
 	p[key] = val
 }
 
-// SetParams method sets multiple val in PathParam.
+// SetParams sets multiple path parameters from a map.
 func (p PathParam) SetParams(m map[string]string) {
 	for k, v := range m {
 		p[k] = v
 	}
 }
 
-// SetParamsWithStruct method sets multiple val in PathParam via a struct.
+// SetParamsWithStruct sets multiple path parameters from a struct.
+// Nested structs are not currently supported.
 func (p PathParam) SetParamsWithStruct(v any) {
 	SetValWithStruct(p, "path", v)
 }
 
-// DelParams method deletes multiple val in PathParams.
+// DelParams deletes multiple path parameters.
 func (p PathParam) DelParams(key ...string) {
 	for _, v := range key {
 		p.Del(v)
 	}
 }
 
-// VisitAll method receive a function which can travel the all val.
+// VisitAll iterates through all path parameters, calling f for each.
 func (p PathParam) VisitAll(f func(key, val string)) {
 	for k, v := range p {
 		f(k, v)
 	}
 }
 
-// Reset clear the PathParam object.
+// Reset clears the PathParam map.
 func (p PathParam) Reset() {
 	for k := range p {
 		delete(p, k)
 	}
 }
 
-// FormData is a wrapper of fasthttp.Args,
-// and it is used for url encode body and file body.
+// FormData wraps fasthttp.Args for URL-encoded bodies and form data.
 type FormData struct {
 	*fasthttp.Args
 }
 
-// Keys method returns all keys in the form data.
+// Keys returns all keys from the form data.
 func (f *FormData) Keys() []string {
 	keys := make([]string, 0, f.Len())
 	f.VisitAll(func(key, _ []byte) {
 		keys = append(keys, utils.UnsafeString(key))
 	})
-
 	return slices.Compact(keys)
 }
 
-// AddData method is a wrapper of Args's Add method.
+// AddData adds a single form field.
 func (f *FormData) AddData(key, val string) {
 	f.Add(key, val)
 }
 
-// SetData method is a wrapper of Args's Set method.
+// SetData sets a single form field, overriding previously set values.
 func (f *FormData) SetData(key, val string) {
 	f.Set(key, val)
 }
 
-// AddDatas method supports add multiple fields.
+// AddDatas adds multiple form fields from a map.
 func (f *FormData) AddDatas(m map[string][]string) {
 	for k, v := range m {
 		for _, vv := range v {
@@ -899,31 +863,32 @@ func (f *FormData) AddDatas(m map[string][]string) {
 	}
 }
 
-// SetDatas method supports set multiple fields.
+// SetDatas sets multiple form fields from a map, overriding previously set values.
 func (f *FormData) SetDatas(m map[string]string) {
 	for k, v := range m {
 		f.Set(k, v)
 	}
 }
 
-// SetDatasWithStruct method supports set multiple fields via a struct.
+// SetDatasWithStruct sets multiple form fields from a struct.
+// Nested structs are not currently supported.
 func (f *FormData) SetDatasWithStruct(v any) {
 	SetValWithStruct(f, "form", v)
 }
 
-// DelDatas method deletes multiple fields.
+// DelDatas deletes multiple form fields.
 func (f *FormData) DelDatas(key ...string) {
 	for _, v := range key {
 		f.Del(v)
 	}
 }
 
-// Reset clear the FormData object.
+// Reset clears the FormData object.
 func (f *FormData) Reset() {
 	f.Args.Reset()
 }
 
-// File is a struct which support send files via request.
+// File represents a file to be sent with the request.
 type File struct {
 	reader    io.ReadCloser
 	name      string
@@ -931,28 +896,27 @@ type File struct {
 	path      string
 }
 
-// SetName method sets file name.
+// SetName sets the file's name.
 func (f *File) SetName(n string) {
 	f.name = n
 }
 
-// SetFieldName method sets key of file in the body.
+// SetFieldName sets the key associated with the file in the body.
 func (f *File) SetFieldName(n string) {
 	f.fieldName = n
 }
 
-// SetPath method set file path.
+// SetPath sets the file's path.
 func (f *File) SetPath(p string) {
 	f.path = p
 }
 
-// SetReader method can receive a io.ReadCloser
-// which will be closed in parserBody hook.
+// SetReader sets the file's reader, which will be closed in the parserBody hook.
 func (f *File) SetReader(r io.ReadCloser) {
 	f.reader = r
 }
 
-// Reset clear the File object.
+// Reset clears the File object.
 func (f *File) Reset() {
 	f.name = ""
 	f.fieldName = ""
@@ -975,22 +939,17 @@ var requestPool = &sync.Pool{
 	},
 }
 
-// AcquireRequest returns an empty request object from the pool.
-//
-// The returned request may be returned to the pool with ReleaseRequest when no longer needed.
-// This allows reducing GC load.
+// AcquireRequest returns a new (pooled) Request object.
 func AcquireRequest() *Request {
 	req, ok := requestPool.Get().(*Request)
 	if !ok {
 		panic(errors.New("failed to type-assert to *Request"))
 	}
-
 	return req
 }
 
-// ReleaseRequest returns the object acquired via AcquireRequest to the pool.
-//
-// Do not access the released Request object, otherwise data races may occur.
+// ReleaseRequest returns the Request object to the pool.
+// Do not use the released Request afterward to avoid data races.
 func ReleaseRequest(req *Request) {
 	req.Reset()
 	requestPool.Put(req)
@@ -998,43 +957,38 @@ func ReleaseRequest(req *Request) {
 
 var filePool sync.Pool
 
-// SetFileFunc The methods as follows is used by AcquireFile method.
-// You can set file field via these method.
+// SetFileFunc defines a function that modifies a File object.
 type SetFileFunc func(f *File)
 
-// SetFileName method sets file name.
+// SetFileName sets the file name.
 func SetFileName(n string) SetFileFunc {
 	return func(f *File) {
 		f.SetName(n)
 	}
 }
 
-// SetFileFieldName method sets key of file in the body.
+// SetFileFieldName sets the file's field name.
 func SetFileFieldName(p string) SetFileFunc {
 	return func(f *File) {
 		f.SetFieldName(p)
 	}
 }
 
-// SetFilePath method set file path.
+// SetFilePath sets the file path.
 func SetFilePath(p string) SetFileFunc {
 	return func(f *File) {
 		f.SetPath(p)
 	}
 }
 
-// SetFileReader method can receive a io.ReadCloser
+// SetFileReader sets the file's reader.
 func SetFileReader(r io.ReadCloser) SetFileFunc {
 	return func(f *File) {
 		f.SetReader(r)
 	}
 }
 
-// AcquireFile returns an File object from the pool.
-// And you can set field in the File with SetFileFunc.
-//
-// The returned file may be returned to the pool with ReleaseFile when no longer needed.
-// This allows reducing GC load.
+// AcquireFile returns a (pooled) File object and applies the provided SetFileFunc functions to it.
 func AcquireFile(setter ...SetFileFunc) *File {
 	fv := filePool.Get()
 	if fv != nil {
@@ -1054,24 +1008,23 @@ func AcquireFile(setter ...SetFileFunc) *File {
 	return f
 }
 
-// ReleaseFile returns the object acquired via AcquireFile to the pool.
-//
-// Do not access the released File object, otherwise data races may occur.
+// ReleaseFile returns the File object to the pool.
+// Do not use the released File afterward to avoid data races.
 func ReleaseFile(f *File) {
 	f.Reset()
 	filePool.Put(f)
 }
 
-// SetValWithStruct Set some values using structs.
-// `p` is a structure that implements the WithStruct interface,
-// The field name can be specified by `tagName`.
-// `v` is a struct include some data.
-// Note: This method only supports simple types and nested structs are not currently supported.
+// SetValWithStruct sets values using a struct. The struct's fields are examined via reflection.
+// `p` is a type that implements WithStruct. `tagName` defines the struct tag to look for.
+// `v` is the struct containing data.
+//
+// Only simple types are supported; nested structs are not currently supported.
 func SetValWithStruct(p WithStruct, tagName string, v any) {
 	valueOfV := reflect.ValueOf(v)
 	typeOfV := reflect.TypeOf(v)
 
-	// The v should be struct or point of struct
+	// The value should be a struct or a pointer to a struct.
 	if typeOfV.Kind() == reflect.Pointer && typeOfV.Elem().Kind() == reflect.Struct {
 		valueOfV = valueOfV.Elem()
 		typeOfV = typeOfV.Elem()
@@ -1079,9 +1032,8 @@ func SetValWithStruct(p WithStruct, tagName string, v any) {
 		return
 	}
 
-	// Boring type judge.
-	// TODO: cover more types and complex data structure.
-	var setVal func(name string, value reflect.Value)
+	// A helper function to set values.
+	var setVal func(name string, val reflect.Value)
 	setVal = func(name string, val reflect.Value) {
 		switch val.Kind() {
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
@@ -1099,6 +1051,7 @@ func SetValWithStruct(p WithStruct, tagName string, v any) {
 				setVal(name, val.Index(i))
 			}
 		default:
+			// Unsupported type is ignored.
 		}
 	}
 
@@ -1116,7 +1069,7 @@ func SetValWithStruct(p WithStruct, tagName string, v any) {
 		if val.IsZero() {
 			continue
 		}
-		// To cover slice and array, we delete the val then add it.
+		// Clear existing value before adding a new one.
 		p.Del(name)
 		setVal(name, val)
 	}
diff --git a/client/response.go b/client/response.go
index 8d21329774..c9b40b1fe2 100644
--- a/client/response.go
+++ b/client/response.go
@@ -15,7 +15,7 @@ import (
 	"github.com/valyala/fasthttp"
 )
 
-// Response is the result of a request. This object is used to access the response data.
+// Response represents the result of a request. It provides access to the response data.
 type Response struct {
 	client  *Client
 	request *Request
@@ -24,47 +24,44 @@ type Response struct {
 	cookie      []*fasthttp.Cookie
 }
 
-// setClient method sets client object in response instance.
-// Use core object in the client.
+// setClient sets the client instance in the response. The client object is used by core functionalities.
 func (r *Response) setClient(c *Client) {
 	r.client = c
 }
 
-// setRequest method sets Request object in response instance.
-// The request will be released when the Response.Close is called.
+// setRequest sets the request object in the response. The request is released when Response.Close is called.
 func (r *Response) setRequest(req *Request) {
 	r.request = req
 }
 
-// Status method returns the HTTP status string for the executed request.
+// Status returns the HTTP status message of the executed request.
 func (r *Response) Status() string {
 	return string(r.RawResponse.Header.StatusMessage())
 }
 
-// StatusCode method returns the HTTP status code for the executed request.
+// StatusCode returns the HTTP status code of the executed request.
 func (r *Response) StatusCode() int {
 	return r.RawResponse.StatusCode()
 }
 
-// Protocol method returns the HTTP response protocol used for the request.
+// Protocol returns the HTTP protocol used for the request.
 func (r *Response) Protocol() string {
 	return string(r.RawResponse.Header.Protocol())
 }
 
-// Header method returns the response headers.
+// Header returns the value of the specified response header field.
 func (r *Response) Header(key string) string {
 	return utils.UnsafeString(r.RawResponse.Header.Peek(key))
 }
 
 // Headers returns all headers in the response using an iterator.
-// You can use maps.Collect() to collect all headers into a map.
+// Use maps.Collect() to gather them into a map if needed.
 //
-// The returned value is valid until the response object is released.
-// Any future calls to Headers method will return the modified value. Do not store references to returned value. Make copies instead.
+// The returned values are valid only until the response object is released.
+// Do not store references to returned values; make copies instead.
 func (r *Response) Headers() iter.Seq2[string, []string] {
 	return func(yield func(string, []string) bool) {
 		keys := r.RawResponse.Header.PeekKeys()
-
 		for _, key := range keys {
 			vals := r.RawResponse.Header.PeekAll(utils.UnsafeString(key))
 			valsStr := make([]string, len(vals))
@@ -79,47 +76,49 @@ func (r *Response) Headers() iter.Seq2[string, []string] {
 	}
 }
 
-// Cookies method to access all the response cookies.
+// Cookies returns all cookies set by the response.
 //
-// The returned value is valid until the response object is released.
-// Any future calls to Cookies method will return the modified value. Do not store references to returned value. Make copies instead.
+// The returned values are valid only until the response object is released.
+// Do not store references to returned values; make copies instead.
 func (r *Response) Cookies() []*fasthttp.Cookie {
 	return r.cookie
 }
 
-// Body method returns HTTP response as []byte array for the executed request.
+// Body returns the HTTP response body as a byte slice.
 func (r *Response) Body() []byte {
 	return r.RawResponse.Body()
 }
 
-// String method returns the body of the server response as String.
+// String returns the response body as a trimmed string.
 func (r *Response) String() string {
 	return utils.Trim(string(r.Body()), ' ')
 }
 
-// JSON method will unmarshal body to json.
+// JSON unmarshals the response body into the given interface{} using JSON.
 func (r *Response) JSON(v any) error {
 	return r.client.jsonUnmarshal(r.Body(), v)
 }
 
-// CBOR method will unmarshal body to CBOR.
+// CBOR unmarshals the response body into the given interface{} using CBOR.
 func (r *Response) CBOR(v any) error {
 	return r.client.cborUnmarshal(r.Body(), v)
 }
 
-// XML method will unmarshal body to xml.
+// XML unmarshals the response body into the given interface{} using XML.
 func (r *Response) XML(v any) error {
 	return r.client.xmlUnmarshal(r.Body(), v)
 }
 
-// Save method will save the body to a file or io.Writer.
+// Save writes the response body to a file or io.Writer.
+// If a string path is provided, it creates directories if needed, then writes to a file.
+// If an io.Writer is provided, it writes directly to it.
 func (r *Response) Save(v any) error {
 	switch p := v.(type) {
 	case string:
 		file := filepath.Clean(p)
 		dir := filepath.Dir(file)
 
-		// create directory
+		// Create directory if it doesn't exist
 		if _, err := os.Stat(dir); err != nil {
 			if !errors.Is(err, fs.ErrNotExist) {
 				return fmt.Errorf("failed to check directory: %w", err)
@@ -130,22 +129,21 @@ func (r *Response) Save(v any) error {
 			}
 		}
 
-		// create file
+		// Create and write to file
 		outFile, err := os.Create(file)
 		if err != nil {
 			return fmt.Errorf("failed to create file: %w", err)
 		}
 		defer func() { _ = outFile.Close() }() //nolint:errcheck // not needed
 
-		_, err = io.Copy(outFile, bytes.NewReader(r.Body()))
-		if err != nil {
+		if _, err = io.Copy(outFile, bytes.NewReader(r.Body())); err != nil {
 			return fmt.Errorf("failed to write response body to file: %w", err)
 		}
 
 		return nil
+
 	case io.Writer:
-		_, err := io.Copy(p, bytes.NewReader(r.Body()))
-		if err != nil {
+		if _, err := io.Copy(p, bytes.NewReader(r.Body())); err != nil {
 			return fmt.Errorf("failed to write response body to io.Writer: %w", err)
 		}
 		defer func() {
@@ -153,14 +151,14 @@ func (r *Response) Save(v any) error {
 				_ = pc.Close() //nolint:errcheck // not needed
 			}
 		}()
-
 		return nil
+
 	default:
 		return ErrNotSupportSaveMethod
 	}
 }
 
-// Reset clears the Response object.
+// Reset clears the Response object, making it ready for reuse.
 func (r *Response) Reset() {
 	r.client = nil
 	r.request = nil
@@ -174,8 +172,8 @@ func (r *Response) Reset() {
 	r.RawResponse.Reset()
 }
 
-// Close method will release Request object and Response object,
-// after call Close please don't use these object.
+// Close releases both the Request and Response objects back to their pools.
+// After calling Close, do not use these objects.
 func (r *Response) Close() {
 	if r.request != nil {
 		tmp := r.request
@@ -194,10 +192,8 @@ var responsePool = &sync.Pool{
 	},
 }
 
-// AcquireResponse returns an empty response object from the pool.
-//
-// The returned response may be returned to the pool with ReleaseResponse when no longer needed.
-// This allows reducing GC load.
+// AcquireResponse returns a new (pooled) Response object.
+// When done, release it with ReleaseResponse to reduce GC load.
 func AcquireResponse() *Response {
 	resp, ok := responsePool.Get().(*Response)
 	if !ok {
@@ -206,9 +202,8 @@ func AcquireResponse() *Response {
 	return resp
 }
 
-// ReleaseResponse returns the object acquired via AcquireResponse to the pool.
-//
-// Do not access the released Response object, otherwise data races may occur.
+// ReleaseResponse returns the Response object to the pool.
+// Do not use the released Response afterward to avoid data races.
 func ReleaseResponse(resp *Response) {
 	resp.Reset()
 	responsePool.Put(resp)