package resty

Import Path
	github.com/go-resty/resty/v2 (on go.dev)

Dependency Relation
	imports 36 packages, and imported by 2 packages

Involved Source Files

	    client.go
	    digest.go
	    middleware.go
	    redirect.go
	    request.go
	    response.go
	  d resty.go
		Package resty provides Simple HTTP and REST client library for Go.

	    retry.go
	    trace.go
	    transport.go
	    transport_other.go
	    util.go
Code Examples

	Client_SetCertificates
	  {
	  
	  	cert, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
	  	if err != nil {
	  		log.Fatalf("ERROR client certificate: %s", err)
	  	}
	  
	  	client := resty.New()
	  
	  	client.SetCertificates(cert)
	  }
	New
	  {
	  
	  	client1 := resty.New()
	  	resp1, err1 := client1.R().Get("http://httpbin.org/get")
	  	fmt.Println(resp1, err1)
	  
	  	client2 := resty.New()
	  	resp2, err2 := client2.R().Get("http://httpbin.org/get")
	  	fmt.Println(resp2, err2)
	  }
	_clientCertificates
	  {
	  
	  	cert, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
	  	if err != nil {
	  		log.Fatalf("ERROR client certificate: %s", err)
	  	}
	  
	  	client := resty.New()
	  
	  	client.SetCertificates(cert)
	  }
	_customRootCertificate
	  {
	  
	  	client := resty.New()
	  	client.SetRootCertificate("/path/to/root/pemFile.pem")
	  }
	_dropboxUpload
	  {
	  
	  	fileBytes, _ := os.ReadFile("/Users/jeeva/mydocument.pdf")
	  
	  	client := resty.New()
	  
	  	resp, err := client.R().
	  		SetBody(fileBytes).
	  		SetContentLength(true).
	  		SetAuthToken("<your-auth-token>").
	  		SetError(DropboxError{}).
	  		Post("https://content.dropboxapi.com/1/files_put/auto/resty/mydocument.pdf")
	  
	  	fmt.Printf("\nError: %v\n", err)
	  	fmt.Printf("Time: %v\n", resp.Time())
	  	fmt.Printf("Body: %v\n", resp)
	  }
	_enhancedGet
	  {
	  
	  	client := resty.New()
	  
	  	resp, err := client.R().
	  		SetQueryParams(map[string]string{
	  			"page_no": "1",
	  			"limit":   "20",
	  			"sort":    "name",
	  			"order":   "asc",
	  			"random":  strconv.FormatInt(time.Now().Unix(), 10),
	  		}).
	  		SetHeader("Accept", "application/json").
	  		SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F").
	  		Get("/search_result")
	  
	  	printOutput(resp, err)
	  }
	_get
	  {
	  
	  	client := resty.New()
	  
	  	resp, err := client.R().Get("http://httpbin.org/get")
	  
	  	fmt.Printf("\nError: %v", err)
	  	fmt.Printf("\nResponse Status Code: %v", resp.StatusCode())
	  	fmt.Printf("\nResponse Status: %v", resp.Status())
	  	fmt.Printf("\nResponse Body: %v", resp)
	  	fmt.Printf("\nResponse Time: %v", resp.Time())
	  	fmt.Printf("\nResponse Received At: %v", resp.ReceivedAt())
	  }
	_post
	  {
	  
	  	client := resty.New()
	  
	  	resp, err := client.R().
	  		SetHeader("Content-Type", "application/json").
	  		SetBody(`{"username":"testuser", "password":"testpass"}`).
	  		SetResult(AuthSuccess{}).
	  		Post("https://myapp.com/login")
	  
	  	printOutput(resp, err)
	  
	  	resp1, err1 := client.R().
	  		SetHeader("Content-Type", "application/json").
	  		SetBody([]byte(`{"username":"testuser", "password":"testpass"}`)).
	  		SetResult(AuthSuccess{}).
	  		Post("https://myapp.com/login")
	  
	  	printOutput(resp1, err1)
	  
	  	resp2, err2 := client.R().
	  		SetBody(resty.User{Username: "testuser", Password: "testpass"}).
	  		SetResult(&AuthSuccess{}).
	  		SetError(&AuthError{}).
	  		Post("https://myapp.com/login")
	  
	  	printOutput(resp2, err2)
	  
	  	resp3, err3 := client.R().
	  		SetBody(map[string]interface{}{"username": "testuser", "password": "testpass"}).
	  		SetResult(&AuthSuccess{}).
	  		SetError(&AuthError{}).
	  		Post("https://myapp.com/login")
	  
	  	printOutput(resp3, err3)
	  }
	_put
	  {
	  
	  	client := resty.New()
	  
	  	resp, err := client.R().
	  		SetBody(Article{
	  			Title:   "go-resty",
	  			Content: "This is my article content, oh ya!",
	  			Author:  "Jeevanandam M",
	  			Tags:    []string{"article", "sample", "resty"},
	  		}).
	  		SetAuthToken("C6A79608-782F-4ED0-A11D-BD82FAD829CD").
	  		SetError(&Error{}).
	  		Put("https://myapp.com/article/1234")
	  
	  	printOutput(resp, err)
	  }
	_socks5Proxy
	  {
	  
	  	dialer, err := proxy.SOCKS5("tcp", "127.0.0.1:9150", nil, proxy.Direct)
	  	if err != nil {
	  		log.Fatalf("Unable to obtain proxy dialer: %v\n", err)
	  	}
	  
	  	ptransport := &http.Transport{Dial: dialer.Dial}
	  
	  	client := resty.New()
	  
	  	client.SetTransport(ptransport)
	  
	  	resp, err := client.R().Get("http://check.torproject.org")
	  	fmt.Println(err, resp)
	  }

Package-Level Type Names (total 27)

	/* sort by: alphabet | popularity */
	 type Client (struct)
		Client struct is used to create Resty client with client level settings,
		these settings are applicable to all the request raised from the client.
		
		Resty also provides an options to override most of the client settings
		at request level.

		Fields (total 27)
			AllowGetMethodPayload bool
			AuthScheme string
			BaseURL string
			Cookies []*http.Cookie
			Debug bool
			DisableWarn bool
			Error reflect.Type
			FormData url.Values
			Header http.Header
			HeaderAuthorizationKey string
				HeaderAuthorizationKey is used to set/access Request Authorization header
				value when `SetAuthToken` option is used.

			HostURL string
				// Deprecated: use BaseURL instead. To be removed in v3.0.0 release.

			JSONMarshal func(v interface{}) ([]byte, error)
			JSONUnmarshal func(data []byte, v interface{}) error
			PathParams map[string]string
			QueryParam url.Values
			RawPathParams map[string]string
			RetryAfter RetryAfterFunc
			RetryConditions []RetryConditionFunc
			RetryCount int
			RetryHooks []OnRetryFunc
			RetryMaxWaitTime time.Duration
			RetryResetReaders bool
			RetryWaitTime time.Duration
			Token string
			UserInfo *User
			XMLMarshal func(v interface{}) ([]byte, error)
			XMLUnmarshal func(data []byte, v interface{}) error
		Methods (total 69)
			(*Client) AddRetryAfterErrorCondition() *Client
				AddRetryAfterErrorCondition adds the basic condition of retrying after encountering
				an error from the http response
				
				Since v2.6.0

			(*Client) AddRetryCondition(condition RetryConditionFunc) *Client
				AddRetryCondition method adds a retry condition function to array of functions
				that are checked to determine if the request is retried. The request will
				retry if any of the functions return true and error is nil.
				
				Note: These retry conditions are applied on all Request made using this Client.
				For Request specific retry conditions check *Request.AddRetryCondition

			(*Client) AddRetryHook(hook OnRetryFunc) *Client
				AddRetryHook adds a side-effecting retry hook to an array of hooks
				that will be executed on each retry.
				
				Since v2.6.0

			(*Client) DisableTrace() *Client
				DisableTrace method disables the Resty client trace. Refer to `Client.EnableTrace`.
				
				Since v2.0.0

			(*Client) EnableTrace() *Client
				EnableTrace method enables the Resty client trace for the requests fired from
				the client using `httptrace.ClientTrace` and provides insights.
				
					client := resty.New().EnableTrace()
				
					resp, err := client.R().Get("https://httpbin.org/get")
					fmt.Println("Error:", err)
					fmt.Println("Trace Info:", resp.Request.TraceInfo())
				
				Also `Request.EnableTrace` available too to get trace info for single request.
				
				Since v2.0.0

			(*Client) GetClient() *http.Client
				GetClient method returns the current `http.Client` used by the resty client.

			(*Client) IsProxySet() bool
				IsProxySet method returns the true is proxy is set from resty client otherwise
				false. By default proxy is set from environment, refer to `http.ProxyFromEnvironment`.

			(*Client) NewRequest() *Request
				NewRequest is an alias for method `R()`. Creates a new request instance, its used for
				Get, Post, Put, Delete, Patch, Head, Options, etc.

			(*Client) OnAfterResponse(m ResponseMiddleware) *Client
				OnAfterResponse method appends response middleware into the after response chain.
				Once we receive response from host server, default Resty response middleware
				gets applied and then user assigned response middlewares applied.
				
					client.OnAfterResponse(func(c *resty.Client, r *resty.Response) error {
							// Now you have access to Client and Response instance
							// manipulate it as per your need
				
							return nil 	// if its success otherwise return error
						})

			(*Client) OnBeforeRequest(m RequestMiddleware) *Client
				OnBeforeRequest method appends a request middleware into the before request chain.
				The user defined middlewares get applied before the default Resty request middlewares.
				After all middlewares have been applied, the request is sent from Resty to the host server.
				
					client.OnBeforeRequest(func(c *resty.Client, r *resty.Request) error {
							// Now you have access to Client and Request instance
							// manipulate it as per your need
				
							return nil 	// if its success otherwise return error
						})

			(*Client) OnError(h ErrorHook) *Client
				OnError method adds a callback that will be run whenever a request execution fails.
				This is called after all retries have been attempted (if any).
				If there was a response from the server, the error will be wrapped in *ResponseError
				which has the last response received from the server.
				
					client.OnError(func(req *resty.Request, err error) {
						if v, ok := err.(*resty.ResponseError); ok {
							// Do something with v.Response
						}
						// Log the error, increment a metric, etc...
					})
				
				Out of the OnSuccess, OnError, OnInvalid, OnPanic callbacks, exactly one
				set will be invoked for each call to Request.Execute() that completes.

			(*Client) OnInvalid(h ErrorHook) *Client
				OnInvalid method adds a callback that will be run whenever a request execution
				fails before it starts because the request is invalid.
				
				Out of the OnSuccess, OnError, OnInvalid, OnPanic callbacks, exactly one
				set will be invoked for each call to Request.Execute() that completes.
				
				Since v2.8.0

			(*Client) OnPanic(h ErrorHook) *Client
				OnPanic method adds a callback that will be run whenever a request execution
				panics.
				
				Out of the OnSuccess, OnError, OnInvalid, OnPanic callbacks, exactly one
				set will be invoked for each call to Request.Execute() that completes.
				If an OnSuccess, OnError, or OnInvalid callback panics, then the exactly
				one rule can be violated.
				
				Since v2.8.0

			(*Client) OnRequestLog(rl RequestLogCallback) *Client
				OnRequestLog method used to set request log callback into Resty. Registered callback gets
				called before the resty actually logs the information.

			(*Client) OnResponseLog(rl ResponseLogCallback) *Client
				OnResponseLog method used to set response log callback into Resty. Registered callback gets
				called before the resty actually logs the information.

			(*Client) OnSuccess(h SuccessHook) *Client
				OnSuccess method adds a callback that will be run whenever a request execution
				succeeds.  This is called after all retries have been attempted (if any).
				
				Out of the OnSuccess, OnError, OnInvalid, OnPanic callbacks, exactly one
				set will be invoked for each call to Request.Execute() that completes.
				
				Since v2.8.0

			(*Client) R() *Request
				R method creates a new request instance, its used for Get, Post, Put, Delete, Patch, Head, Options, etc.

			(*Client) RemoveProxy() *Client
				RemoveProxy method removes the proxy configuration from Resty client
				
					client.RemoveProxy()

			(*Client) SetAllowGetMethodPayload(a bool) *Client
				SetAllowGetMethodPayload method allows the GET method with payload on Resty client.
				
				For Example: Resty allows the user sends request with a payload on HTTP GET method.
				
					client.SetAllowGetMethodPayload(true)

			(*Client) SetAuthScheme(scheme string) *Client
				SetAuthScheme method sets the auth scheme type in the HTTP request. For Example:
				
					Authorization: <auth-scheme-value> <auth-token-value>
				
				For Example: To set the scheme to use OAuth
				
					client.SetAuthScheme("OAuth")
				
				This auth scheme gets added to all the requests raised from this client instance.
				Also it can be overridden or set one at the request level is supported.
				
				Information about auth schemes can be found in RFC7235 which is linked to below
				along with the page containing the currently defined official authentication schemes:
				
					https://tools.ietf.org/html/rfc7235
					https://www.iana.org/assignments/http-authschemes/http-authschemes.xhtml#authschemes
				
				See `Request.SetAuthToken`.

			(*Client) SetAuthToken(token string) *Client
				SetAuthToken method sets the auth token of the `Authorization` header for all HTTP requests.
				The default auth scheme is `Bearer`, it can be customized with the method `SetAuthScheme`. For Example:
				
					Authorization: <auth-scheme> <auth-token-value>
				
				For Example: To set auth token BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F
				
					client.SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F")
				
				This auth token gets added to all the requests raised from this client instance.
				Also it can be overridden or set one at the request level is supported.
				
				See `Request.SetAuthToken`.

			(*Client) SetBaseURL(url string) *Client
				SetBaseURL method is to set Base URL in the client instance. It will be used with request
				raised from this client with relative URL
				
					// Setting HTTP address
					client.SetBaseURL("http://myjeeva.com")
				
					// Setting HTTPS address
					client.SetBaseURL("https://myjeeva.com")
				
				Since v2.7.0

			(*Client) SetBasicAuth(username, password string) *Client
				SetBasicAuth method sets the basic authentication header in the HTTP request. For Example:
				
					Authorization: Basic <base64-encoded-value>
				
				For Example: To set the header for username "go-resty" and password "welcome"
				
					client.SetBasicAuth("go-resty", "welcome")
				
				This basic auth information gets added to all the request raised from this client instance.
				Also it can be overridden or set one at the request level is supported.
				
				See `Request.SetBasicAuth`.

			(*Client) SetCertificates(certs ...tls.Certificate) *Client
				SetCertificates method helps to set client certificates into Resty conveniently.

			(*Client) SetCloseConnection(close bool) *Client
				SetCloseConnection method sets variable `Close` in http request struct with the given
				value. More info: https://golang.org/src/net/http/request.go

			(*Client) SetContentLength(l bool) *Client
				SetContentLength method enables the HTTP header `Content-Length` value for every request.
				By default Resty won't set `Content-Length`.
				
					client.SetContentLength(true)
				
				Also you have an option to enable for particular request. See `Request.SetContentLength`

			(*Client) SetCookie(hc *http.Cookie) *Client
				SetCookie method appends a single cookie in the client instance.
				These cookies will be added to all the request raised from this client instance.
				
					client.SetCookie(&http.Cookie{
								Name:"go-resty",
								Value:"This is cookie value",
							})

			(*Client) SetCookieJar(jar http.CookieJar) *Client
				SetCookieJar method sets custom http.CookieJar in the resty client. Its way to override default.
				
				For Example: sometimes we don't want to save cookies in api contacting, we can remove the default
				CookieJar in resty client.
				
					client.SetCookieJar(nil)

			(*Client) SetCookies(cs []*http.Cookie) *Client
				SetCookies method sets an array of cookies in the client instance.
				These cookies will be added to all the request raised from this client instance.
				
					cookies := []*http.Cookie{
						&http.Cookie{
							Name:"go-resty-1",
							Value:"This is cookie 1 value",
						},
						&http.Cookie{
							Name:"go-resty-2",
							Value:"This is cookie 2 value",
						},
					}
				
					// Setting a cookies into resty
					client.SetCookies(cookies)

			(*Client) SetDebug(d bool) *Client
				SetDebug method enables the debug mode on Resty client. Client logs details of every request and response.
				For `Request` it logs information such as HTTP verb, Relative URL path, Host, Headers, Body if it has one.
				For `Response` it logs information such as Status, Response Time, Headers, Body if it has one.
				
					client.SetDebug(true)
				
				Also it can be enabled at request level for particular request, see `Request.SetDebug`.

			(*Client) SetDebugBodyLimit(sl int64) *Client
				SetDebugBodyLimit sets the maximum size for which the response and request body will be logged in debug mode.
				
					client.SetDebugBodyLimit(1000000)

			(*Client) SetDigestAuth(username, password string) *Client
				SetDigestAuth method sets the Digest Access auth scheme for the client. If a server responds with 401 and sends
				a Digest challenge in the WWW-Authenticate Header, requests will be resent with the appropriate Authorization Header.
				
				For Example: To set the Digest scheme with user "Mufasa" and password "Circle Of Life"
				
					client.SetDigestAuth("Mufasa", "Circle Of Life")
				
				Information about Digest Access Authentication can be found in RFC7616:
				
					https://datatracker.ietf.org/doc/html/rfc7616
				
				See `Request.SetDigestAuth`.

			(*Client) SetDisableWarn(d bool) *Client
				SetDisableWarn method disables the warning message on Resty client.
				
				For Example: Resty warns the user when BasicAuth used on non-TLS mode.
				
					client.SetDisableWarn(true)

			(*Client) SetDoNotParseResponse(parse bool) *Client
				SetDoNotParseResponse method instructs `Resty` not to parse the response body automatically.
				Resty exposes the raw response body as `io.ReadCloser`. Also do not forget to close the body,
				otherwise you might get into connection leaks, no connection reuse.
				
				Note: Response middlewares are not applicable, if you use this option. Basically you have
				taken over the control of response parsing from `Resty`.

			(*Client) SetError(err interface{}) *Client
				SetError method is to register the global or client common `Error` object into Resty.
				It is used for automatic unmarshalling if response status code is greater than 399 and
				content type either JSON or XML. Can be pointer or non-pointer.
				
					client.SetError(&Error{})
					// OR
					client.SetError(Error{})

			(*Client) SetFormData(data map[string]string) *Client
				SetFormData method sets Form parameters and their values in the client instance.
				It's applicable only HTTP method `POST` and `PUT` and request content type would be set as
				`application/x-www-form-urlencoded`. These form data will be added to all the request raised from
				this client instance. Also it can be overridden at request level form data.
				
				See `Request.SetFormData`.
				
					client.SetFormData(map[string]string{
							"access_token": "BC594900-518B-4F7E-AC75-BD37F019E08F",
							"user_id": "3455454545",
						})

			(*Client) SetHeader(header, value string) *Client
				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.
				
				See `Request.SetHeader` or `Request.SetHeaders`.
				
				For Example: To set `Content-Type` and `Accept` as `application/json`
				
					client.
						SetHeader("Content-Type", "application/json").
						SetHeader("Accept", "application/json")

			(*Client) SetHeaderVerbatim(header, value string) *Client
				SetHeaderVerbatim method is to set a single header field and its value verbatim in the current request.
				
				For Example: To set `all_lowercase` and `UPPERCASE` as `available`.
				
					client.R().
						SetHeaderVerbatim("all_lowercase", "available").
						SetHeaderVerbatim("UPPERCASE", "available")
				
				Also you can override header value, which was set at client instance level.
				
				Since v2.6.0

			(*Client) SetHeaders(headers map[string]string) *Client
				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.
				
				See `Request.SetHeaders` or `Request.SetHeader`.
				
				For Example: To set `Content-Type` and `Accept` as `application/json`
				
					client.SetHeaders(map[string]string{
							"Content-Type": "application/json",
							"Accept": "application/json",
						})

			(*Client) SetHostURL(url string) *Client
				SetHostURL method is to set Host URL in the client instance. It will be used with request
				raised from this client with relative URL
				
					// Setting HTTP address
					client.SetHostURL("http://myjeeva.com")
				
					// Setting HTTPS address
					client.SetHostURL("https://myjeeva.com")
				
				Deprecated: use SetBaseURL instead. To be removed in v3.0.0 release.

			(*Client) SetJSONEscapeHTML(b bool) *Client
				SetJSONEscapeHTML method is to enable/disable the HTML escape on JSON marshal.
				
				Note: This option only applicable to standard JSON Marshaller.

			(*Client) SetJSONMarshaler(marshaler func(v interface{}) ([]byte, error)) *Client
				SetJSONMarshaler method sets the JSON marshaler function to marshal the request body.
				By default, Resty uses `encoding/json` package to marshal the request body.
				
				Since v2.8.0

			(*Client) SetJSONUnmarshaler(unmarshaler func(data []byte, v interface{}) error) *Client
				SetJSONUnmarshaler method sets the JSON unmarshaler function to unmarshal the response body.
				By default, Resty uses `encoding/json` package to unmarshal the response body.
				
				Since v2.8.0

			(*Client) SetLogger(l Logger) *Client
				SetLogger method sets given writer for logging Resty request and response details.
				
				Compliant to interface `resty.Logger`.

			(*Client) SetOutputDirectory(dirPath string) *Client
				SetOutputDirectory method sets output directory for saving HTTP response into file.
				If the output directory not exists then resty creates one. This setting is optional one,
				if you're planning using absolute path in `Request.SetOutput` and can used together.
				
					client.SetOutputDirectory("/save/http/response/here")

			(*Client) SetPathParam(param, value string) *Client
				SetPathParam method sets single URL path key-value pair in the
				Resty client instance.
				
					client.SetPathParam("userId", "sample@sample.com")
				
					Result:
					   URL - /v1/users/{userId}/details
					   Composed URL - /v1/users/sample@sample.com/details
				
				It replaces the value of the key while composing the request URL.
				The value will be escaped using `url.PathEscape` function.
				
				Also it can be overridden at request level Path Params options,
				see `Request.SetPathParam` or `Request.SetPathParams`.

			(*Client) SetPathParams(params map[string]string) *Client
				SetPathParams method sets multiple URL path key-value pairs at one go in the
				Resty client instance.
				
					client.SetPathParams(map[string]string{
						"userId":       "sample@sample.com",
						"subAccountId": "100002",
						"path":         "groups/developers",
					})
				
					Result:
					   URL - /v1/users/{userId}/{subAccountId}/{path}/details
					   Composed URL - /v1/users/sample@sample.com/100002/groups%2Fdevelopers/details
				
				It replaces the value of the key while composing the request URL.
				The values will be escaped using `url.PathEscape` function.
				
				Also it can be overridden at request level Path Params options,
				see `Request.SetPathParam` or `Request.SetPathParams`.

			(*Client) SetPreRequestHook(h PreRequestHook) *Client
				SetPreRequestHook method sets the given pre-request function into resty client.
				It is called right before the request is fired.
				
				Note: Only one pre-request hook can be registered. Use `client.OnBeforeRequest` for multiple.

			(*Client) SetProxy(proxyURL string) *Client
				SetProxy method sets the Proxy URL and Port for Resty client.
				
					client.SetProxy("http://proxyserver:8888")
				
				OR Without this `SetProxy` method, you could also set Proxy via environment variable.
				
				Refer to godoc `http.ProxyFromEnvironment`.

			(*Client) SetQueryParam(param, value string) *Client
				SetQueryParam method sets single parameter and its value in the client instance.
				It will be formed as query string for the request.
				
				For Example: `search=kitchen%20papers&size=large`
				in the URL after `?` mark. These query params will be added to all the request raised from
				this client instance. Also it can be overridden at request level Query Param options.
				
				See `Request.SetQueryParam` or `Request.SetQueryParams`.
				
					client.
						SetQueryParam("search", "kitchen papers").
						SetQueryParam("size", "large")

			(*Client) SetQueryParams(params map[string]string) *Client
				SetQueryParams method sets multiple parameters and their values at one go in the client instance.
				It will be formed as query string for the request.
				
				For Example: `search=kitchen%20papers&size=large`
				in the URL after `?` mark. These query params will be added to all the request raised from this
				client instance. Also it can be overridden at request level Query Param options.
				
				See `Request.SetQueryParams` or `Request.SetQueryParam`.
				
					client.SetQueryParams(map[string]string{
							"search": "kitchen papers",
							"size": "large",
						})

			(*Client) SetRateLimiter(rl RateLimiter) *Client
				SetRateLimiter sets an optional `RateLimiter`. If set the rate limiter will control
				all requests made with this client.
				
				Since v2.9.0

			(*Client) SetRawPathParam(param, value string) *Client
				SetRawPathParam method sets single URL path key-value pair in the
				Resty client instance.
				
					client.SetPathParam("userId", "sample@sample.com")
				
					Result:
					   URL - /v1/users/{userId}/details
					   Composed URL - /v1/users/sample@sample.com/details
				
					client.SetPathParam("path", "groups/developers")
				
					Result:
					   URL - /v1/users/{userId}/details
					   Composed URL - /v1/users/groups%2Fdevelopers/details
				
				It replaces the value of the key while composing the request URL.
				The value will be used as it is and will not be escaped.
				
				Also it can be overridden at request level Path Params options,
				see `Request.SetPathParam` or `Request.SetPathParams`.
				
				Since v2.8.0

			(*Client) SetRawPathParams(params map[string]string) *Client
				SetRawPathParams method sets multiple URL path key-value pairs at one go in the
				Resty client instance.
				
					client.SetPathParams(map[string]string{
						"userId":       "sample@sample.com",
						"subAccountId": "100002",
						"path":         "groups/developers",
					})
				
					Result:
					   URL - /v1/users/{userId}/{subAccountId}/{path}/details
					   Composed URL - /v1/users/sample@sample.com/100002/groups/developers/details
				
				It replaces the value of the key while composing the request URL.
				The values will be used as they are and will not be escaped.
				
				Also it can be overridden at request level Path Params options,
				see `Request.SetPathParam` or `Request.SetPathParams`.
				
				Since v2.8.0

			(*Client) SetRedirectPolicy(policies ...interface{}) *Client
				SetRedirectPolicy method sets the client redirect policy. Resty provides ready to use
				redirect policies. Wanna create one for yourself refer to `redirect.go`.
				
					client.SetRedirectPolicy(FlexibleRedirectPolicy(20))
				
					// Need multiple redirect policies together
					client.SetRedirectPolicy(FlexibleRedirectPolicy(20), DomainCheckRedirectPolicy("host1.com", "host2.net"))

			(*Client) SetRetryAfter(callback RetryAfterFunc) *Client
				SetRetryAfter sets callback to calculate wait time between retries.
				Default (nil) implies exponential backoff with jitter

			(*Client) SetRetryCount(count int) *Client
				SetRetryCount method enables retry on Resty client and allows you
				to set no. of retry count. Resty uses a Backoff mechanism.

			(*Client) SetRetryMaxWaitTime(maxWaitTime time.Duration) *Client
				SetRetryMaxWaitTime method sets max wait time to sleep before retrying
				request.
				
				Default is 2 seconds.

			(*Client) SetRetryResetReaders(b bool) *Client
				SetRetryResetReaders method enables the Resty client to seek the start of all
				file readers given as multipart files, if the given object implements `io.ReadSeeker`.
				
				Since ...

			(*Client) SetRetryWaitTime(waitTime time.Duration) *Client
				SetRetryWaitTime method sets default wait time to sleep before retrying
				request.
				
				Default is 100 milliseconds.

			(*Client) SetRootCertificate(pemFilePath string) *Client
				SetRootCertificate method helps to add one or more root certificates into Resty client
				
					client.SetRootCertificate("/path/to/root/pemFile.pem")

			(*Client) SetRootCertificateFromString(pemContent string) *Client
				SetRootCertificateFromString method helps to add one or more root certificates into Resty client
				
					client.SetRootCertificateFromString("pem file content")

			(*Client) SetScheme(scheme string) *Client
				SetScheme method sets custom scheme in the Resty client. It's way to override default.
				
					client.SetScheme("http")

			(*Client) SetTLSClientConfig(config *tls.Config) *Client
				SetTLSClientConfig method sets TLSClientConfig for underling client Transport.
				
				For Example:
				
					// One can set custom root-certificate. Refer: http://golang.org/pkg/crypto/tls/#example_Dial
					client.SetTLSClientConfig(&tls.Config{ RootCAs: roots })
				
					// or One can disable security check (https)
					client.SetTLSClientConfig(&tls.Config{ InsecureSkipVerify: true })
				
				Note: This method overwrites existing `TLSClientConfig`.

			(*Client) SetTimeout(timeout time.Duration) *Client
				SetTimeout method sets timeout for request raised from client.
				
					client.SetTimeout(time.Duration(1 * time.Minute))

			(*Client) SetTransport(transport http.RoundTripper) *Client
				SetTransport method sets custom `*http.Transport` or any `http.RoundTripper`
				compatible interface implementation in the resty client.
				
				Note:
				
				- If transport is not type of `*http.Transport` then you may not be able to
				take advantage of some of the Resty client settings.
				
				- It overwrites the Resty client transport instance and it's configurations.
				
					transport := &http.Transport{
						// something like Proxying to httptest.Server, etc...
						Proxy: func(req *http.Request) (*url.URL, error) {
							return url.Parse(server.URL)
						},
					}
				
					client.SetTransport(transport)

			(*Client) SetXMLMarshaler(marshaler func(v interface{}) ([]byte, error)) *Client
				SetXMLMarshaler method sets the XML marshaler function to marshal the request body.
				By default, Resty uses `encoding/xml` package to marshal the request body.
				
				Since v2.8.0

			(*Client) SetXMLUnmarshaler(unmarshaler func(data []byte, v interface{}) error) *Client
				SetXMLUnmarshaler method sets the XML unmarshaler function to unmarshal the response body.
				By default, Resty uses `encoding/xml` package to unmarshal the response body.
				
				Since v2.8.0

			(*Client) Transport() (*http.Transport, error)
				Transport method returns `*http.Transport` currently in use or error
				in case currently used `transport` is not a `*http.Transport`.
				
				Since v2.8.0 become exported method.

		As Outputs Of (at least 68)
			func New() *Client
			func NewWithClient(hc *http.Client) *Client
			func NewWithLocalAddr(localAddr net.Addr) *Client
			func (*Client).AddRetryAfterErrorCondition() *Client
			func (*Client).AddRetryCondition(condition RetryConditionFunc) *Client
			func (*Client).AddRetryHook(hook OnRetryFunc) *Client
			func (*Client).DisableTrace() *Client
			func (*Client).EnableTrace() *Client
			func (*Client).OnAfterResponse(m ResponseMiddleware) *Client
			func (*Client).OnBeforeRequest(m RequestMiddleware) *Client
			func (*Client).OnError(h ErrorHook) *Client
			func (*Client).OnInvalid(h ErrorHook) *Client
			func (*Client).OnPanic(h ErrorHook) *Client
			func (*Client).OnRequestLog(rl RequestLogCallback) *Client
			func (*Client).OnResponseLog(rl ResponseLogCallback) *Client
			func (*Client).OnSuccess(h SuccessHook) *Client
			func (*Client).RemoveProxy() *Client
			func (*Client).SetAllowGetMethodPayload(a bool) *Client
			func (*Client).SetAuthScheme(scheme string) *Client
			func (*Client).SetAuthToken(token string) *Client
			func (*Client).SetBaseURL(url string) *Client
			func (*Client).SetBasicAuth(username, password string) *Client
			func (*Client).SetCertificates(certs ...tls.Certificate) *Client
			func (*Client).SetCloseConnection(close bool) *Client
			func (*Client).SetContentLength(l bool) *Client
			func (*Client).SetCookie(hc *http.Cookie) *Client
			func (*Client).SetCookieJar(jar http.CookieJar) *Client
			func (*Client).SetCookies(cs []*http.Cookie) *Client
			func (*Client).SetDebug(d bool) *Client
			func (*Client).SetDebugBodyLimit(sl int64) *Client
			func (*Client).SetDigestAuth(username, password string) *Client
			func (*Client).SetDisableWarn(d bool) *Client
			func (*Client).SetDoNotParseResponse(parse bool) *Client
			func (*Client).SetError(err interface{}) *Client
			func (*Client).SetFormData(data map[string]string) *Client
			func (*Client).SetHeader(header, value string) *Client
			func (*Client).SetHeaders(headers map[string]string) *Client
			func (*Client).SetHeaderVerbatim(header, value string) *Client
			func (*Client).SetHostURL(url string) *Client
			func (*Client).SetJSONEscapeHTML(b bool) *Client
			func (*Client).SetJSONMarshaler(marshaler func(v interface{}) ([]byte, error)) *Client
			func (*Client).SetJSONUnmarshaler(unmarshaler func(data []byte, v interface{}) error) *Client
			func (*Client).SetLogger(l Logger) *Client
			func (*Client).SetOutputDirectory(dirPath string) *Client
			func (*Client).SetPathParam(param, value string) *Client
			func (*Client).SetPathParams(params map[string]string) *Client
			func (*Client).SetPreRequestHook(h PreRequestHook) *Client
			func (*Client).SetProxy(proxyURL string) *Client
			func (*Client).SetQueryParam(param, value string) *Client
			func (*Client).SetQueryParams(params map[string]string) *Client
			func (*Client).SetRateLimiter(rl RateLimiter) *Client
			func (*Client).SetRawPathParam(param, value string) *Client
			func (*Client).SetRawPathParams(params map[string]string) *Client
			func (*Client).SetRedirectPolicy(policies ...interface{}) *Client
			func (*Client).SetRetryAfter(callback RetryAfterFunc) *Client
			func (*Client).SetRetryCount(count int) *Client
			func (*Client).SetRetryMaxWaitTime(maxWaitTime time.Duration) *Client
			func (*Client).SetRetryResetReaders(b bool) *Client
			func (*Client).SetRetryWaitTime(waitTime time.Duration) *Client
			func (*Client).SetRootCertificate(pemFilePath string) *Client
			func (*Client).SetRootCertificateFromString(pemContent string) *Client
			func (*Client).SetScheme(scheme string) *Client
			func (*Client).SetTimeout(timeout time.Duration) *Client
			func (*Client).SetTLSClientConfig(config *tls.Config) *Client
			func (*Client).SetTransport(transport http.RoundTripper) *Client
			func (*Client).SetXMLMarshaler(marshaler func(v interface{}) ([]byte, error)) *Client
			func (*Client).SetXMLUnmarshaler(unmarshaler func(data []byte, v interface{}) error) *Client
			func github.com/Nerzal/gocloak/v13.(*GoCloak).RestyClient() *Client
		As Inputs Of (at least 2)
			func Unmarshalc(c *Client, ct string, b []byte, d interface{}) (err error)
			func github.com/Nerzal/gocloak/v13.(*GoCloak).SetRestyClient(restyClient *Client)

	 type ErrorHook (func)
		ErrorHook type is for reacting to request errors, called after all retries were attempted

		As Inputs Of (at least 3)
			func (*Client).OnError(h ErrorHook) *Client
			func (*Client).OnInvalid(h ErrorHook) *Client
			func (*Client).OnPanic(h ErrorHook) *Client

	 type File (struct)
		File struct represent file information for multipart request

		Fields (total 3)
			Name string
			ParamName string
			Reader io.Reader
		Methods (total 2)
			( File) Read(p []byte) (n int, err error)
			(*File) String() string
				String returns string value of current file details

		Implements (at least 3)
			*File : github.com/ChrisTrenkamp/goxpath/tree.Result
			*File : fmt.Stringer
			 File : io.Reader

	 type Logger (interface)
		Logger interface is to abstract the logging from Resty. Gives control to
		the Resty users, choice of the logger.

		Methods (total 3)
			( Logger) Debugf(format string, v ...interface{})
			( Logger) Errorf(format string, v ...interface{})
			( Logger) Warnf(format string, v ...interface{})
		Implemented By (at least 4)
			 github.com/gofiber/fiber/v2/log.AllLogger (interface)
			 github.com/gofiber/fiber/v2/log.CommonLogger (interface)
			 github.com/gofiber/fiber/v2/log.FormatLogger (interface)
			*go.uber.org/zap.SugaredLogger
		As Inputs Of (at least 2)
			func (*Client).SetLogger(l Logger) *Client
			func (*Request).SetLogger(l Logger) *Request

	 type MultipartField (struct)
		MultipartField struct represent custom data part for multipart request

		Fields (total 4)
			ContentType string
			FileName string
			Param string
			Reader io.Reader
		Methods (only one)
			( MultipartField) Read(p []byte) (n int, err error)
		Implements (at least one exported)
			 MultipartField : io.Reader
		As Inputs Of (at least one exported)
			func (*Request).SetMultipartFields(fields ...*MultipartField) *Request

	 type OnRetryFunc (func)
		OnRetryFunc is for side-effecting functions triggered on retry

		As Inputs Of (at least 2)
			func RetryHooks(hooks []OnRetryFunc) Option
			func (*Client).AddRetryHook(hook OnRetryFunc) *Client

	 type Option (func)
		Option is to create convenient retry options like wait time, max retries, etc.

		As Outputs Of (at least 6)
			func MaxWaitTime(value time.Duration) Option
			func ResetMultipartReaders(value bool) Option
			func Retries(value int) Option
			func RetryConditions(conditions []RetryConditionFunc) Option
			func RetryHooks(hooks []OnRetryFunc) Option
			func WaitTime(value time.Duration) Option
		As Inputs Of (at least one exported)
			func Backoff(operation func() (*Response, error), options ...Option) error

	 type Options (struct)
		Options struct is used to hold retry settings.

	 type PreRequestHook (func)
		PreRequestHook type is for the request hook, called right before the request is sent

		As Inputs Of (at least one exported)
			func (*Client).SetPreRequestHook(h PreRequestHook) *Client

	 type RateLimiter (interface)

		Methods (only one)
			( RateLimiter) Allow() bool
		As Inputs Of (at least one exported)
			func (*Client).SetRateLimiter(rl RateLimiter) *Client

	 type RedirectPolicy (interface)
		RedirectPolicy to regulate the redirects in the resty client.
		Objects implementing the RedirectPolicy interface can be registered as
		
		Apply function should return nil to continue the redirect journey, otherwise
		return error to stop the redirect.

		Methods (only one)
			( RedirectPolicy) Apply(req *http.Request, via []*http.Request) error
		Implemented By (at least one exported)
			 RedirectPolicyFunc
		As Outputs Of (at least 3)
			func DomainCheckRedirectPolicy(hostnames ...string) RedirectPolicy
			func FlexibleRedirectPolicy(noOfRedirect int) RedirectPolicy
			func NoRedirectPolicy() RedirectPolicy

	 type RedirectPolicyFunc (func)
		The RedirectPolicyFunc type is an adapter to allow the use of ordinary functions as RedirectPolicy.
		If f is a function with the appropriate signature, RedirectPolicyFunc(f) is a RedirectPolicy object that calls f.

		Methods (only one)
			( RedirectPolicyFunc) Apply(req *http.Request, via []*http.Request) error
				Apply calls f(req, via).

		Implements (at least one exported)
			 RedirectPolicyFunc : RedirectPolicy

	 type Request (struct)
		Request struct is used to compose and fire individual request from
		resty client. Request provides an options to override client level
		settings and also an options for the request composition.

		Fields (total 19)
			Attempt int
				Attempt is to represent the request attempt made during a Resty
				request execution flow, including retry count.
				
				Since v2.4.0

			AuthScheme string
			Body interface{}
			Cookies []*http.Cookie
			Debug bool
			Error interface{}
			FormData url.Values
			Header http.Header
			Method string
			PathParams map[string]string
			QueryParam url.Values
			RawPathParams map[string]string
			RawRequest *http.Request
			Result interface{}
			SRV *SRVRecord
			Time time.Time
			Token string
			URL string
			UserInfo *User
		Methods (total 52)
			(*Request) AddRetryCondition(condition RetryConditionFunc) *Request
				AddRetryCondition method adds a retry condition function to the request's
				array of functions that are checked to determine if the request is retried.
				The request will retry if any of the functions return true and error is nil.
				
				Note: These retry conditions are checked before all retry conditions of the client.
				
				Since v2.7.0

			(*Request) Context() context.Context
				Context method returns the Context if its already set in request
				otherwise it creates new one using `context.Background()`.

			(*Request) Delete(url string) (*Response, error)
				Delete method does DELETE HTTP request. It's defined in section 4.3.5 of RFC7231.

			(*Request) EnableTrace() *Request
				EnableTrace method enables trace for the current request
				using `httptrace.ClientTrace` and provides insights.
				
					client := resty.New()
				
					resp, err := client.R().EnableTrace().Get("https://httpbin.org/get")
					fmt.Println("Error:", err)
					fmt.Println("Trace Info:", resp.Request.TraceInfo())
				
				See `Client.EnableTrace` available too to get trace info for all requests.
				
				Since v2.0.0

			(*Request) Execute(method, url string) (*Response, error)
				Execute method performs the HTTP request with given HTTP method and URL
				for current `Request`.
				
					resp, err := client.R().Execute(resty.GET, "http://httpbin.org/get")

			(*Request) ExpectContentType(contentType string) *Request
				ExpectContentType method allows to provide fallback `Content-Type` for automatic unmarshalling
				when `Content-Type` response header is unavailable.

			(*Request) ForceContentType(contentType string) *Request
				ForceContentType method provides a strong sense of response `Content-Type` for automatic unmarshalling.
				Resty gives this a higher priority than the `Content-Type` response header.  This means that if both
				`Request.ForceContentType` is set and the response `Content-Type` is available, `ForceContentType` will win.

			(*Request) Get(url string) (*Response, error)
				Get method does GET HTTP request. It's defined in section 4.3.1 of RFC7231.

			(*Request) Head(url string) (*Response, error)
				Head method does HEAD HTTP request. It's defined in section 4.3.2 of RFC7231.

			(*Request) Options(url string) (*Response, error)
				Options method does OPTIONS HTTP request. It's defined in section 4.3.7 of RFC7231.

			(*Request) Patch(url string) (*Response, error)
				Patch method does PATCH HTTP request. It's defined in section 2 of RFC5789.

			(*Request) Post(url string) (*Response, error)
				Post method does POST HTTP request. It's defined in section 4.3.3 of RFC7231.

			(*Request) Put(url string) (*Response, error)
				Put method does PUT HTTP request. It's defined in section 4.3.4 of RFC7231.

			(*Request) Send() (*Response, error)
				Send method performs the HTTP request using the method and URL already defined
				for current `Request`.
				
					req := client.R()
					req.Method = resty.GET
					req.URL = "http://httpbin.org/get"
					resp, err := req.Send()

			(*Request) SetAuthScheme(scheme string) *Request
				SetAuthScheme method sets the auth token scheme type in the HTTP request. For Example:
				
					Authorization: <auth-scheme-value-set-here> <auth-token-value>
				
				For Example: To set the scheme to use OAuth
				
					client.R().SetAuthScheme("OAuth")
				
				This auth header scheme gets added to all the request raised from this client instance.
				Also it can be overridden or set one at the request level is supported.
				
				Information about Auth schemes can be found in RFC7235 which is linked to below along with the page containing
				the currently defined official authentication schemes:
				
					https://tools.ietf.org/html/rfc7235
					https://www.iana.org/assignments/http-authschemes/http-authschemes.xhtml#authschemes
				
				This method overrides the Authorization scheme set by method `Client.SetAuthScheme`.

			(*Request) SetAuthToken(token string) *Request
				SetAuthToken method sets the auth token header(Default Scheme: Bearer) in the current HTTP request. Header example:
				
					Authorization: Bearer <auth-token-value-comes-here>
				
				For Example: To set auth token BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F
				
					client.R().SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F")
				
				This method overrides the Auth token set by method `Client.SetAuthToken`.

			(*Request) SetBasicAuth(username, password string) *Request
				SetBasicAuth method sets the basic authentication header in the current HTTP request.
				
				For Example:
				
					Authorization: Basic <base64-encoded-value>
				
				To set the header for username "go-resty" and password "welcome"
				
					client.R().SetBasicAuth("go-resty", "welcome")
				
				This method overrides the credentials set by method `Client.SetBasicAuth`.

			(*Request) SetBody(body interface{}) *Request
				SetBody method sets the request body for the request. It supports various realtime needs as easy.
				We can say its quite handy or powerful. Supported request body data types is `string`,
				`[]byte`, `struct`, `map`, `slice` and `io.Reader`. Body value can be pointer or non-pointer.
				Automatic marshalling for JSON and XML content type, if it is `struct`, `map`, or `slice`.
				
				Note: `io.Reader` is processed as bufferless mode while sending request.
				
				For Example: Struct as a body input, based on content type, it will be marshalled.
				
					client.R().
						SetBody(User{
							Username: "jeeva@myjeeva.com",
							Password: "welcome2resty",
						})
				
				Map as a body input, based on content type, it will be marshalled.
				
					client.R().
						SetBody(map[string]interface{}{
							"username": "jeeva@myjeeva.com",
							"password": "welcome2resty",
							"address": &Address{
								Address1: "1111 This is my street",
								Address2: "Apt 201",
								City: "My City",
								State: "My State",
								ZipCode: 00000,
							},
						})
				
				String as a body input. Suitable for any need as a string input.
				
					client.R().
						SetBody(`{
							"username": "jeeva@getrightcare.com",
							"password": "admin"
						}`)
				
				[]byte as a body input. Suitable for raw request such as file upload, serialize & deserialize, etc.
				
					client.R().
						SetBody([]byte("This is my raw request, sent as-is"))

			(*Request) SetContentLength(l bool) *Request
				SetContentLength method sets the HTTP header `Content-Length` value for current request.
				By default Resty won't set `Content-Length`. Also you have an option to enable for every
				request.
				
				See `Client.SetContentLength`
				
					client.R().SetContentLength(true)

			(*Request) SetContext(ctx context.Context) *Request
				SetContext method 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.

			(*Request) SetCookie(hc *http.Cookie) *Request
				SetCookie method appends a single cookie in the current request instance.
				
					client.R().SetCookie(&http.Cookie{
								Name:"go-resty",
								Value:"This is cookie value",
							})
				
				Note: Method appends the Cookie value into existing Cookie if already existing.
				
				Since v2.1.0

			(*Request) SetCookies(rs []*http.Cookie) *Request
				SetCookies method sets an array of cookies in the current request instance.
				
					cookies := []*http.Cookie{
						&http.Cookie{
							Name:"go-resty-1",
							Value:"This is cookie 1 value",
						},
						&http.Cookie{
							Name:"go-resty-2",
							Value:"This is cookie 2 value",
						},
					}
				
					// Setting a cookies into resty's current request
					client.R().SetCookies(cookies)
				
				Note: Method appends the Cookie value into existing Cookie if already existing.
				
				Since v2.1.0

			(*Request) SetDebug(d bool) *Request
				SetDebug method enables the debug mode on current request Resty request, It logs
				the details current request and response.
				For `Request` it logs information such as HTTP verb, Relative URL path, Host, Headers, Body if it has one.
				For `Response` it logs information such as Status, Response Time, Headers, Body if it has one.
				
					client.R().SetDebug(true)

			(*Request) SetDigestAuth(username, password string) *Request
				SetDigestAuth method sets the Digest Access auth scheme for the HTTP request. If a server responds with 401 and sends
				a Digest challenge in the WWW-Authenticate Header, the request will be resent with the appropriate Authorization Header.
				
				For Example: To set the Digest scheme with username "Mufasa" and password "Circle Of Life"
				
					client.R().SetDigestAuth("Mufasa", "Circle Of Life")
				
				Information about Digest Access Authentication can be found in RFC7616:
				
					https://datatracker.ietf.org/doc/html/rfc7616
				
				This method overrides the username and password set by method `Client.SetDigestAuth`.

			(*Request) SetDoNotParseResponse(parse bool) *Request
				SetDoNotParseResponse method instructs `Resty` not to parse the response body automatically.
				Resty exposes the raw response body as `io.ReadCloser`. Also do not forget to close the body,
				otherwise you might get into connection leaks, no connection reuse.
				
				Note: Response middlewares are not applicable, if you use this option. Basically you have
				taken over the control of response parsing from `Resty`.

			(*Request) SetError(err interface{}) *Request
				SetError method is to register the request `Error` object for automatic unmarshalling for the request,
				if response status code is greater than 399 and content type either JSON or XML.
				
				Note: Error object can be pointer or non-pointer.
				
					client.R().SetError(&AuthError{})
					// OR
					client.R().SetError(AuthError{})
				
				Accessing a error value from response instance.
				
					response.Error().(*AuthError)

			(*Request) SetFile(param, filePath string) *Request
				SetFile method is to set single file field name and its path for multipart upload.
				
					client.R().
						SetFile("my_file", "/Users/jeeva/Gas Bill - Sep.pdf")

			(*Request) SetFileReader(param, fileName string, reader io.Reader) *Request
				SetFileReader method is to set single file using io.Reader for multipart upload.
				
					client.R().
						SetFileReader("profile_img", "my-profile-img.png", bytes.NewReader(profileImgBytes)).
						SetFileReader("notes", "user-notes.txt", bytes.NewReader(notesBytes))

			(*Request) SetFiles(files map[string]string) *Request
				SetFiles method is to set multiple file field name and its path for multipart upload.
				
					client.R().
						SetFiles(map[string]string{
								"my_file1": "/Users/jeeva/Gas Bill - Sep.pdf",
								"my_file2": "/Users/jeeva/Electricity Bill - Sep.pdf",
								"my_file3": "/Users/jeeva/Water Bill - Sep.pdf",
							})

			(*Request) SetFormData(data map[string]string) *Request
				SetFormData method sets Form parameters and their values in the current request.
				It's applicable only HTTP method `POST` and `PUT` and requests content type would be set as
				`application/x-www-form-urlencoded`.
				
					client.R().
						SetFormData(map[string]string{
							"access_token": "BC594900-518B-4F7E-AC75-BD37F019E08F",
							"user_id": "3455454545",
						})
				
				Also you can override form data value, which was set at client instance level.

			(*Request) SetFormDataFromValues(data url.Values) *Request
				SetFormDataFromValues method appends multiple form parameters with multi-value
				(`url.Values`) at one go in the current request.
				
					client.R().
						SetFormDataFromValues(url.Values{
							"search_criteria": []string{"book", "glass", "pencil"},
						})
				
				Also you can override form data value, which was set at client instance level.

			(*Request) SetHeader(header, value string) *Request
				SetHeader method is to set a single header field and its value in the current request.
				
				For Example: To set `Content-Type` and `Accept` as `application/json`.
				
					client.R().
						SetHeader("Content-Type", "application/json").
						SetHeader("Accept", "application/json")
				
				Also you can override header value, which was set at client instance level.

			(*Request) SetHeaderMultiValues(headers map[string][]string) *Request
				SetHeaderMultiValues sets multiple headers fields and its values is list of strings at one go in the current request.
				
				For Example: To set `Accept` as `text/html, application/xhtml+xml, application/xml;q=0.9, image/webp, */*;q=0.8`
				
					client.R().
						SetHeaderMultiValues(map[string][]string{
							"Accept": []string{"text/html", "application/xhtml+xml", "application/xml;q=0.9", "image/webp", "*/*;q=0.8"},
						})
				
				Also you can override header value, which was set at client instance level.

			(*Request) SetHeaderVerbatim(header, value string) *Request
				SetHeaderVerbatim method is to set a single header field and its value verbatim in the current request.
				
				For Example: To set `all_lowercase` and `UPPERCASE` as `available`.
				
					client.R().
						SetHeaderVerbatim("all_lowercase", "available").
						SetHeaderVerbatim("UPPERCASE", "available")
				
				Also you can override header value, which was set at client instance level.
				
				Since v2.6.0

			(*Request) SetHeaders(headers map[string]string) *Request
				SetHeaders method sets multiple headers field and its values at one go in the current request.
				
				For Example: To set `Content-Type` and `Accept` as `application/json`
				
					client.R().
						SetHeaders(map[string]string{
							"Content-Type": "application/json",
							"Accept": "application/json",
						})
				
				Also you can override header value, which was set at client instance level.

			(*Request) SetJSONEscapeHTML(b bool) *Request
				SetJSONEscapeHTML method is to enable/disable the HTML escape on JSON marshal.
				
				Note: This option only applicable to standard JSON Marshaller.

			(*Request) SetLogger(l Logger) *Request
				SetLogger method sets given writer for logging Resty request and response details.
				By default, requests and responses inherit their logger from the client.
				
				Compliant to interface `resty.Logger`.

			(*Request) SetMultipartField(param, fileName, contentType string, reader io.Reader) *Request
				SetMultipartField method is to set custom data using io.Reader for multipart upload.

			(*Request) SetMultipartFields(fields ...*MultipartField) *Request
				SetMultipartFields method is to set multiple data fields using io.Reader for multipart upload.
				
				For Example:
				
					client.R().SetMultipartFields(
						&resty.MultipartField{
							Param:       "uploadManifest1",
							FileName:    "upload-file-1.json",
							ContentType: "application/json",
							Reader:      strings.NewReader(`{"input": {"name": "Uploaded document 1", "_filename" : ["file1.txt"]}}`),
						},
						&resty.MultipartField{
							Param:       "uploadManifest2",
							FileName:    "upload-file-2.json",
							ContentType: "application/json",
							Reader:      strings.NewReader(`{"input": {"name": "Uploaded document 2", "_filename" : ["file2.txt"]}}`),
						})
				
				If you have slice already, then simply call-
				
					client.R().SetMultipartFields(fields...)

			(*Request) SetMultipartFormData(data map[string]string) *Request
				SetMultipartFormData method allows simple form data to be attached to the request as `multipart:form-data`

			(*Request) SetOutput(file string) *Request
				SetOutput method sets the output file for current HTTP request. Current HTTP response will be
				saved into given file. It is similar to `curl -o` flag. Absolute path or relative path can be used.
				If is it relative path then output file goes under the output directory, as mentioned
				in the `Client.SetOutputDirectory`.
				
					client.R().
						SetOutput("/Users/jeeva/Downloads/ReplyWithHeader-v5.1-beta.zip").
						Get("http://bit.ly/1LouEKr")
				
				Note: In this scenario `Response.Body` might be nil.

			(*Request) SetPathParam(param, value string) *Request
				SetPathParam method sets single URL path key-value pair in the
				Resty current request instance.
				
					client.R().SetPathParam("userId", "sample@sample.com")
				
					Result:
					   URL - /v1/users/{userId}/details
					   Composed URL - /v1/users/sample@sample.com/details
				
					client.R().SetPathParam("path", "groups/developers")
				
					Result:
					   URL - /v1/users/{userId}/details
					   Composed URL - /v1/users/groups%2Fdevelopers/details
				
				It replaces the value of the key while composing the request URL.
				The values will be escaped using `url.PathEscape` function.
				
				Also you can override Path Params value, which was set at client instance
				level.

			(*Request) SetPathParams(params map[string]string) *Request
				SetPathParams method sets multiple URL path key-value pairs at one go in the
				Resty current request instance.
				
					client.R().SetPathParams(map[string]string{
						"userId":       "sample@sample.com",
						"subAccountId": "100002",
						"path":         "groups/developers",
					})
				
					Result:
					   URL - /v1/users/{userId}/{subAccountId}/{path}/details
					   Composed URL - /v1/users/sample@sample.com/100002/groups%2Fdevelopers/details
				
				It replaces the value of the key while composing request URL.
				The value will be used as it is and will not be escaped.
				
				Also you can override Path Params value, which was set at client instance
				level.

			(*Request) SetQueryParam(param, value string) *Request
				SetQueryParam method sets single parameter and its value in the current request.
				It will be formed as query string for the request.
				
				For Example: `search=kitchen%20papers&size=large` in the URL after `?` mark.
				
					client.R().
						SetQueryParam("search", "kitchen papers").
						SetQueryParam("size", "large")
				
				Also you can override query params value, which was set at client instance level.

			(*Request) SetQueryParams(params map[string]string) *Request
				SetQueryParams method sets multiple parameters and its values at one go in the current request.
				It will be formed as query string for the request.
				
				For Example: `search=kitchen%20papers&size=large` in the URL after `?` mark.
				
					client.R().
						SetQueryParams(map[string]string{
							"search": "kitchen papers",
							"size": "large",
						})
				
				Also you can override query params value, which was set at client instance level.

			(*Request) SetQueryParamsFromValues(params url.Values) *Request
				SetQueryParamsFromValues method appends multiple parameters with multi-value
				(`url.Values`) at one go in the current request. It will be formed as
				query string for the request.
				
				For Example: `status=pending&status=approved&status=open` in the URL after `?` mark.
				
					client.R().
						SetQueryParamsFromValues(url.Values{
							"status": []string{"pending", "approved", "open"},
						})
				
				Also you can override query params value, which was set at client instance level.

			(*Request) SetQueryString(query string) *Request
				SetQueryString method provides ability to use string as an input to set URL query string for the request.
				
				Using String as an input
				
					client.R().
						SetQueryString("productId=232&template=fresh-sample&cat=resty&source=google&kw=buy a lot more")

			(*Request) SetRawPathParam(param, value string) *Request
				SetRawPathParam method sets single URL path key-value pair in the
				Resty current request instance.
				
					client.R().SetPathParam("userId", "sample@sample.com")
				
					Result:
					   URL - /v1/users/{userId}/details
					   Composed URL - /v1/users/sample@sample.com/details
				
					client.R().SetPathParam("path", "groups/developers")
				
					Result:
					   URL - /v1/users/{userId}/details
					   Composed URL - /v1/users/groups/developers/details
				
				It replaces the value of the key while composing the request URL.
				The value will be used as it is and will not be escaped.
				
				Also you can override Path Params value, which was set at client instance
				level.
				
				Since v2.8.0

			(*Request) SetRawPathParams(params map[string]string) *Request
				SetRawPathParams method sets multiple URL path key-value pairs at one go in the
				Resty current request instance.
				
					client.R().SetPathParams(map[string]string{
						"userId": "sample@sample.com",
						"subAccountId": "100002",
						"path":         "groups/developers",
					})
				
					Result:
					   URL - /v1/users/{userId}/{subAccountId}/{path}/details
					   Composed URL - /v1/users/sample@sample.com/100002/groups/developers/details
				
				It replaces the value of the key while composing request URL.
				The values will be used as they are and will not be escaped.
				
				Also you can override Path Params value, which was set at client instance
				level.
				
				Since v2.8.0

			(*Request) SetResult(res interface{}) *Request
				SetResult method is to register the response `Result` object for automatic unmarshalling for the request,
				if response status code is between 200 and 299 and content type either JSON or XML.
				
				Note: Result object can be pointer or non-pointer.
				
					client.R().SetResult(&AuthToken{})
					// OR
					client.R().SetResult(AuthToken{})
				
				Accessing a result value from response instance.
				
					response.Result().(*AuthToken)

			(*Request) SetSRV(srv *SRVRecord) *Request
				SetSRV method sets the details to query the service SRV record and execute the
				request.
				
					client.R().
						SetSRV(SRVRecord{"web", "testservice.com"}).
						Get("/get")

			(*Request) TraceInfo() TraceInfo
				TraceInfo method returns the trace info for the request.
				If either the Client or Request EnableTrace function has not been called
				prior to the request being made, an empty TraceInfo object will be returned.
				
				Since v2.0.0

		As Outputs Of (at least 48)
			func (*Client).NewRequest() *Request
			func (*Client).R() *Request
			func (*Request).AddRetryCondition(condition RetryConditionFunc) *Request
			func (*Request).EnableTrace() *Request
			func (*Request).ExpectContentType(contentType string) *Request
			func (*Request).ForceContentType(contentType string) *Request
			func (*Request).SetAuthScheme(scheme string) *Request
			func (*Request).SetAuthToken(token string) *Request
			func (*Request).SetBasicAuth(username, password string) *Request
			func (*Request).SetBody(body interface{}) *Request
			func (*Request).SetContentLength(l bool) *Request
			func (*Request).SetContext(ctx context.Context) *Request
			func (*Request).SetCookie(hc *http.Cookie) *Request
			func (*Request).SetCookies(rs []*http.Cookie) *Request
			func (*Request).SetDebug(d bool) *Request
			func (*Request).SetDigestAuth(username, password string) *Request
			func (*Request).SetDoNotParseResponse(parse bool) *Request
			func (*Request).SetError(err interface{}) *Request
			func (*Request).SetFile(param, filePath string) *Request
			func (*Request).SetFileReader(param, fileName string, reader io.Reader) *Request
			func (*Request).SetFiles(files map[string]string) *Request
			func (*Request).SetFormData(data map[string]string) *Request
			func (*Request).SetFormDataFromValues(data url.Values) *Request
			func (*Request).SetHeader(header, value string) *Request
			func (*Request).SetHeaderMultiValues(headers map[string][]string) *Request
			func (*Request).SetHeaders(headers map[string]string) *Request
			func (*Request).SetHeaderVerbatim(header, value string) *Request
			func (*Request).SetJSONEscapeHTML(b bool) *Request
			func (*Request).SetLogger(l Logger) *Request
			func (*Request).SetMultipartField(param, fileName, contentType string, reader io.Reader) *Request
			func (*Request).SetMultipartFields(fields ...*MultipartField) *Request
			func (*Request).SetMultipartFormData(data map[string]string) *Request
			func (*Request).SetOutput(file string) *Request
			func (*Request).SetPathParam(param, value string) *Request
			func (*Request).SetPathParams(params map[string]string) *Request
			func (*Request).SetQueryParam(param, value string) *Request
			func (*Request).SetQueryParams(params map[string]string) *Request
			func (*Request).SetQueryParamsFromValues(params url.Values) *Request
			func (*Request).SetQueryString(query string) *Request
			func (*Request).SetRawPathParam(param, value string) *Request
			func (*Request).SetRawPathParams(params map[string]string) *Request
			func (*Request).SetResult(res interface{}) *Request
			func (*Request).SetSRV(srv *SRVRecord) *Request
			func github.com/Nerzal/gocloak/v13.(*GoCloak).GetRequest(ctx context.Context) *Request
			func github.com/Nerzal/gocloak/v13.(*GoCloak).GetRequestWithBasicAuth(ctx context.Context, clientID, clientSecret string) *Request
			func github.com/Nerzal/gocloak/v13.(*GoCloak).GetRequestWithBearerAuth(ctx context.Context, token string) *Request
			func github.com/Nerzal/gocloak/v13.(*GoCloak).GetRequestWithBearerAuthNoCache(ctx context.Context, token string) *Request
			func github.com/Nerzal/gocloak/v13.(*GoCloak).GetRequestWithBearerAuthXMLHeader(ctx context.Context, token string) *Request

	 type RequestLog (struct)
		RequestLog struct is used to collected information from resty request
		instance for debug logging. It sent to request log callback before resty
		actually logs the information.

		Fields (total 2)
			Body string
			Header http.Header

	 type RequestLogCallback (func)
		RequestLogCallback type is for request logs, called before the request is logged

		As Inputs Of (at least one exported)
			func (*Client).OnRequestLog(rl RequestLogCallback) *Client

	 type RequestMiddleware (func)
		RequestMiddleware type is for request middleware, called before a request is sent

		As Inputs Of (at least one exported)
			func (*Client).OnBeforeRequest(m RequestMiddleware) *Client

	 type Response (struct)
		Response struct holds response values of executed request.

		Fields (total 2)
			RawResponse *http.Response
			Request *Request
		Methods (total 16)
			(*Response) Body() []byte
				Body method returns HTTP response as []byte array for the executed request.
				
				Note: `Response.Body` might be nil, if `Request.SetOutput` is used.

			(*Response) Cookies() []*http.Cookie
				Cookies method to access all the response cookies

			(*Response) Error() interface{}
				Error method returns the error object if it has one

			(*Response) Header() http.Header
				Header method returns the response headers

			(*Response) IsError() bool
				IsError method returns true if HTTP status `code >= 400` otherwise false.

			(*Response) IsSuccess() bool
				IsSuccess method returns true if HTTP status `code >= 200 and <= 299` otherwise false.

			(*Response) Proto() string
				Proto method returns the HTTP response protocol used for the request.

			(*Response) RawBody() io.ReadCloser
				RawBody method exposes the HTTP raw response body. Use this method in-conjunction with `SetDoNotParseResponse`
				option otherwise you get an error as `read err: http: read on closed response body`.
				
				Do not forget to close the body, otherwise you might get into connection leaks, no connection reuse.
				Basically you have taken over the control of response parsing from `Resty`.

			(*Response) ReceivedAt() time.Time
				ReceivedAt method returns when response got received from server for the request.

			(*Response) Result() interface{}
				Result method returns the response value as an object if it has one

			(*Response) SetBody(b []byte) *Response
				SetBody method is to set Response body in byte slice. Typically,
				its helpful for test cases.
				
					resp.SetBody([]byte("This is test body content"))
					resp.SetBody(nil)
				
				Since v2.10.0

			(*Response) Size() int64
				Size method returns the HTTP response size in bytes. Ya, you can relay on HTTP `Content-Length` header,
				however it won't be good for chucked transfer/compressed response. Since Resty calculates response size
				at the client end. You will get actual size of the http response.

			(*Response) Status() string
				Status method returns the HTTP status string for the executed request.
				
					Example: 200 OK

			(*Response) StatusCode() int
				StatusCode method returns the HTTP status code for the executed request.
				
					Example: 200

			(*Response) String() string
				String method returns the body of the server response as String.

			(*Response) Time() time.Duration
				Time method returns the time of HTTP response time that from request we sent and received a request.
				
				See `Response.ReceivedAt` to know when client received response and see `Response.Request.Time` to know
				when client sent a request.

		Implements (at least 2)
			*Response : github.com/ChrisTrenkamp/goxpath/tree.Result
			*Response : fmt.Stringer
		As Outputs Of (at least 10)
			func (*Request).Delete(url string) (*Response, error)
			func (*Request).Execute(method, url string) (*Response, error)
			func (*Request).Get(url string) (*Response, error)
			func (*Request).Head(url string) (*Response, error)
			func (*Request).Options(url string) (*Response, error)
			func (*Request).Patch(url string) (*Response, error)
			func (*Request).Post(url string) (*Response, error)
			func (*Request).Put(url string) (*Response, error)
			func (*Request).Send() (*Response, error)
			func (*Response).SetBody(b []byte) *Response

	 type ResponseError (struct)
		ResponseError is a wrapper for including the server response with an error.
		Neither the err nor the response should be nil.

		Fields (total 2)
			Err error
			Response *Response
		Methods (total 2)
			(*ResponseError) Error() string
			(*ResponseError) Unwrap() error
		Implements (at least one exported)
			*ResponseError : error

	 type ResponseLog (struct)
		ResponseLog struct is used to collected information from resty response
		instance for debug logging. It sent to response log callback before resty
		actually logs the information.

		Fields (total 2)
			Body string
			Header http.Header

	 type ResponseLogCallback (func)
		ResponseLogCallback type is for response logs, called before the response is logged

		As Inputs Of (at least one exported)
			func (*Client).OnResponseLog(rl ResponseLogCallback) *Client

	 type ResponseMiddleware (func)
		ResponseMiddleware type is for response middleware, called after a response has been received

		As Inputs Of (at least one exported)
			func (*Client).OnAfterResponse(m ResponseMiddleware) *Client

	 type RetryAfterFunc (func)
		RetryAfterFunc returns time to wait before retry
		For example, it can parse HTTP Retry-After header
		https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
		Non-nil error is returned if it is found that request is not retryable
		(0, nil) is a special result means 'use default algorithm'

		As Inputs Of (at least one exported)
			func (*Client).SetRetryAfter(callback RetryAfterFunc) *Client

	 type RetryConditionFunc (func)
		RetryConditionFunc type is for retry condition function
		input: non-nil Response OR request execution error

		As Inputs Of (at least 3)
			func RetryConditions(conditions []RetryConditionFunc) Option
			func (*Client).AddRetryCondition(condition RetryConditionFunc) *Client
			func (*Request).AddRetryCondition(condition RetryConditionFunc) *Request

	 type SRVRecord (struct)
		SRVRecord struct holds the data to query the SRV record for the
		following service.

		Fields (total 2)
			Domain string
			Service string
		As Inputs Of (at least one exported)
			func (*Request).SetSRV(srv *SRVRecord) *Request

	 type SuccessHook (func)
		SuccessHook type is for reacting to request success

		As Inputs Of (at least one exported)
			func (*Client).OnSuccess(h SuccessHook) *Client

	 type TraceInfo (struct)
		TraceInfo struct is used provide request trace info such as DNS lookup
		duration, Connection obtain duration, Server processing duration, etc.
		
		Since v2.0.0

		Fields (total 12)
			ConnIdleTime time.Duration
				ConnIdleTime is a duration how long the connection was previously
				idle, if IsConnWasIdle is true.

			ConnTime time.Duration
				ConnTime is a duration that took to obtain a successful connection.

			DNSLookup time.Duration
				DNSLookup is a duration that transport took to perform
				DNS lookup.

			IsConnReused bool
				IsConnReused is whether this connection has been previously
				used for another HTTP request.

			IsConnWasIdle bool
				IsConnWasIdle is whether this connection was obtained from an
				idle pool.

			RemoteAddr net.Addr
				RemoteAddr returns the remote network address.

			RequestAttempt int
				RequestAttempt is to represent the request attempt made during a Resty
				request execution flow, including retry count.

			ResponseTime time.Duration
				ResponseTime is a duration since first response byte from server to
				request completion.

			ServerTime time.Duration
				ServerTime is a duration that server took to respond first byte.

			TCPConnTime time.Duration
				TCPConnTime is a duration that took to obtain the TCP connection.

			TLSHandshake time.Duration
				TLSHandshake is a duration that TLS handshake took place.

			TotalTime time.Duration
				TotalTime is a duration that total request took end-to-end.

		As Outputs Of (at least one exported)
			func (*Request).TraceInfo() TraceInfo

	 type User (struct)
		User type is to hold an username and password information

		Fields (total 2)
			Password string
			Username string


Package-Level Functions (total 18)

	 func Backoff(operation func() (*Response, error), options ...Option) error
		Backoff retries with increasing timeout duration up until X amount of retries
		(Default is 3 attempts, Override with option Retries(n))

	 func DetectContentType(body interface{}) string
		DetectContentType method is used to figure out `Request.Body` content type for request header

	 func DomainCheckRedirectPolicy(hostnames ...string) RedirectPolicy
		DomainCheckRedirectPolicy is convenient method to define domain name redirect rule in resty client.
		Redirect is allowed for only mentioned host in the policy.
		
			resty.SetRedirectPolicy(DomainCheckRedirectPolicy("host1.com", "host2.org", "host3.net"))

	 func FlexibleRedirectPolicy(noOfRedirect int) RedirectPolicy
		FlexibleRedirectPolicy is convenient method to create No of redirect policy for HTTP client.
		
			resty.SetRedirectPolicy(FlexibleRedirectPolicy(20))

	 func IsJSONType(ct string) bool
		IsJSONType method is to check JSON content type or not

	 func IsStringEmpty(str string) bool
		IsStringEmpty method tells whether given string is empty or not

	 func IsXMLType(ct string) bool
		IsXMLType method is to check XML content type or not

	 func MaxWaitTime(value time.Duration) Option
		MaxWaitTime sets the max wait time to sleep between requests

	 func New() *Client
		New method creates a new Resty client.

	 func NewWithClient(hc *http.Client) *Client
		NewWithClient method creates a new Resty client with given `http.Client`.

	 func NewWithLocalAddr(localAddr net.Addr) *Client
		NewWithLocalAddr method creates a new Resty client with given Local Address
		to dial from.

	 func NoRedirectPolicy() RedirectPolicy
		NoRedirectPolicy is used to disable redirects in the HTTP client
		
			resty.SetRedirectPolicy(NoRedirectPolicy())

	 func ResetMultipartReaders(value bool) Option
		ResetMultipartReaders sets a boolean value which will lead the start being seeked out
		on all multipart file readers, if they implement io.ReadSeeker

	 func Retries(value int) Option
		Retries sets the max number of retries

	 func RetryConditions(conditions []RetryConditionFunc) Option
		RetryConditions sets the conditions that will be checked for retry.

	 func RetryHooks(hooks []OnRetryFunc) Option
		RetryHooks sets the hooks that will be executed after each retry

	 func Unmarshalc(c *Client, ct string, b []byte, d interface{}) (err error)
		Unmarshalc content into object from JSON or XML

	 func WaitTime(value time.Duration) Option
		WaitTime sets the default wait time to sleep between requests


Package-Level Variables (total 7)

	  var ErrAutoRedirectDisabled error
		Since v2.8.0

	  var ErrDigestAlgNotSupported error
	  var ErrDigestBadChallenge error
	  var ErrDigestCharset error
	  var ErrDigestNoQop error
	  var ErrDigestQopNotSupported error
	  var ErrRateLimitExceeded error
Package-Level Constants (total 8)

	const MethodDelete = "DELETE"
		MethodDelete HTTP method

	const MethodGet = "GET"
		MethodGet HTTP method

	const MethodHead = "HEAD"
		MethodHead HTTP method

	const MethodOptions = "OPTIONS"
		MethodOptions HTTP method

	const MethodPatch = "PATCH"
		MethodPatch HTTP method

	const MethodPost = "POST"
		MethodPost HTTP method

	const MethodPut = "PUT"
		MethodPut HTTP method

	const Version = "2.10.0"
		Version # of resty

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.