Repository: line/line-bot-sdk-go
Pull request #387 (2023-11-06 06:12:44)

Add WithResult methods to take HTTP headers, if needed.

codecov-commenter: ## [Codecov](https://app.codecov.io/gh/line/line-bot-sdk-go/pull/387?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=line) Report
All modified and coverable lines are covered by tests :white_check_mark:
> Comparison is base [(`e44a70b`)](https://app.codecov.io/gh/line/line-bot-sdk-go/commit/e44a70b7bd97844db6052d831aedeea33345d25d?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=line) 55.68% compared to head [(`1537209`)](https://app.codecov.io/gh/line/line-bot-sdk-go/pull/387?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=line) 55.68%.

> :exclamation: Current head 1537209 differs from pull request most recent head ea62b2c. Consider uploading reports for the commit ea62b2c to get more accurate results

<details><summary>Additional details and impacted files</summary>


```diff
@@           Coverage Diff           @@
##           master     #387   +/-   ##
=======================================
  Coverage   55.68%   55.68%           
=======================================
  Files          86       86           
  Lines        5414     5414           
=======================================
  Hits         3015     3015           
  Misses       2179     2179           
  Partials      220      220           
```




</details>

[:umbrella: View full report in Codecov by Sentry](https://app.codecov.io/gh/line/line-bot-sdk-go/pull/387?src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=line).   
:loudspeaker: Have feedback on the report? [Share it here](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=line).


Patch:
diff --git a/generator/pom.xml b/generator/pom.xml
index dd84499..7f75091 100644
--- a/generator/pom.xml
+++ b/generator/pom.xml
@@ -146,7 +146,7 @@
     </dependencies>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <openapi-generator-version>7.0.1</openapi-generator-version>
+        <openapi-generator-version>7.1.0</openapi-generator-version>
         <maven-plugin-version>1.0.0</maven-plugin-version>
     </properties>
 </project>
diff --git a/generator/src/main/resources/line-bot-sdk-go-generator/api.pebble b/generator/src/main/resources/line-bot-sdk-go-generator/api.pebble
index 135f4e4..2511d6c 100644
--- a/generator/src/main/resources/line-bot-sdk-go-generator/api.pebble
+++ b/generator/src/main/resources/line-bot-sdk-go-generator/api.pebble
@@ -142,6 +142,44 @@ func (client *{{ classname }}) {{ op.operationId }}(
     {% endif %}
 {% endfor %}
 ) ({% if op.isResponseFile %}*http.Response{% elseif op.returnType %}*{{ op.returnType }}{% else %}struct{}{% endif %}, error) {
+    _, body, error := client.{{ op.operationId }}WithHttpInfo(
+    {% for param in op.allParams %}
+        {% if param.isBodyParam and param.isFile %}
+        {{ param.paramName }}ContentType,
+        {{ param.paramName }}Reader,
+        {% else %}
+        {{ param.paramName }},
+        {% endif %}
+    {% endfor %}
+    )
+    return body, error
+}
+
+// {{ op.operationId | capitalize }}
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+// {{ op.summary }}
+// {{ op.notes }}
+// Parameters:
+{% for param in op.allParams %}
+    {%- if param.isBodyParam and param.isFile -%}
+//        {{ param.paramName }}ContentType  {{ param.description }} content-type
+//        {{ param.paramName }}Reader       {{ param.description }} file content
+   {%- else -%}
+//        {{ param.paramName }}             {{ param.description }}
+   {%- endif %}
+{% endfor %}
+{% if op.isResponseFile %}// You must close the response body when finished with it.{% endif %}
+{% if op.externalDocs != null -%}// {{op.externalDocs.url}}{% endif %}
+func (client *{{ classname }}) {{ op.operationId }}WithHttpInfo(
+{% for param in op.allParams %}
+    {% if param.isBodyParam and param.isFile %}
+    {{ param.paramName }}ContentType string,
+    {{ param.paramName }}Reader io.Reader,
+    {% else %}
+    {{ param.paramName }} {% if not (param.isPrimitiveType or param.isEnumRef) %}*{% endif %}{{ param.dataType }},
+    {% endif %}
+{% endfor %}
+) (*http.Response, {% if op.isResponseFile %}*http.Response{% elseif op.returnType %}*{{ op.returnType }}{% else %}struct{}{% endif %}, error) {
     path := "{{ op.path }}"
     {% for pp in op.pathParams %}
     path = strings.Replace(path, "{{ "{" }}{{ pp.paramName }}{{ "}" }}", {% if pp.isInteger or pp.isLong %}strconv.FormatInt({{ pp.paramName }}, 10){% else %}{{ pp.paramName }}{% endif %}, -1)
@@ -150,19 +188,19 @@ func (client *{{ classname }}) {{ op.operationId }}(
 	log.Printf("Sending request: method={{ op.httpMethod }} path=%s bodyContentType=%s\n", path, {{ op.bodyParam.paramName }}ContentType)
 	req, err := http.NewRequest(http.Method{{ op.httpMethod }}, client.Url(path), {{ op.bodyParam.paramName }}Reader)
 	if err != nil {
-		return {{ nilval }}, err
+		return nil, {{ nilval }}, err
 	}
     req.Header.Set("Content-Type", {{ op.bodyParam.paramName }}ContentType)
     {% elseif op.bodyParam != null %}
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode({{ op.bodyParam.paramName }}); err != nil {
-		return {{ nilval }}, err
+		return nil, {{ nilval }}, err
 	}
 	log.Printf("Sending request: method={{ op.httpMethod }} path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.Method{{ op.httpMethod }}, client.Url(path), &buf)
 	if err != nil {
-		return {{ nilval }}, err
+		return nil, {{ nilval }}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 	{% elseif op.hasFormParams and op.isMultipart %}
@@ -172,7 +210,7 @@ func (client *{{ classname }}) {{ op.operationId }}(
             {% if fp.isFile %}
 	fileWriter, err := writer.CreateFormFile("{{ fp.baseName }}", {{ fp.paramName }}.Name())
 	if err != nil {
-		return {{ nilval }}, err
+		return nil, {{ nilval }}, err
 	}
 	io.Copy(fileWriter, {{ fp.paramName }})
             {% else %}
@@ -181,13 +219,13 @@ func (client *{{ classname }}) {{ op.operationId }}(
         {% endfor %}
 	err = writer.Close()
 	if err != nil {
-		return {{ nilval }}, err
+		return nil, {{ nilval }}, err
 	}
 
 	log.Printf("Sending request: method={{ op.httpMethod }} path=%s\n", path)
 	req, err := http.NewRequest(http.Method{{ op.httpMethod }}, client.Url(path), body)
 	if err != nil {
-		return {{ nilval }}, err
+		return nil, {{ nilval }}, err
 	}
 	req.Header.Set("Content-Type", writer.FormDataContentType())
 	{% elseif op.hasFormParams %}
@@ -202,14 +240,14 @@ func (client *{{ classname }}) {{ op.operationId }}(
 	log.Printf("Sending request: method={{ op.httpMethod }} path=%s body=%s\n", path, buf)
 	req, err := http.NewRequest(http.Method{{ op.httpMethod }}, client.Url(path), body)
 	if err != nil {
-		return {{ nilval }}, err
+		return nil, {{ nilval }}, err
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 	{% else %}
 	log.Printf("Sending request: method={{ op.httpMethod }} path=%s\n", path)
 	req, err := http.NewRequest(http.Method{{ op.httpMethod }}, client.Url(path), nil)
 	if err != nil {
-		return {{ nilval }}, err
+		return nil, {{ nilval }}, err
 	}
     {% endif %}
 
@@ -229,19 +267,19 @@ func (client *{{ classname }}) {{ op.operationId }}(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return {{ nilval }}, err
+		return res, {{ nilval }}, err
 	}
 
 	if res.StatusCode/100 != 2 {
         body, err := io.ReadAll(res.Body)
         if err != nil {
-            return {{ nilval }}, fmt.Errorf("failed to read response body: %w", err)
+            return res, {{ nilval }}, fmt.Errorf("failed to read response body: %w", err)
         }
-	    return {{ nilval }}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+	    return res, {{ nilval }}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
     {% if op.isResponseFile %}
-    return res, nil
+    return res, res, nil
     {% else %}
 	defer res.Body.Close()
 
@@ -249,11 +287,11 @@ func (client *{{ classname }}) {{ op.operationId }}(
 	decoder := json.NewDecoder(res.Body)
 	result := {{ op.returnType }}{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
     {% else %}
-	return struct{}{}, nil
+	return res, struct{}{}, nil
     {% endif %}
     {% endif %}
 }
diff --git a/linebot/channel_access_token/api_channel_access_token.go b/linebot/channel_access_token/api_channel_access_token.go
index edbfc12..0d64b8b 100644
--- a/linebot/channel_access_token/api_channel_access_token.go
+++ b/linebot/channel_access_token/api_channel_access_token.go
@@ -129,12 +129,37 @@ func (client *ChannelAccessTokenAPI) GetsAllValidChannelAccessTokenKeyIds(
 	clientAssertion string,
 
 ) (*ChannelAccessTokenKeyIdsResponse, error) {
+	_, body, error := client.GetsAllValidChannelAccessTokenKeyIdsWithHttpInfo(
+
+		clientAssertionType,
+
+		clientAssertion,
+	)
+	return body, error
+}
+
+// GetsAllValidChannelAccessTokenKeyIds
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Gets all valid channel access token key IDs.
+// Parameters:
+//        clientAssertionType             `urn:ietf:params:oauth:client-assertion-type:jwt-bearer`
+//        clientAssertion             A JSON Web Token (JWT) (opens new window)the client needs to create and sign with the private key.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-all-valid-channel-access-token-key-ids-v2-1
+func (client *ChannelAccessTokenAPI) GetsAllValidChannelAccessTokenKeyIdsWithHttpInfo(
+
+	clientAssertionType string,
+
+	clientAssertion string,
+
+) (*http.Response, *ChannelAccessTokenKeyIdsResponse, error) {
 	path := "/oauth2/v2.1/tokens/kid"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -147,15 +172,15 @@ func (client *ChannelAccessTokenAPI) GetsAllValidChannelAccessTokenKeyIds(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -163,9 +188,9 @@ func (client *ChannelAccessTokenAPI) GetsAllValidChannelAccessTokenKeyIds(
 	decoder := json.NewDecoder(res.Body)
 	result := ChannelAccessTokenKeyIdsResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -187,6 +212,36 @@ func (client *ChannelAccessTokenAPI) IssueChannelToken(
 	clientSecret string,
 
 ) (*IssueShortLivedChannelAccessTokenResponse, error) {
+	_, body, error := client.IssueChannelTokenWithHttpInfo(
+
+		grantType,
+
+		clientId,
+
+		clientSecret,
+	)
+	return body, error
+}
+
+// IssueChannelToken
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Issue short-lived channel access token
+// Parameters:
+//        grantType             `client_credentials`
+//        clientId             Channel ID.
+//        clientSecret             Channel secret.
+
+// https://developers.line.biz/en/reference/messaging-api/#issue-shortlived-channel-access-token
+func (client *ChannelAccessTokenAPI) IssueChannelTokenWithHttpInfo(
+
+	grantType string,
+
+	clientId string,
+
+	clientSecret string,
+
+) (*http.Response, *IssueShortLivedChannelAccessTokenResponse, error) {
 	path := "/v2/oauth/accessToken"
 
 	vs := url.Values{
@@ -200,7 +255,7 @@ func (client *ChannelAccessTokenAPI) IssueChannelToken(
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), body)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 
@@ -208,15 +263,15 @@ func (client *ChannelAccessTokenAPI) IssueChannelToken(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -224,9 +279,9 @@ func (client *ChannelAccessTokenAPI) IssueChannelToken(
 	decoder := json.NewDecoder(res.Body)
 	result := IssueShortLivedChannelAccessTokenResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -248,6 +303,36 @@ func (client *ChannelAccessTokenAPI) IssueChannelTokenByJWT(
 	clientAssertion string,
 
 ) (*IssueChannelAccessTokenResponse, error) {
+	_, body, error := client.IssueChannelTokenByJWTWithHttpInfo(
+
+		grantType,
+
+		clientAssertionType,
+
+		clientAssertion,
+	)
+	return body, error
+}
+
+// IssueChannelTokenByJWT
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Issues a channel access token that allows you to specify a desired expiration date. This method lets you use JWT assertion for authentication.
+// Parameters:
+//        grantType             client_credentials
+//        clientAssertionType             urn:ietf:params:oauth:client-assertion-type:jwt-bearer
+//        clientAssertion             A JSON Web Token the client needs to create and sign with the private key of the Assertion Signing Key.
+
+// https://developers.line.biz/en/reference/messaging-api/#issue-channel-access-token-v2-1
+func (client *ChannelAccessTokenAPI) IssueChannelTokenByJWTWithHttpInfo(
+
+	grantType string,
+
+	clientAssertionType string,
+
+	clientAssertion string,
+
+) (*http.Response, *IssueChannelAccessTokenResponse, error) {
 	path := "/oauth2/v2.1/token"
 
 	vs := url.Values{
@@ -261,7 +346,7 @@ func (client *ChannelAccessTokenAPI) IssueChannelTokenByJWT(
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), body)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 
@@ -269,15 +354,15 @@ func (client *ChannelAccessTokenAPI) IssueChannelTokenByJWT(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -285,9 +370,9 @@ func (client *ChannelAccessTokenAPI) IssueChannelTokenByJWT(
 	decoder := json.NewDecoder(res.Body)
 	result := IssueChannelAccessTokenResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -315,6 +400,46 @@ func (client *ChannelAccessTokenAPI) IssueStatelessChannelToken(
 	clientSecret string,
 
 ) (*IssueStatelessChannelAccessTokenResponse, error) {
+	_, body, error := client.IssueStatelessChannelTokenWithHttpInfo(
+
+		grantType,
+
+		clientAssertionType,
+
+		clientAssertion,
+
+		clientId,
+
+		clientSecret,
+	)
+	return body, error
+}
+
+// IssueStatelessChannelToken
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Issues a new stateless channel access token, which doesn't have max active token limit unlike the other token types. The newly issued token is only valid for 15 minutes but can not be revoked until it naturally expires.
+// Parameters:
+//        grantType             `client_credentials`
+//        clientAssertionType             URL-encoded value of `urn:ietf:params:oauth:client-assertion-type:jwt-bearer`
+//        clientAssertion             A JSON Web Token the client needs to create and sign with the private key of the Assertion Signing Key.
+//        clientId             Channel ID.
+//        clientSecret             Channel secret.
+
+// https://developers.line.biz/en/reference/messaging-api/#issue-stateless-channel-access-token
+func (client *ChannelAccessTokenAPI) IssueStatelessChannelTokenWithHttpInfo(
+
+	grantType string,
+
+	clientAssertionType string,
+
+	clientAssertion string,
+
+	clientId string,
+
+	clientSecret string,
+
+) (*http.Response, *IssueStatelessChannelAccessTokenResponse, error) {
 	path := "/oauth2/v3/token"
 
 	vs := url.Values{
@@ -330,7 +455,7 @@ func (client *ChannelAccessTokenAPI) IssueStatelessChannelToken(
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), body)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 
@@ -338,15 +463,15 @@ func (client *ChannelAccessTokenAPI) IssueStatelessChannelToken(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -354,9 +479,9 @@ func (client *ChannelAccessTokenAPI) IssueStatelessChannelToken(
 	decoder := json.NewDecoder(res.Body)
 	result := IssueStatelessChannelAccessTokenResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -372,6 +497,26 @@ func (client *ChannelAccessTokenAPI) RevokeChannelToken(
 	accessToken string,
 
 ) (struct{}, error) {
+	_, body, error := client.RevokeChannelTokenWithHttpInfo(
+
+		accessToken,
+	)
+	return body, error
+}
+
+// RevokeChannelToken
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Revoke short-lived or long-lived channel access token
+// Parameters:
+//        accessToken             Channel access token
+
+// https://developers.line.biz/en/reference/messaging-api/#revoke-longlived-or-shortlived-channel-access-token
+func (client *ChannelAccessTokenAPI) RevokeChannelTokenWithHttpInfo(
+
+	accessToken string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/oauth/revoke"
 
 	vs := url.Values{
@@ -383,7 +528,7 @@ func (client *ChannelAccessTokenAPI) RevokeChannelToken(
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), body)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 
@@ -391,20 +536,20 @@ func (client *ChannelAccessTokenAPI) RevokeChannelToken(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -426,6 +571,36 @@ func (client *ChannelAccessTokenAPI) RevokeChannelTokenByJWT(
 	accessToken string,
 
 ) (struct{}, error) {
+	_, body, error := client.RevokeChannelTokenByJWTWithHttpInfo(
+
+		clientId,
+
+		clientSecret,
+
+		accessToken,
+	)
+	return body, error
+}
+
+// RevokeChannelTokenByJWT
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Revoke channel access token v2.1
+// Parameters:
+//        clientId             Channel ID
+//        clientSecret             Channel Secret
+//        accessToken             Channel access token
+
+// https://developers.line.biz/en/reference/messaging-api/#revoke-channel-access-token-v2-1
+func (client *ChannelAccessTokenAPI) RevokeChannelTokenByJWTWithHttpInfo(
+
+	clientId string,
+
+	clientSecret string,
+
+	accessToken string,
+
+) (*http.Response, struct{}, error) {
 	path := "/oauth2/v2.1/revoke"
 
 	vs := url.Values{
@@ -439,7 +614,7 @@ func (client *ChannelAccessTokenAPI) RevokeChannelTokenByJWT(
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), body)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 
@@ -447,20 +622,20 @@ func (client *ChannelAccessTokenAPI) RevokeChannelTokenByJWT(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -476,6 +651,26 @@ func (client *ChannelAccessTokenAPI) VerifyChannelToken(
 	accessToken string,
 
 ) (*VerifyChannelAccessTokenResponse, error) {
+	_, body, error := client.VerifyChannelTokenWithHttpInfo(
+
+		accessToken,
+	)
+	return body, error
+}
+
+// VerifyChannelToken
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Verify the validity of short-lived and long-lived channel access tokens
+// Parameters:
+//        accessToken             A short-lived or long-lived channel access token.
+
+// https://developers.line.biz/en/reference/messaging-api/#verfiy-channel-access-token
+func (client *ChannelAccessTokenAPI) VerifyChannelTokenWithHttpInfo(
+
+	accessToken string,
+
+) (*http.Response, *VerifyChannelAccessTokenResponse, error) {
 	path := "/v2/oauth/verify"
 
 	vs := url.Values{
@@ -487,7 +682,7 @@ func (client *ChannelAccessTokenAPI) VerifyChannelToken(
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), body)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 
@@ -495,15 +690,15 @@ func (client *ChannelAccessTokenAPI) VerifyChannelToken(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -511,9 +706,9 @@ func (client *ChannelAccessTokenAPI) VerifyChannelToken(
 	decoder := json.NewDecoder(res.Body)
 	result := VerifyChannelAccessTokenResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -529,12 +724,32 @@ func (client *ChannelAccessTokenAPI) VerifyChannelTokenByJWT(
 	accessToken string,
 
 ) (*VerifyChannelAccessTokenResponse, error) {
+	_, body, error := client.VerifyChannelTokenByJWTWithHttpInfo(
+
+		accessToken,
+	)
+	return body, error
+}
+
+// VerifyChannelTokenByJWT
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// You can verify whether a Channel access token with a user-specified expiration (Channel Access Token v2.1) is valid.
+// Parameters:
+//        accessToken             Channel access token with a user-specified expiration (Channel Access Token v2.1).
+
+// https://developers.line.biz/en/reference/messaging-api/#verfiy-channel-access-token-v2-1
+func (client *ChannelAccessTokenAPI) VerifyChannelTokenByJWTWithHttpInfo(
+
+	accessToken string,
+
+) (*http.Response, *VerifyChannelAccessTokenResponse, error) {
 	path := "/oauth2/v2.1/verify"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -546,15 +761,15 @@ func (client *ChannelAccessTokenAPI) VerifyChannelTokenByJWT(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -562,8 +777,8 @@ func (client *ChannelAccessTokenAPI) VerifyChannelTokenByJWT(
 	decoder := json.NewDecoder(res.Body)
 	result := VerifyChannelAccessTokenResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
diff --git a/linebot/insight/api_insight.go b/linebot/insight/api_insight.go
index 00ad3c5..d7cc7e2 100644
--- a/linebot/insight/api_insight.go
+++ b/linebot/insight/api_insight.go
@@ -120,27 +120,39 @@ func WithEndpoint(endpoint string) InsightAPIOption {
 
 // https://developers.line.biz/en/reference/messaging-api/#get-demographic
 func (client *InsightAPI) GetFriendsDemographics() (*GetFriendsDemographicsResponse, error) {
+	_, body, error := client.GetFriendsDemographicsWithHttpInfo()
+	return body, error
+}
+
+// GetFriendsDemographics
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Retrieves the demographic attributes for a LINE Official Account's friends.You can only retrieve information about friends for LINE Official Accounts created by users in Japan (JP), Thailand (TH), Taiwan (TW) and Indonesia (ID).
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-demographic
+func (client *InsightAPI) GetFriendsDemographicsWithHttpInfo() (*http.Response, *GetFriendsDemographicsResponse, error) {
 	path := "/v2/bot/insight/demographic"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -148,9 +160,9 @@ func (client *InsightAPI) GetFriendsDemographics() (*GetFriendsDemographicsRespo
 	decoder := json.NewDecoder(res.Body)
 	result := GetFriendsDemographicsResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -166,12 +178,32 @@ func (client *InsightAPI) GetMessageEvent(
 	requestId string,
 
 ) (*GetMessageEventResponse, error) {
+	_, body, error := client.GetMessageEventWithHttpInfo(
+
+		requestId,
+	)
+	return body, error
+}
+
+// GetMessageEvent
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+// Get user interaction statistics
+// Returns statistics about how users interact with narrowcast messages or broadcast messages sent from your LINE Official Account.
+// Parameters:
+//        requestId             Request ID of a narrowcast message or broadcast message. Each Messaging API request has a request ID.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-message-event
+func (client *InsightAPI) GetMessageEventWithHttpInfo(
+
+	requestId string,
+
+) (*http.Response, *GetMessageEventResponse, error) {
 	path := "/v2/bot/insight/message/event"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -183,15 +215,15 @@ func (client *InsightAPI) GetMessageEvent(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -199,9 +231,9 @@ func (client *InsightAPI) GetMessageEvent(
 	decoder := json.NewDecoder(res.Body)
 	result := GetMessageEventResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -217,12 +249,32 @@ func (client *InsightAPI) GetNumberOfFollowers(
 	date string,
 
 ) (*GetNumberOfFollowersResponse, error) {
+	_, body, error := client.GetNumberOfFollowersWithHttpInfo(
+
+		date,
+	)
+	return body, error
+}
+
+// GetNumberOfFollowers
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+// Get number of followers
+// Returns the number of users who have added the LINE Official Account on or before a specified date.
+// Parameters:
+//        date             Date for which to retrieve the number of followers.  Format: yyyyMMdd (e.g. 20191231) Timezone: UTC+9
+
+// https://developers.line.biz/en/reference/messaging-api/#get-number-of-followers
+func (client *InsightAPI) GetNumberOfFollowersWithHttpInfo(
+
+	date string,
+
+) (*http.Response, *GetNumberOfFollowersResponse, error) {
 	path := "/v2/bot/insight/followers"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -234,15 +286,15 @@ func (client *InsightAPI) GetNumberOfFollowers(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -250,9 +302,9 @@ func (client *InsightAPI) GetNumberOfFollowers(
 	decoder := json.NewDecoder(res.Body)
 	result := GetNumberOfFollowersResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -268,12 +320,32 @@ func (client *InsightAPI) GetNumberOfMessageDeliveries(
 	date string,
 
 ) (*GetNumberOfMessageDeliveriesResponse, error) {
+	_, body, error := client.GetNumberOfMessageDeliveriesWithHttpInfo(
+
+		date,
+	)
+	return body, error
+}
+
+// GetNumberOfMessageDeliveries
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+// Get number of message deliveries
+// Returns the number of messages sent from LINE Official Account on a specified day.
+// Parameters:
+//        date             Date for which to retrieve number of sent messages. - Format: yyyyMMdd (e.g. 20191231) - Timezone: UTC+9
+
+// https://developers.line.biz/en/reference/messaging-api/#get-number-of-delivery-messages
+func (client *InsightAPI) GetNumberOfMessageDeliveriesWithHttpInfo(
+
+	date string,
+
+) (*http.Response, *GetNumberOfMessageDeliveriesResponse, error) {
 	path := "/v2/bot/insight/message/delivery"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -285,15 +357,15 @@ func (client *InsightAPI) GetNumberOfMessageDeliveries(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -301,9 +373,9 @@ func (client *InsightAPI) GetNumberOfMessageDeliveries(
 	decoder := json.NewDecoder(res.Body)
 	result := GetNumberOfMessageDeliveriesResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -325,12 +397,42 @@ func (client *InsightAPI) GetStatisticsPerUnit(
 	to string,
 
 ) (*GetStatisticsPerUnitResponse, error) {
+	_, body, error := client.GetStatisticsPerUnitWithHttpInfo(
+
+		customAggregationUnit,
+
+		from,
+
+		to,
+	)
+	return body, error
+}
+
+// GetStatisticsPerUnit
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// You can check the per-unit statistics of how users interact with push messages and multicast messages sent from your LINE Official Account.
+// Parameters:
+//        customAggregationUnit             Name of aggregation unit specified when sending the message. Case-sensitive. For example, `Promotion_a` and `Promotion_A` are regarded as different unit names.
+//        from             Start date of aggregation period.  Format: yyyyMMdd (e.g. 20210301) Time zone: UTC+9
+//        to             End date of aggregation period. The end date can be specified for up to 30 days later. For example, if the start date is 20210301, the latest end date is 20210331.  Format: yyyyMMdd (e.g. 20210301) Time zone: UTC+9
+
+// https://developers.line.biz/en/reference/messaging-api/#get-statistics-per-unit
+func (client *InsightAPI) GetStatisticsPerUnitWithHttpInfo(
+
+	customAggregationUnit string,
+
+	from string,
+
+	to string,
+
+) (*http.Response, *GetStatisticsPerUnitResponse, error) {
 	path := "/v2/bot/insight/message/event/aggregation"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -344,15 +446,15 @@ func (client *InsightAPI) GetStatisticsPerUnit(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -360,8 +462,8 @@ func (client *InsightAPI) GetStatisticsPerUnit(
 	decoder := json.NewDecoder(res.Body)
 	result := GetStatisticsPerUnitResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
diff --git a/linebot/liff/api_liff.go b/linebot/liff/api_liff.go
index 9f6b42c..6bc026d 100644
--- a/linebot/liff/api_liff.go
+++ b/linebot/liff/api_liff.go
@@ -127,17 +127,37 @@ func (client *LiffAPI) AddLIFFApp(
 	addLiffAppRequest *AddLiffAppRequest,
 
 ) (*AddLiffAppResponse, error) {
+	_, body, error := client.AddLIFFAppWithHttpInfo(
+
+		addLiffAppRequest,
+	)
+	return body, error
+}
+
+// AddLIFFApp
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Adding the LIFF app to a channel
+// Parameters:
+//        addLiffAppRequest
+
+// https://developers.line.biz/en/reference/liff-server/#add-liff-app
+func (client *LiffAPI) AddLIFFAppWithHttpInfo(
+
+	addLiffAppRequest *AddLiffAppRequest,
+
+) (*http.Response, *AddLiffAppResponse, error) {
 	path := "/liff/v1/apps"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(addLiffAppRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -145,15 +165,15 @@ func (client *LiffAPI) AddLIFFApp(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -161,9 +181,9 @@ func (client *LiffAPI) AddLIFFApp(
 	decoder := json.NewDecoder(res.Body)
 	result := AddLiffAppResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -179,6 +199,26 @@ func (client *LiffAPI) DeleteLIFFApp(
 	liffId string,
 
 ) (struct{}, error) {
+	_, body, error := client.DeleteLIFFAppWithHttpInfo(
+
+		liffId,
+	)
+	return body, error
+}
+
+// DeleteLIFFApp
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+// Delete LIFF app from a channel
+// Deletes a LIFF app from a channel.
+// Parameters:
+//        liffId             ID of the LIFF app to be updated
+
+// https://developers.line.biz/en/reference/liff-server/#delete-liff-app
+func (client *LiffAPI) DeleteLIFFAppWithHttpInfo(
+
+	liffId string,
+
+) (*http.Response, struct{}, error) {
 	path := "/liff/v1/apps/{liffId}"
 
 	path = strings.Replace(path, "{liffId}", liffId, -1)
@@ -186,27 +226,27 @@ func (client *LiffAPI) DeleteLIFFApp(
 	log.Printf("Sending request: method=Delete path=%s\n", path)
 	req, err := http.NewRequest(http.MethodDelete, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -217,27 +257,39 @@ func (client *LiffAPI) DeleteLIFFApp(
 
 // https://developers.line.biz/en/reference/liff-server/#get-all-liff-apps
 func (client *LiffAPI) GetAllLIFFApps() (*GetAllLiffAppsResponse, error) {
+	_, body, error := client.GetAllLIFFAppsWithHttpInfo()
+	return body, error
+}
+
+// GetAllLIFFApps
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+// Get all LIFF apps
+// Gets information on all the LIFF apps added to the channel.
+// Parameters:
+
+// https://developers.line.biz/en/reference/liff-server/#get-all-liff-apps
+func (client *LiffAPI) GetAllLIFFAppsWithHttpInfo() (*http.Response, *GetAllLiffAppsResponse, error) {
 	path := "/liff/v1/apps"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -245,9 +297,9 @@ func (client *LiffAPI) GetAllLIFFApps() (*GetAllLiffAppsResponse, error) {
 	decoder := json.NewDecoder(res.Body)
 	result := GetAllLiffAppsResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -266,6 +318,31 @@ func (client *LiffAPI) UpdateLIFFApp(
 	updateLiffAppRequest *UpdateLiffAppRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.UpdateLIFFAppWithHttpInfo(
+
+		liffId,
+
+		updateLiffAppRequest,
+	)
+	return body, error
+}
+
+// UpdateLIFFApp
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Update LIFF app settings
+// Parameters:
+//        liffId             ID of the LIFF app to be updated
+//        updateLiffAppRequest
+
+// https://developers.line.biz/en/reference/liff-server/#update-liff-app
+func (client *LiffAPI) UpdateLIFFAppWithHttpInfo(
+
+	liffId string,
+
+	updateLiffAppRequest *UpdateLiffAppRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/liff/v1/apps/{liffId}"
 
 	path = strings.Replace(path, "{liffId}", liffId, -1)
@@ -273,12 +350,12 @@ func (client *LiffAPI) UpdateLIFFApp(
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(updateLiffAppRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Put path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPut, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -286,19 +363,19 @@ func (client *LiffAPI) UpdateLIFFApp(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
diff --git a/linebot/manage_audience/api_manage_audience.go b/linebot/manage_audience/api_manage_audience.go
index 815f9ee..c9b4b6a 100644
--- a/linebot/manage_audience/api_manage_audience.go
+++ b/linebot/manage_audience/api_manage_audience.go
@@ -128,6 +128,26 @@ func (client *ManageAudienceAPI) ActivateAudienceGroup(
 	audienceGroupId int64,
 
 ) (struct{}, error) {
+	_, body, error := client.ActivateAudienceGroupWithHttpInfo(
+
+		audienceGroupId,
+	)
+	return body, error
+}
+
+// ActivateAudienceGroup
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Activate audience
+// Parameters:
+//        audienceGroupId             The audience ID.
+
+// https://developers.line.biz/en/reference/messaging-api/#activate-audience-group
+func (client *ManageAudienceAPI) ActivateAudienceGroupWithHttpInfo(
+
+	audienceGroupId int64,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/audienceGroup/{audienceGroupId}/activate"
 
 	path = strings.Replace(path, "{audienceGroupId}", strconv.FormatInt(audienceGroupId, 10), -1)
@@ -135,27 +155,27 @@ func (client *ManageAudienceAPI) ActivateAudienceGroup(
 	log.Printf("Sending request: method=Put path=%s\n", path)
 	req, err := http.NewRequest(http.MethodPut, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -171,17 +191,37 @@ func (client *ManageAudienceAPI) AddAudienceToAudienceGroup(
 	addAudienceToAudienceGroupRequest *AddAudienceToAudienceGroupRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.AddAudienceToAudienceGroupWithHttpInfo(
+
+		addAudienceToAudienceGroupRequest,
+	)
+	return body, error
+}
+
+// AddAudienceToAudienceGroup
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Add user IDs or Identifiers for Advertisers (IFAs) to an audience for uploading user IDs (by JSON)
+// Parameters:
+//        addAudienceToAudienceGroupRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#update-upload-audience-group
+func (client *ManageAudienceAPI) AddAudienceToAudienceGroupWithHttpInfo(
+
+	addAudienceToAudienceGroupRequest *AddAudienceToAudienceGroupRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/audienceGroup/upload"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(addAudienceToAudienceGroupRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Put path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPut, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -189,20 +229,20 @@ func (client *ManageAudienceAPI) AddAudienceToAudienceGroup(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -218,17 +258,37 @@ func (client *ManageAudienceAPI) CreateAudienceGroup(
 	createAudienceGroupRequest *CreateAudienceGroupRequest,
 
 ) (*CreateAudienceGroupResponse, error) {
+	_, body, error := client.CreateAudienceGroupWithHttpInfo(
+
+		createAudienceGroupRequest,
+	)
+	return body, error
+}
+
+// CreateAudienceGroup
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Create audience for uploading user IDs (by JSON)
+// Parameters:
+//        createAudienceGroupRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#create-upload-audience-group
+func (client *ManageAudienceAPI) CreateAudienceGroupWithHttpInfo(
+
+	createAudienceGroupRequest *CreateAudienceGroupRequest,
+
+) (*http.Response, *CreateAudienceGroupResponse, error) {
 	path := "/v2/bot/audienceGroup/upload"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(createAudienceGroupRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -236,15 +296,15 @@ func (client *ManageAudienceAPI) CreateAudienceGroup(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -252,9 +312,9 @@ func (client *ManageAudienceAPI) CreateAudienceGroup(
 	decoder := json.NewDecoder(res.Body)
 	result := CreateAudienceGroupResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -270,17 +330,37 @@ func (client *ManageAudienceAPI) CreateClickBasedAudienceGroup(
 	createClickBasedAudienceGroupRequest *CreateClickBasedAudienceGroupRequest,
 
 ) (*CreateClickBasedAudienceGroupResponse, error) {
+	_, body, error := client.CreateClickBasedAudienceGroupWithHttpInfo(
+
+		createClickBasedAudienceGroupRequest,
+	)
+	return body, error
+}
+
+// CreateClickBasedAudienceGroup
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Create audience for click-based retargeting
+// Parameters:
+//        createClickBasedAudienceGroupRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#create-click-audience-group
+func (client *ManageAudienceAPI) CreateClickBasedAudienceGroupWithHttpInfo(
+
+	createClickBasedAudienceGroupRequest *CreateClickBasedAudienceGroupRequest,
+
+) (*http.Response, *CreateClickBasedAudienceGroupResponse, error) {
 	path := "/v2/bot/audienceGroup/click"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(createClickBasedAudienceGroupRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -288,15 +368,15 @@ func (client *ManageAudienceAPI) CreateClickBasedAudienceGroup(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -304,9 +384,9 @@ func (client *ManageAudienceAPI) CreateClickBasedAudienceGroup(
 	decoder := json.NewDecoder(res.Body)
 	result := CreateClickBasedAudienceGroupResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -322,17 +402,37 @@ func (client *ManageAudienceAPI) CreateImpBasedAudienceGroup(
 	createImpBasedAudienceGroupRequest *CreateImpBasedAudienceGroupRequest,
 
 ) (*CreateImpBasedAudienceGroupResponse, error) {
+	_, body, error := client.CreateImpBasedAudienceGroupWithHttpInfo(
+
+		createImpBasedAudienceGroupRequest,
+	)
+	return body, error
+}
+
+// CreateImpBasedAudienceGroup
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Create audience for impression-based retargeting
+// Parameters:
+//        createImpBasedAudienceGroupRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#create-imp-audience-group
+func (client *ManageAudienceAPI) CreateImpBasedAudienceGroupWithHttpInfo(
+
+	createImpBasedAudienceGroupRequest *CreateImpBasedAudienceGroupRequest,
+
+) (*http.Response, *CreateImpBasedAudienceGroupResponse, error) {
 	path := "/v2/bot/audienceGroup/imp"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(createImpBasedAudienceGroupRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -340,15 +440,15 @@ func (client *ManageAudienceAPI) CreateImpBasedAudienceGroup(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -356,9 +456,9 @@ func (client *ManageAudienceAPI) CreateImpBasedAudienceGroup(
 	decoder := json.NewDecoder(res.Body)
 	result := CreateImpBasedAudienceGroupResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -374,6 +474,26 @@ func (client *ManageAudienceAPI) DeleteAudienceGroup(
 	audienceGroupId int64,
 
 ) (struct{}, error) {
+	_, body, error := client.DeleteAudienceGroupWithHttpInfo(
+
+		audienceGroupId,
+	)
+	return body, error
+}
+
+// DeleteAudienceGroup
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Delete audience
+// Parameters:
+//        audienceGroupId             The audience ID.
+
+// https://developers.line.biz/en/reference/messaging-api/#delete-audience-group
+func (client *ManageAudienceAPI) DeleteAudienceGroupWithHttpInfo(
+
+	audienceGroupId int64,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/audienceGroup/{audienceGroupId}"
 
 	path = strings.Replace(path, "{audienceGroupId}", strconv.FormatInt(audienceGroupId, 10), -1)
@@ -381,27 +501,27 @@ func (client *ManageAudienceAPI) DeleteAudienceGroup(
 	log.Printf("Sending request: method=Delete path=%s\n", path)
 	req, err := http.NewRequest(http.MethodDelete, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -417,6 +537,26 @@ func (client *ManageAudienceAPI) GetAudienceData(
 	audienceGroupId int64,
 
 ) (*GetAudienceDataResponse, error) {
+	_, body, error := client.GetAudienceDataWithHttpInfo(
+
+		audienceGroupId,
+	)
+	return body, error
+}
+
+// GetAudienceData
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Gets audience data.
+// Parameters:
+//        audienceGroupId             The audience ID.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-audience-group
+func (client *ManageAudienceAPI) GetAudienceDataWithHttpInfo(
+
+	audienceGroupId int64,
+
+) (*http.Response, *GetAudienceDataResponse, error) {
 	path := "/v2/bot/audienceGroup/{audienceGroupId}"
 
 	path = strings.Replace(path, "{audienceGroupId}", strconv.FormatInt(audienceGroupId, 10), -1)
@@ -424,22 +564,22 @@ func (client *ManageAudienceAPI) GetAudienceData(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -447,9 +587,9 @@ func (client *ManageAudienceAPI) GetAudienceData(
 	decoder := json.NewDecoder(res.Body)
 	result := GetAudienceDataResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -460,27 +600,39 @@ func (client *ManageAudienceAPI) GetAudienceData(
 
 // https://developers.line.biz/en/reference/messaging-api/#get-authority-level
 func (client *ManageAudienceAPI) GetAudienceGroupAuthorityLevel() (*GetAudienceGroupAuthorityLevelResponse, error) {
+	_, body, error := client.GetAudienceGroupAuthorityLevelWithHttpInfo()
+	return body, error
+}
+
+// GetAudienceGroupAuthorityLevel
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get the authority level of the audience
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-authority-level
+func (client *ManageAudienceAPI) GetAudienceGroupAuthorityLevelWithHttpInfo() (*http.Response, *GetAudienceGroupAuthorityLevelResponse, error) {
 	path := "/v2/bot/audienceGroup/authorityLevel"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -488,9 +640,9 @@ func (client *ManageAudienceAPI) GetAudienceGroupAuthorityLevel() (*GetAudienceG
 	decoder := json.NewDecoder(res.Body)
 	result := GetAudienceGroupAuthorityLevelResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -521,12 +673,57 @@ func (client *ManageAudienceAPI) GetAudienceGroups(
 	createRoute AudienceGroupCreateRoute,
 
 ) (*GetAudienceGroupsResponse, error) {
+	_, body, error := client.GetAudienceGroupsWithHttpInfo(
+
+		page,
+
+		description,
+
+		status,
+
+		size,
+
+		includesExternalPublicGroups,
+
+		createRoute,
+	)
+	return body, error
+}
+
+// GetAudienceGroups
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Gets data for more than one audience.
+// Parameters:
+//        page             The page to return when getting (paginated) results. Must be 1 or higher.
+//        description             The name of the audience(s) to return. You can search for partial matches. This is case-insensitive, meaning AUDIENCE and audience are considered identical. If omitted, the name of the audience(s) will not be used as a search criterion.
+//        status             The status of the audience(s) to return. If omitted, the status of the audience(s) will not be used as a search criterion.
+//        size             The number of audiences per page. Default: 20 Max: 40
+//        includesExternalPublicGroups             true (default): Get public audiences created in all channels linked to the same bot. false: Get audiences created in the same channel.
+//        createRoute             How the audience was created. If omitted, all audiences are included.  `OA_MANAGER`: Return only audiences created with LINE Official Account Manager (opens new window). `MESSAGING_API`: Return only audiences created with Messaging API.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-audience-groups
+func (client *ManageAudienceAPI) GetAudienceGroupsWithHttpInfo(
+
+	page int64,
+
+	description string,
+
+	status AudienceGroupStatus,
+
+	size int64,
+
+	includesExternalPublicGroups bool,
+
+	createRoute AudienceGroupCreateRoute,
+
+) (*http.Response, *GetAudienceGroupsResponse, error) {
 	path := "/v2/bot/audienceGroup/list"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -543,15 +740,15 @@ func (client *ManageAudienceAPI) GetAudienceGroups(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -559,9 +756,9 @@ func (client *ManageAudienceAPI) GetAudienceGroups(
 	decoder := json.NewDecoder(res.Body)
 	result := GetAudienceGroupsResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -577,17 +774,37 @@ func (client *ManageAudienceAPI) UpdateAudienceGroupAuthorityLevel(
 	updateAudienceGroupAuthorityLevelRequest *UpdateAudienceGroupAuthorityLevelRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.UpdateAudienceGroupAuthorityLevelWithHttpInfo(
+
+		updateAudienceGroupAuthorityLevelRequest,
+	)
+	return body, error
+}
+
+// UpdateAudienceGroupAuthorityLevel
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Change the authority level of the audience
+// Parameters:
+//        updateAudienceGroupAuthorityLevelRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#change-authority-level
+func (client *ManageAudienceAPI) UpdateAudienceGroupAuthorityLevelWithHttpInfo(
+
+	updateAudienceGroupAuthorityLevelRequest *UpdateAudienceGroupAuthorityLevelRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/audienceGroup/authorityLevel"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(updateAudienceGroupAuthorityLevelRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Put path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPut, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -595,20 +812,20 @@ func (client *ManageAudienceAPI) UpdateAudienceGroupAuthorityLevel(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -627,6 +844,31 @@ func (client *ManageAudienceAPI) UpdateAudienceGroupDescription(
 	updateAudienceGroupDescriptionRequest *UpdateAudienceGroupDescriptionRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.UpdateAudienceGroupDescriptionWithHttpInfo(
+
+		audienceGroupId,
+
+		updateAudienceGroupDescriptionRequest,
+	)
+	return body, error
+}
+
+// UpdateAudienceGroupDescription
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Renames an existing audience.
+// Parameters:
+//        audienceGroupId             The audience ID.
+//        updateAudienceGroupDescriptionRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#set-description-audience-group
+func (client *ManageAudienceAPI) UpdateAudienceGroupDescriptionWithHttpInfo(
+
+	audienceGroupId int64,
+
+	updateAudienceGroupDescriptionRequest *UpdateAudienceGroupDescriptionRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/audienceGroup/{audienceGroupId}/updateDescription"
 
 	path = strings.Replace(path, "{audienceGroupId}", strconv.FormatInt(audienceGroupId, 10), -1)
@@ -634,12 +876,12 @@ func (client *ManageAudienceAPI) UpdateAudienceGroupDescription(
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(updateAudienceGroupDescriptionRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Put path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPut, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -647,19 +889,19 @@ func (client *ManageAudienceAPI) UpdateAudienceGroupDescription(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
diff --git a/linebot/manage_audience/api_manage_audience_blob.go b/linebot/manage_audience/api_manage_audience_blob.go
index e2b864e..1066562 100644
--- a/linebot/manage_audience/api_manage_audience_blob.go
+++ b/linebot/manage_audience/api_manage_audience_blob.go
@@ -135,6 +135,36 @@ func (client *ManageAudienceBlobAPI) AddUserIdsToAudience(
 	uploadDescription string,
 
 ) (struct{}, error) {
+	_, body, error := client.AddUserIdsToAudienceWithHttpInfo(
+
+		file,
+
+		audienceGroupId,
+
+		uploadDescription,
+	)
+	return body, error
+}
+
+// AddUserIdsToAudience
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Add user IDs or Identifiers for Advertisers (IFAs) to an audience for uploading user IDs (by file).
+// Parameters:
+//        file             A text file with one user ID or IFA entered per line. Specify text/plain as Content-Type. Max file number: 1 Max number: 1,500,000
+//        audienceGroupId             The audience ID.
+//        uploadDescription             The description to register with the job
+
+// https://developers.line.biz/en/reference/messaging-api/#update-upload-audience-group-by-file
+func (client *ManageAudienceBlobAPI) AddUserIdsToAudienceWithHttpInfo(
+
+	file *os.File,
+
+	audienceGroupId int64,
+
+	uploadDescription string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/audienceGroup/upload/byFile"
 
 	body := &bytes.Buffer{}
@@ -146,19 +176,19 @@ func (client *ManageAudienceBlobAPI) AddUserIdsToAudience(
 
 	fileWriter, err := writer.CreateFormFile("file", file.Name())
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	io.Copy(fileWriter, file)
 
 	err = writer.Close()
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	log.Printf("Sending request: method=Put path=%s\n", path)
 	req, err := http.NewRequest(http.MethodPut, client.Url(path), body)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", writer.FormDataContentType())
 
@@ -166,20 +196,20 @@ func (client *ManageAudienceBlobAPI) AddUserIdsToAudience(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -204,6 +234,41 @@ func (client *ManageAudienceBlobAPI) CreateAudienceForUploadingUserIds(
 	uploadDescription string,
 
 ) (*CreateAudienceGroupResponse, error) {
+	_, body, error := client.CreateAudienceForUploadingUserIdsWithHttpInfo(
+
+		file,
+
+		description,
+
+		isIfaAudience,
+
+		uploadDescription,
+	)
+	return body, error
+}
+
+// CreateAudienceForUploadingUserIds
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Create audience for uploading user IDs (by file).
+// Parameters:
+//        file             A text file with one user ID or IFA entered per line. Specify text/plain as Content-Type. Max file number: 1 Max number: 1,500,000
+//        description             The audience's name. This is case-insensitive, meaning AUDIENCE and audience are considered identical. Max character limit: 120
+//        isIfaAudience             To specify recipients by IFAs: set `true`. To specify recipients by user IDs: set `false` or omit isIfaAudience property.
+//        uploadDescription             The description to register for the job (in `jobs[].description`).
+
+// https://developers.line.biz/en/reference/messaging-api/#create-upload-audience-group-by-file
+func (client *ManageAudienceBlobAPI) CreateAudienceForUploadingUserIdsWithHttpInfo(
+
+	file *os.File,
+
+	description string,
+
+	isIfaAudience bool,
+
+	uploadDescription string,
+
+) (*http.Response, *CreateAudienceGroupResponse, error) {
 	path := "/v2/bot/audienceGroup/upload/byFile"
 
 	body := &bytes.Buffer{}
@@ -217,19 +282,19 @@ func (client *ManageAudienceBlobAPI) CreateAudienceForUploadingUserIds(
 
 	fileWriter, err := writer.CreateFormFile("file", file.Name())
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	io.Copy(fileWriter, file)
 
 	err = writer.Close()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	log.Printf("Sending request: method=Post path=%s\n", path)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), body)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", writer.FormDataContentType())
 
@@ -237,15 +302,15 @@ func (client *ManageAudienceBlobAPI) CreateAudienceForUploadingUserIds(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -253,8 +318,8 @@ func (client *ManageAudienceBlobAPI) CreateAudienceForUploadingUserIds(
 	decoder := json.NewDecoder(res.Body)
 	result := CreateAudienceGroupResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
diff --git a/linebot/messaging_api/api_messaging_api.go b/linebot/messaging_api/api_messaging_api.go
index 63bab64..865ba24 100644
--- a/linebot/messaging_api/api_messaging_api.go
+++ b/linebot/messaging_api/api_messaging_api.go
@@ -127,17 +127,37 @@ func (client *MessagingApiAPI) AudienceMatch(
 	audienceMatchMessagesRequest *AudienceMatchMessagesRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.AudienceMatchWithHttpInfo(
+
+		audienceMatchMessagesRequest,
+	)
+	return body, error
+}
+
+// AudienceMatch
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Send a message using phone number
+// Parameters:
+//        audienceMatchMessagesRequest
+
+// https://developers.line.biz/en/reference/partner-docs/#phone-audience-match
+func (client *MessagingApiAPI) AudienceMatchWithHttpInfo(
+
+	audienceMatchMessagesRequest *AudienceMatchMessagesRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/bot/ad/multicast/phone"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(audienceMatchMessagesRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -145,20 +165,20 @@ func (client *MessagingApiAPI) AudienceMatch(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -177,17 +197,42 @@ func (client *MessagingApiAPI) Broadcast(
 	xLineRetryKey string,
 
 ) (*map[string]interface{}, error) {
+	_, body, error := client.BroadcastWithHttpInfo(
+
+		broadcastRequest,
+
+		xLineRetryKey,
+	)
+	return body, error
+}
+
+// Broadcast
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Sends a message to multiple users at any time.
+// Parameters:
+//        broadcastRequest
+//        xLineRetryKey             Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key.
+
+// https://developers.line.biz/en/reference/messaging-api/#send-broadcast-message
+func (client *MessagingApiAPI) BroadcastWithHttpInfo(
+
+	broadcastRequest *BroadcastRequest,
+
+	xLineRetryKey string,
+
+) (*http.Response, *map[string]interface{}, error) {
 	path := "/v2/bot/message/broadcast"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(broadcastRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -197,15 +242,15 @@ func (client *MessagingApiAPI) Broadcast(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -213,9 +258,9 @@ func (client *MessagingApiAPI) Broadcast(
 	decoder := json.NewDecoder(res.Body)
 	result := map[string]interface{}{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -226,32 +271,44 @@ func (client *MessagingApiAPI) Broadcast(
 
 // https://developers.line.biz/en/reference/messaging-api/#cancel-default-rich-menu
 func (client *MessagingApiAPI) CancelDefaultRichMenu() (struct{}, error) {
+	_, body, error := client.CancelDefaultRichMenuWithHttpInfo()
+	return body, error
+}
+
+// CancelDefaultRichMenu
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Cancel default rich menu
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#cancel-default-rich-menu
+func (client *MessagingApiAPI) CancelDefaultRichMenuWithHttpInfo() (*http.Response, struct{}, error) {
 	path := "/v2/bot/user/all/richmenu"
 
 	log.Printf("Sending request: method=Delete path=%s\n", path)
 	req, err := http.NewRequest(http.MethodDelete, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -267,17 +324,37 @@ func (client *MessagingApiAPI) CreateRichMenu(
 	richMenuRequest *RichMenuRequest,
 
 ) (*RichMenuIdResponse, error) {
+	_, body, error := client.CreateRichMenuWithHttpInfo(
+
+		richMenuRequest,
+	)
+	return body, error
+}
+
+// CreateRichMenu
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Create rich menu
+// Parameters:
+//        richMenuRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#create-rich-menu
+func (client *MessagingApiAPI) CreateRichMenuWithHttpInfo(
+
+	richMenuRequest *RichMenuRequest,
+
+) (*http.Response, *RichMenuIdResponse, error) {
 	path := "/v2/bot/richmenu"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(richMenuRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -285,15 +362,15 @@ func (client *MessagingApiAPI) CreateRichMenu(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -301,9 +378,9 @@ func (client *MessagingApiAPI) CreateRichMenu(
 	decoder := json.NewDecoder(res.Body)
 	result := RichMenuIdResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -319,17 +396,37 @@ func (client *MessagingApiAPI) CreateRichMenuAlias(
 	createRichMenuAliasRequest *CreateRichMenuAliasRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.CreateRichMenuAliasWithHttpInfo(
+
+		createRichMenuAliasRequest,
+	)
+	return body, error
+}
+
+// CreateRichMenuAlias
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Create rich menu alias
+// Parameters:
+//        createRichMenuAliasRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#create-rich-menu-alias
+func (client *MessagingApiAPI) CreateRichMenuAliasWithHttpInfo(
+
+	createRichMenuAliasRequest *CreateRichMenuAliasRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/alias"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(createRichMenuAliasRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -337,20 +434,20 @@ func (client *MessagingApiAPI) CreateRichMenuAlias(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -366,6 +463,26 @@ func (client *MessagingApiAPI) DeleteRichMenu(
 	richMenuId string,
 
 ) (struct{}, error) {
+	_, body, error := client.DeleteRichMenuWithHttpInfo(
+
+		richMenuId,
+	)
+	return body, error
+}
+
+// DeleteRichMenu
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Deletes a rich menu.
+// Parameters:
+//        richMenuId             ID of a rich menu
+
+// https://developers.line.biz/en/reference/messaging-api/#delete-rich-menu
+func (client *MessagingApiAPI) DeleteRichMenuWithHttpInfo(
+
+	richMenuId string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/{richMenuId}"
 
 	path = strings.Replace(path, "{richMenuId}", richMenuId, -1)
@@ -373,27 +490,27 @@ func (client *MessagingApiAPI) DeleteRichMenu(
 	log.Printf("Sending request: method=Delete path=%s\n", path)
 	req, err := http.NewRequest(http.MethodDelete, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -409,6 +526,26 @@ func (client *MessagingApiAPI) DeleteRichMenuAlias(
 	richMenuAliasId string,
 
 ) (struct{}, error) {
+	_, body, error := client.DeleteRichMenuAliasWithHttpInfo(
+
+		richMenuAliasId,
+	)
+	return body, error
+}
+
+// DeleteRichMenuAlias
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Delete rich menu alias
+// Parameters:
+//        richMenuAliasId             Rich menu alias ID that you want to delete.
+
+// https://developers.line.biz/en/reference/messaging-api/#delete-rich-menu-alias
+func (client *MessagingApiAPI) DeleteRichMenuAliasWithHttpInfo(
+
+	richMenuAliasId string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/alias/{richMenuAliasId}"
 
 	path = strings.Replace(path, "{richMenuAliasId}", richMenuAliasId, -1)
@@ -416,27 +553,27 @@ func (client *MessagingApiAPI) DeleteRichMenuAlias(
 	log.Printf("Sending request: method=Delete path=%s\n", path)
 	req, err := http.NewRequest(http.MethodDelete, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -452,12 +589,32 @@ func (client *MessagingApiAPI) GetAdPhoneMessageStatistics(
 	date string,
 
 ) (*NumberOfMessagesResponse, error) {
+	_, body, error := client.GetAdPhoneMessageStatisticsWithHttpInfo(
+
+		date,
+	)
+	return body, error
+}
+
+// GetAdPhoneMessageStatistics
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get result of message delivery using phone number
+// Parameters:
+//        date             Date the message was sent  Format: `yyyyMMdd` (e.g. `20190831`) Time Zone: UTC+9
+
+// https://developers.line.biz/en/reference/partner-docs/#get-phone-audience-match
+func (client *MessagingApiAPI) GetAdPhoneMessageStatisticsWithHttpInfo(
+
+	date string,
+
+) (*http.Response, *NumberOfMessagesResponse, error) {
 	path := "/v2/bot/message/delivery/ad_phone"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -469,15 +626,15 @@ func (client *MessagingApiAPI) GetAdPhoneMessageStatistics(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -485,9 +642,9 @@ func (client *MessagingApiAPI) GetAdPhoneMessageStatistics(
 	decoder := json.NewDecoder(res.Body)
 	result := NumberOfMessagesResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -506,12 +663,37 @@ func (client *MessagingApiAPI) GetAggregationUnitNameList(
 	start string,
 
 ) (*GetAggregationUnitNameListResponse, error) {
+	_, body, error := client.GetAggregationUnitNameListWithHttpInfo(
+
+		limit,
+
+		start,
+	)
+	return body, error
+}
+
+// GetAggregationUnitNameList
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get name list of units used this month
+// Parameters:
+//        limit             The maximum number of aggregation units you can get per request.
+//        start             Value of the continuation token found in the next property of the JSON object returned in the response. If you can't get all the aggregation units in one request, include this parameter to get the remaining array.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-name-list-of-units-used-this-month
+func (client *MessagingApiAPI) GetAggregationUnitNameListWithHttpInfo(
+
+	limit string,
+
+	start string,
+
+) (*http.Response, *GetAggregationUnitNameListResponse, error) {
 	path := "/v2/bot/message/aggregation/list"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -524,15 +706,15 @@ func (client *MessagingApiAPI) GetAggregationUnitNameList(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -540,9 +722,9 @@ func (client *MessagingApiAPI) GetAggregationUnitNameList(
 	decoder := json.NewDecoder(res.Body)
 	result := GetAggregationUnitNameListResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -553,27 +735,39 @@ func (client *MessagingApiAPI) GetAggregationUnitNameList(
 
 // https://developers.line.biz/en/reference/messaging-api/#get-number-of-units-used-this-month
 func (client *MessagingApiAPI) GetAggregationUnitUsage() (*GetAggregationUnitUsageResponse, error) {
+	_, body, error := client.GetAggregationUnitUsageWithHttpInfo()
+	return body, error
+}
+
+// GetAggregationUnitUsage
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get number of units used this month
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-number-of-units-used-this-month
+func (client *MessagingApiAPI) GetAggregationUnitUsageWithHttpInfo() (*http.Response, *GetAggregationUnitUsageResponse, error) {
 	path := "/v2/bot/message/aggregation/info"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -581,9 +775,9 @@ func (client *MessagingApiAPI) GetAggregationUnitUsage() (*GetAggregationUnitUsa
 	decoder := json.NewDecoder(res.Body)
 	result := GetAggregationUnitUsageResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -594,27 +788,39 @@ func (client *MessagingApiAPI) GetAggregationUnitUsage() (*GetAggregationUnitUsa
 
 // https://developers.line.biz/en/reference/messaging-api/#get-bot-info
 func (client *MessagingApiAPI) GetBotInfo() (*BotInfoResponse, error) {
+	_, body, error := client.GetBotInfoWithHttpInfo()
+	return body, error
+}
+
+// GetBotInfo
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get bot info
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-bot-info
+func (client *MessagingApiAPI) GetBotInfoWithHttpInfo() (*http.Response, *BotInfoResponse, error) {
 	path := "/v2/bot/info"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -622,9 +828,9 @@ func (client *MessagingApiAPI) GetBotInfo() (*BotInfoResponse, error) {
 	decoder := json.NewDecoder(res.Body)
 	result := BotInfoResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -635,27 +841,39 @@ func (client *MessagingApiAPI) GetBotInfo() (*BotInfoResponse, error) {
 
 // https://developers.line.biz/en/reference/messaging-api/#get-default-rich-menu-id
 func (client *MessagingApiAPI) GetDefaultRichMenuId() (*RichMenuIdResponse, error) {
+	_, body, error := client.GetDefaultRichMenuIdWithHttpInfo()
+	return body, error
+}
+
+// GetDefaultRichMenuId
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Gets the ID of the default rich menu set with the Messaging API.
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-default-rich-menu-id
+func (client *MessagingApiAPI) GetDefaultRichMenuIdWithHttpInfo() (*http.Response, *RichMenuIdResponse, error) {
 	path := "/v2/bot/user/all/richmenu"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -663,9 +881,9 @@ func (client *MessagingApiAPI) GetDefaultRichMenuId() (*RichMenuIdResponse, erro
 	decoder := json.NewDecoder(res.Body)
 	result := RichMenuIdResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -684,12 +902,37 @@ func (client *MessagingApiAPI) GetFollowers(
 	limit int32,
 
 ) (*GetFollowersResponse, error) {
+	_, body, error := client.GetFollowersWithHttpInfo(
+
+		start,
+
+		limit,
+	)
+	return body, error
+}
+
+// GetFollowers
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get a list of users who added your LINE Official Account as a friend
+// Parameters:
+//        start             Value of the continuation token found in the next property of the JSON object returned in the response. Include this parameter to get the next array of user IDs.
+//        limit             The maximum number of user IDs to retrieve in a single request.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-follower-ids
+func (client *MessagingApiAPI) GetFollowersWithHttpInfo(
+
+	start string,
+
+	limit int32,
+
+) (*http.Response, *GetFollowersResponse, error) {
 	path := "/v2/bot/followers/ids"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -702,15 +945,15 @@ func (client *MessagingApiAPI) GetFollowers(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -718,9 +961,9 @@ func (client *MessagingApiAPI) GetFollowers(
 	decoder := json.NewDecoder(res.Body)
 	result := GetFollowersResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -736,6 +979,26 @@ func (client *MessagingApiAPI) GetGroupMemberCount(
 	groupId string,
 
 ) (*GroupMemberCountResponse, error) {
+	_, body, error := client.GetGroupMemberCountWithHttpInfo(
+
+		groupId,
+	)
+	return body, error
+}
+
+// GetGroupMemberCount
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get number of users in a group chat
+// Parameters:
+//        groupId             Group ID
+
+// https://developers.line.biz/en/reference/messaging-api/#get-members-group-count
+func (client *MessagingApiAPI) GetGroupMemberCountWithHttpInfo(
+
+	groupId string,
+
+) (*http.Response, *GroupMemberCountResponse, error) {
 	path := "/v2/bot/group/{groupId}/members/count"
 
 	path = strings.Replace(path, "{groupId}", groupId, -1)
@@ -743,22 +1006,22 @@ func (client *MessagingApiAPI) GetGroupMemberCount(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -766,9 +1029,9 @@ func (client *MessagingApiAPI) GetGroupMemberCount(
 	decoder := json.NewDecoder(res.Body)
 	result := GroupMemberCountResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -787,6 +1050,31 @@ func (client *MessagingApiAPI) GetGroupMemberProfile(
 	userId string,
 
 ) (*GroupUserProfileResponse, error) {
+	_, body, error := client.GetGroupMemberProfileWithHttpInfo(
+
+		groupId,
+
+		userId,
+	)
+	return body, error
+}
+
+// GetGroupMemberProfile
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get group chat member profile
+// Parameters:
+//        groupId             Group ID
+//        userId             User ID
+
+// https://developers.line.biz/en/reference/messaging-api/#get-group-member-profile
+func (client *MessagingApiAPI) GetGroupMemberProfileWithHttpInfo(
+
+	groupId string,
+
+	userId string,
+
+) (*http.Response, *GroupUserProfileResponse, error) {
 	path := "/v2/bot/group/{groupId}/member/{userId}"
 
 	path = strings.Replace(path, "{groupId}", groupId, -1)
@@ -796,22 +1084,22 @@ func (client *MessagingApiAPI) GetGroupMemberProfile(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -819,9 +1107,9 @@ func (client *MessagingApiAPI) GetGroupMemberProfile(
 	decoder := json.NewDecoder(res.Body)
 	result := GroupUserProfileResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -840,6 +1128,31 @@ func (client *MessagingApiAPI) GetGroupMembersIds(
 	start string,
 
 ) (*MembersIdsResponse, error) {
+	_, body, error := client.GetGroupMembersIdsWithHttpInfo(
+
+		groupId,
+
+		start,
+	)
+	return body, error
+}
+
+// GetGroupMembersIds
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get group chat member user IDs
+// Parameters:
+//        groupId             Group ID
+//        start             Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-group-member-user-ids
+func (client *MessagingApiAPI) GetGroupMembersIdsWithHttpInfo(
+
+	groupId string,
+
+	start string,
+
+) (*http.Response, *MembersIdsResponse, error) {
 	path := "/v2/bot/group/{groupId}/members/ids"
 
 	path = strings.Replace(path, "{groupId}", groupId, -1)
@@ -847,7 +1160,7 @@ func (client *MessagingApiAPI) GetGroupMembersIds(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -859,15 +1172,15 @@ func (client *MessagingApiAPI) GetGroupMembersIds(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -875,9 +1188,9 @@ func (client *MessagingApiAPI) GetGroupMembersIds(
 	decoder := json.NewDecoder(res.Body)
 	result := MembersIdsResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -893,6 +1206,26 @@ func (client *MessagingApiAPI) GetGroupSummary(
 	groupId string,
 
 ) (*GroupSummaryResponse, error) {
+	_, body, error := client.GetGroupSummaryWithHttpInfo(
+
+		groupId,
+	)
+	return body, error
+}
+
+// GetGroupSummary
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get group chat summary
+// Parameters:
+//        groupId             Group ID
+
+// https://developers.line.biz/en/reference/messaging-api/#get-group-summary
+func (client *MessagingApiAPI) GetGroupSummaryWithHttpInfo(
+
+	groupId string,
+
+) (*http.Response, *GroupSummaryResponse, error) {
 	path := "/v2/bot/group/{groupId}/summary"
 
 	path = strings.Replace(path, "{groupId}", groupId, -1)
@@ -900,22 +1233,22 @@ func (client *MessagingApiAPI) GetGroupSummary(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -923,9 +1256,9 @@ func (client *MessagingApiAPI) GetGroupSummary(
 	decoder := json.NewDecoder(res.Body)
 	result := GroupSummaryResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -936,27 +1269,39 @@ func (client *MessagingApiAPI) GetGroupSummary(
 
 // https://developers.line.biz/en/reference/messaging-api/#get-quota
 func (client *MessagingApiAPI) GetMessageQuota() (*MessageQuotaResponse, error) {
+	_, body, error := client.GetMessageQuotaWithHttpInfo()
+	return body, error
+}
+
+// GetMessageQuota
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Gets the target limit for sending messages in the current month. The total number of the free messages and the additional messages is returned.
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-quota
+func (client *MessagingApiAPI) GetMessageQuotaWithHttpInfo() (*http.Response, *MessageQuotaResponse, error) {
 	path := "/v2/bot/message/quota"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -964,9 +1309,9 @@ func (client *MessagingApiAPI) GetMessageQuota() (*MessageQuotaResponse, error)
 	decoder := json.NewDecoder(res.Body)
 	result := MessageQuotaResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -977,27 +1322,39 @@ func (client *MessagingApiAPI) GetMessageQuota() (*MessageQuotaResponse, error)
 
 // https://developers.line.biz/en/reference/messaging-api/#get-consumption
 func (client *MessagingApiAPI) GetMessageQuotaConsumption() (*QuotaConsumptionResponse, error) {
+	_, body, error := client.GetMessageQuotaConsumptionWithHttpInfo()
+	return body, error
+}
+
+// GetMessageQuotaConsumption
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Gets the number of messages sent in the current month.
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-consumption
+func (client *MessagingApiAPI) GetMessageQuotaConsumptionWithHttpInfo() (*http.Response, *QuotaConsumptionResponse, error) {
 	path := "/v2/bot/message/quota/consumption"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1005,9 +1362,9 @@ func (client *MessagingApiAPI) GetMessageQuotaConsumption() (*QuotaConsumptionRe
 	decoder := json.NewDecoder(res.Body)
 	result := QuotaConsumptionResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1023,12 +1380,32 @@ func (client *MessagingApiAPI) GetNarrowcastProgress(
 	requestId string,
 
 ) (*NarrowcastProgressResponse, error) {
+	_, body, error := client.GetNarrowcastProgressWithHttpInfo(
+
+		requestId,
+	)
+	return body, error
+}
+
+// GetNarrowcastProgress
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Gets the status of a narrowcast message.
+// Parameters:
+//        requestId             The narrowcast message's request ID. Each Messaging API request has a request ID.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-narrowcast-progress-status
+func (client *MessagingApiAPI) GetNarrowcastProgressWithHttpInfo(
+
+	requestId string,
+
+) (*http.Response, *NarrowcastProgressResponse, error) {
 	path := "/v2/bot/message/progress/narrowcast"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -1040,15 +1417,15 @@ func (client *MessagingApiAPI) GetNarrowcastProgress(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1056,9 +1433,9 @@ func (client *MessagingApiAPI) GetNarrowcastProgress(
 	decoder := json.NewDecoder(res.Body)
 	result := NarrowcastProgressResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1074,12 +1451,32 @@ func (client *MessagingApiAPI) GetNumberOfSentBroadcastMessages(
 	date string,
 
 ) (*NumberOfMessagesResponse, error) {
+	_, body, error := client.GetNumberOfSentBroadcastMessagesWithHttpInfo(
+
+		date,
+	)
+	return body, error
+}
+
+// GetNumberOfSentBroadcastMessages
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get number of sent broadcast messages
+// Parameters:
+//        date             Date the messages were sent  Format: yyyyMMdd (e.g. 20191231) Timezone: UTC+9
+
+// https://developers.line.biz/en/reference/messaging-api/#get-number-of-broadcast-messages
+func (client *MessagingApiAPI) GetNumberOfSentBroadcastMessagesWithHttpInfo(
+
+	date string,
+
+) (*http.Response, *NumberOfMessagesResponse, error) {
 	path := "/v2/bot/message/delivery/broadcast"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -1091,15 +1488,15 @@ func (client *MessagingApiAPI) GetNumberOfSentBroadcastMessages(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1107,9 +1504,9 @@ func (client *MessagingApiAPI) GetNumberOfSentBroadcastMessages(
 	decoder := json.NewDecoder(res.Body)
 	result := NumberOfMessagesResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1125,12 +1522,32 @@ func (client *MessagingApiAPI) GetNumberOfSentMulticastMessages(
 	date string,
 
 ) (*NumberOfMessagesResponse, error) {
+	_, body, error := client.GetNumberOfSentMulticastMessagesWithHttpInfo(
+
+		date,
+	)
+	return body, error
+}
+
+// GetNumberOfSentMulticastMessages
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get number of sent multicast messages
+// Parameters:
+//        date             Date the messages were sent  Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9
+
+// https://developers.line.biz/en/reference/messaging-api/#get-number-of-multicast-messages
+func (client *MessagingApiAPI) GetNumberOfSentMulticastMessagesWithHttpInfo(
+
+	date string,
+
+) (*http.Response, *NumberOfMessagesResponse, error) {
 	path := "/v2/bot/message/delivery/multicast"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -1142,15 +1559,15 @@ func (client *MessagingApiAPI) GetNumberOfSentMulticastMessages(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1158,9 +1575,9 @@ func (client *MessagingApiAPI) GetNumberOfSentMulticastMessages(
 	decoder := json.NewDecoder(res.Body)
 	result := NumberOfMessagesResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1176,12 +1593,32 @@ func (client *MessagingApiAPI) GetNumberOfSentPushMessages(
 	date string,
 
 ) (*NumberOfMessagesResponse, error) {
+	_, body, error := client.GetNumberOfSentPushMessagesWithHttpInfo(
+
+		date,
+	)
+	return body, error
+}
+
+// GetNumberOfSentPushMessages
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get number of sent push messages
+// Parameters:
+//        date             Date the messages were sent  Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9
+
+// https://developers.line.biz/en/reference/messaging-api/#get-number-of-push-messages
+func (client *MessagingApiAPI) GetNumberOfSentPushMessagesWithHttpInfo(
+
+	date string,
+
+) (*http.Response, *NumberOfMessagesResponse, error) {
 	path := "/v2/bot/message/delivery/push"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -1193,15 +1630,15 @@ func (client *MessagingApiAPI) GetNumberOfSentPushMessages(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1209,9 +1646,9 @@ func (client *MessagingApiAPI) GetNumberOfSentPushMessages(
 	decoder := json.NewDecoder(res.Body)
 	result := NumberOfMessagesResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1227,12 +1664,32 @@ func (client *MessagingApiAPI) GetNumberOfSentReplyMessages(
 	date string,
 
 ) (*NumberOfMessagesResponse, error) {
+	_, body, error := client.GetNumberOfSentReplyMessagesWithHttpInfo(
+
+		date,
+	)
+	return body, error
+}
+
+// GetNumberOfSentReplyMessages
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get number of sent reply messages
+// Parameters:
+//        date             Date the messages were sent  Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9
+
+// https://developers.line.biz/en/reference/messaging-api/#get-number-of-reply-messages
+func (client *MessagingApiAPI) GetNumberOfSentReplyMessagesWithHttpInfo(
+
+	date string,
+
+) (*http.Response, *NumberOfMessagesResponse, error) {
 	path := "/v2/bot/message/delivery/reply"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -1244,15 +1701,15 @@ func (client *MessagingApiAPI) GetNumberOfSentReplyMessages(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1260,9 +1717,9 @@ func (client *MessagingApiAPI) GetNumberOfSentReplyMessages(
 	decoder := json.NewDecoder(res.Body)
 	result := NumberOfMessagesResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1278,12 +1735,32 @@ func (client *MessagingApiAPI) GetPNPMessageStatistics(
 	date string,
 
 ) (*NumberOfMessagesResponse, error) {
+	_, body, error := client.GetPNPMessageStatisticsWithHttpInfo(
+
+		date,
+	)
+	return body, error
+}
+
+// GetPNPMessageStatistics
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get number of sent LINE notification messages
+// Parameters:
+//        date             Date the message was sent  Format: `yyyyMMdd` (Example:`20211231`) Time zone: UTC+9
+
+// https://developers.line.biz/en/reference/partner-docs/#get-number-of-sent-line-notification-messages
+func (client *MessagingApiAPI) GetPNPMessageStatisticsWithHttpInfo(
+
+	date string,
+
+) (*http.Response, *NumberOfMessagesResponse, error) {
 	path := "/v2/bot/message/delivery/pnp"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -1295,15 +1772,15 @@ func (client *MessagingApiAPI) GetPNPMessageStatistics(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1311,9 +1788,9 @@ func (client *MessagingApiAPI) GetPNPMessageStatistics(
 	decoder := json.NewDecoder(res.Body)
 	result := NumberOfMessagesResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1329,6 +1806,26 @@ func (client *MessagingApiAPI) GetProfile(
 	userId string,
 
 ) (*UserProfileResponse, error) {
+	_, body, error := client.GetProfileWithHttpInfo(
+
+		userId,
+	)
+	return body, error
+}
+
+// GetProfile
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get profile
+// Parameters:
+//        userId             User ID
+
+// https://developers.line.biz/en/reference/messaging-api/#get-profile
+func (client *MessagingApiAPI) GetProfileWithHttpInfo(
+
+	userId string,
+
+) (*http.Response, *UserProfileResponse, error) {
 	path := "/v2/bot/profile/{userId}"
 
 	path = strings.Replace(path, "{userId}", userId, -1)
@@ -1336,22 +1833,22 @@ func (client *MessagingApiAPI) GetProfile(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1359,9 +1856,9 @@ func (client *MessagingApiAPI) GetProfile(
 	decoder := json.NewDecoder(res.Body)
 	result := UserProfileResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1377,6 +1874,26 @@ func (client *MessagingApiAPI) GetRichMenu(
 	richMenuId string,
 
 ) (*RichMenuResponse, error) {
+	_, body, error := client.GetRichMenuWithHttpInfo(
+
+		richMenuId,
+	)
+	return body, error
+}
+
+// GetRichMenu
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Gets a rich menu via a rich menu ID.
+// Parameters:
+//        richMenuId             ID of a rich menu
+
+// https://developers.line.biz/en/reference/messaging-api/#get-rich-menu
+func (client *MessagingApiAPI) GetRichMenuWithHttpInfo(
+
+	richMenuId string,
+
+) (*http.Response, *RichMenuResponse, error) {
 	path := "/v2/bot/richmenu/{richMenuId}"
 
 	path = strings.Replace(path, "{richMenuId}", richMenuId, -1)
@@ -1384,22 +1901,22 @@ func (client *MessagingApiAPI) GetRichMenu(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1407,9 +1924,9 @@ func (client *MessagingApiAPI) GetRichMenu(
 	decoder := json.NewDecoder(res.Body)
 	result := RichMenuResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1425,6 +1942,26 @@ func (client *MessagingApiAPI) GetRichMenuAlias(
 	richMenuAliasId string,
 
 ) (*RichMenuAliasResponse, error) {
+	_, body, error := client.GetRichMenuAliasWithHttpInfo(
+
+		richMenuAliasId,
+	)
+	return body, error
+}
+
+// GetRichMenuAlias
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get rich menu alias information
+// Parameters:
+//        richMenuAliasId             The rich menu alias ID whose information you want to obtain.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-rich-menu-alias-by-id
+func (client *MessagingApiAPI) GetRichMenuAliasWithHttpInfo(
+
+	richMenuAliasId string,
+
+) (*http.Response, *RichMenuAliasResponse, error) {
 	path := "/v2/bot/richmenu/alias/{richMenuAliasId}"
 
 	path = strings.Replace(path, "{richMenuAliasId}", richMenuAliasId, -1)
@@ -1432,22 +1969,22 @@ func (client *MessagingApiAPI) GetRichMenuAlias(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1455,9 +1992,9 @@ func (client *MessagingApiAPI) GetRichMenuAlias(
 	decoder := json.NewDecoder(res.Body)
 	result := RichMenuAliasResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1468,27 +2005,39 @@ func (client *MessagingApiAPI) GetRichMenuAlias(
 
 // https://developers.line.biz/en/reference/messaging-api/#get-rich-menu-alias-list
 func (client *MessagingApiAPI) GetRichMenuAliasList() (*RichMenuAliasListResponse, error) {
+	_, body, error := client.GetRichMenuAliasListWithHttpInfo()
+	return body, error
+}
+
+// GetRichMenuAliasList
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get list of rich menu alias
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-rich-menu-alias-list
+func (client *MessagingApiAPI) GetRichMenuAliasListWithHttpInfo() (*http.Response, *RichMenuAliasListResponse, error) {
 	path := "/v2/bot/richmenu/alias/list"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1496,9 +2045,9 @@ func (client *MessagingApiAPI) GetRichMenuAliasList() (*RichMenuAliasListRespons
 	decoder := json.NewDecoder(res.Body)
 	result := RichMenuAliasListResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1514,12 +2063,32 @@ func (client *MessagingApiAPI) GetRichMenuBatchProgress(
 	requestId string,
 
 ) (*RichMenuBatchProgressResponse, error) {
+	_, body, error := client.GetRichMenuBatchProgressWithHttpInfo(
+
+		requestId,
+	)
+	return body, error
+}
+
+// GetRichMenuBatchProgress
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get the status of Replace or unlink a linked rich menus in batches.
+// Parameters:
+//        requestId             A request ID used to batch control the rich menu linked to the user. Each Messaging API request has a request ID.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-batch-control-rich-menus-progress-status
+func (client *MessagingApiAPI) GetRichMenuBatchProgressWithHttpInfo(
+
+	requestId string,
+
+) (*http.Response, *RichMenuBatchProgressResponse, error) {
 	path := "/v2/bot/richmenu/progress/batch"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -1531,15 +2100,15 @@ func (client *MessagingApiAPI) GetRichMenuBatchProgress(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1547,9 +2116,9 @@ func (client *MessagingApiAPI) GetRichMenuBatchProgress(
 	decoder := json.NewDecoder(res.Body)
 	result := RichMenuBatchProgressResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1565,6 +2134,26 @@ func (client *MessagingApiAPI) GetRichMenuIdOfUser(
 	userId string,
 
 ) (*RichMenuIdResponse, error) {
+	_, body, error := client.GetRichMenuIdOfUserWithHttpInfo(
+
+		userId,
+	)
+	return body, error
+}
+
+// GetRichMenuIdOfUser
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get rich menu ID of user
+// Parameters:
+//        userId             User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-rich-menu-id-of-user
+func (client *MessagingApiAPI) GetRichMenuIdOfUserWithHttpInfo(
+
+	userId string,
+
+) (*http.Response, *RichMenuIdResponse, error) {
 	path := "/v2/bot/user/{userId}/richmenu"
 
 	path = strings.Replace(path, "{userId}", userId, -1)
@@ -1572,22 +2161,22 @@ func (client *MessagingApiAPI) GetRichMenuIdOfUser(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1595,9 +2184,9 @@ func (client *MessagingApiAPI) GetRichMenuIdOfUser(
 	decoder := json.NewDecoder(res.Body)
 	result := RichMenuIdResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1608,27 +2197,39 @@ func (client *MessagingApiAPI) GetRichMenuIdOfUser(
 
 // https://developers.line.biz/en/reference/messaging-api/#get-rich-menu-list
 func (client *MessagingApiAPI) GetRichMenuList() (*RichMenuListResponse, error) {
+	_, body, error := client.GetRichMenuListWithHttpInfo()
+	return body, error
+}
+
+// GetRichMenuList
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get rich menu list
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-rich-menu-list
+func (client *MessagingApiAPI) GetRichMenuListWithHttpInfo() (*http.Response, *RichMenuListResponse, error) {
 	path := "/v2/bot/richmenu/list"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1636,9 +2237,9 @@ func (client *MessagingApiAPI) GetRichMenuList() (*RichMenuListResponse, error)
 	decoder := json.NewDecoder(res.Body)
 	result := RichMenuListResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1654,6 +2255,26 @@ func (client *MessagingApiAPI) GetRoomMemberCount(
 	roomId string,
 
 ) (*RoomMemberCountResponse, error) {
+	_, body, error := client.GetRoomMemberCountWithHttpInfo(
+
+		roomId,
+	)
+	return body, error
+}
+
+// GetRoomMemberCount
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get number of users in a multi-person chat
+// Parameters:
+//        roomId             Room ID
+
+// https://developers.line.biz/en/reference/messaging-api/#get-members-room-count
+func (client *MessagingApiAPI) GetRoomMemberCountWithHttpInfo(
+
+	roomId string,
+
+) (*http.Response, *RoomMemberCountResponse, error) {
 	path := "/v2/bot/room/{roomId}/members/count"
 
 	path = strings.Replace(path, "{roomId}", roomId, -1)
@@ -1661,22 +2282,22 @@ func (client *MessagingApiAPI) GetRoomMemberCount(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1684,9 +2305,9 @@ func (client *MessagingApiAPI) GetRoomMemberCount(
 	decoder := json.NewDecoder(res.Body)
 	result := RoomMemberCountResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1705,6 +2326,31 @@ func (client *MessagingApiAPI) GetRoomMemberProfile(
 	userId string,
 
 ) (*RoomUserProfileResponse, error) {
+	_, body, error := client.GetRoomMemberProfileWithHttpInfo(
+
+		roomId,
+
+		userId,
+	)
+	return body, error
+}
+
+// GetRoomMemberProfile
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get multi-person chat member profile
+// Parameters:
+//        roomId             Room ID
+//        userId             User ID
+
+// https://developers.line.biz/en/reference/messaging-api/#get-room-member-profile
+func (client *MessagingApiAPI) GetRoomMemberProfileWithHttpInfo(
+
+	roomId string,
+
+	userId string,
+
+) (*http.Response, *RoomUserProfileResponse, error) {
 	path := "/v2/bot/room/{roomId}/member/{userId}"
 
 	path = strings.Replace(path, "{roomId}", roomId, -1)
@@ -1714,22 +2360,22 @@ func (client *MessagingApiAPI) GetRoomMemberProfile(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1737,9 +2383,9 @@ func (client *MessagingApiAPI) GetRoomMemberProfile(
 	decoder := json.NewDecoder(res.Body)
 	result := RoomUserProfileResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1758,6 +2404,31 @@ func (client *MessagingApiAPI) GetRoomMembersIds(
 	start string,
 
 ) (*MembersIdsResponse, error) {
+	_, body, error := client.GetRoomMembersIdsWithHttpInfo(
+
+		roomId,
+
+		start,
+	)
+	return body, error
+}
+
+// GetRoomMembersIds
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get multi-person chat member user IDs
+// Parameters:
+//        roomId             Room ID
+//        start             Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group.
+
+// https://developers.line.biz/en/reference/messaging-api/#get-room-member-user-ids
+func (client *MessagingApiAPI) GetRoomMembersIdsWithHttpInfo(
+
+	roomId string,
+
+	start string,
+
+) (*http.Response, *MembersIdsResponse, error) {
 	path := "/v2/bot/room/{roomId}/members/ids"
 
 	path = strings.Replace(path, "{roomId}", roomId, -1)
@@ -1765,7 +2436,7 @@ func (client *MessagingApiAPI) GetRoomMembersIds(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -1777,15 +2448,15 @@ func (client *MessagingApiAPI) GetRoomMembersIds(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1793,9 +2464,9 @@ func (client *MessagingApiAPI) GetRoomMembersIds(
 	decoder := json.NewDecoder(res.Body)
 	result := MembersIdsResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1806,27 +2477,39 @@ func (client *MessagingApiAPI) GetRoomMembersIds(
 
 // https://developers.line.biz/en/reference/messaging-api/#get-webhook-endpoint-information
 func (client *MessagingApiAPI) GetWebhookEndpoint() (*GetWebhookEndpointResponse, error) {
+	_, body, error := client.GetWebhookEndpointWithHttpInfo()
+	return body, error
+}
+
+// GetWebhookEndpoint
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get webhook endpoint information
+// Parameters:
+
+// https://developers.line.biz/en/reference/messaging-api/#get-webhook-endpoint-information
+func (client *MessagingApiAPI) GetWebhookEndpointWithHttpInfo() (*http.Response, *GetWebhookEndpointResponse, error) {
 	path := "/v2/bot/channel/webhook/endpoint"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1834,9 +2517,9 @@ func (client *MessagingApiAPI) GetWebhookEndpoint() (*GetWebhookEndpointResponse
 	decoder := json.NewDecoder(res.Body)
 	result := GetWebhookEndpointResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1852,6 +2535,26 @@ func (client *MessagingApiAPI) IssueLinkToken(
 	userId string,
 
 ) (*IssueLinkTokenResponse, error) {
+	_, body, error := client.IssueLinkTokenWithHttpInfo(
+
+		userId,
+	)
+	return body, error
+}
+
+// IssueLinkToken
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Issue link token
+// Parameters:
+//        userId             User ID for the LINE account to be linked. Found in the `source` object of account link event objects. Do not use the LINE ID used in LINE.
+
+// https://developers.line.biz/en/reference/messaging-api/#issue-link-token
+func (client *MessagingApiAPI) IssueLinkTokenWithHttpInfo(
+
+	userId string,
+
+) (*http.Response, *IssueLinkTokenResponse, error) {
 	path := "/v2/bot/user/{userId}/linkToken"
 
 	path = strings.Replace(path, "{userId}", userId, -1)
@@ -1859,22 +2562,22 @@ func (client *MessagingApiAPI) IssueLinkToken(
 	log.Printf("Sending request: method=Post path=%s\n", path)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -1882,9 +2585,9 @@ func (client *MessagingApiAPI) IssueLinkToken(
 	decoder := json.NewDecoder(res.Body)
 	result := IssueLinkTokenResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -1900,6 +2603,26 @@ func (client *MessagingApiAPI) LeaveGroup(
 	groupId string,
 
 ) (struct{}, error) {
+	_, body, error := client.LeaveGroupWithHttpInfo(
+
+		groupId,
+	)
+	return body, error
+}
+
+// LeaveGroup
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Leave group chat
+// Parameters:
+//        groupId             Group ID
+
+// https://developers.line.biz/en/reference/messaging-api/#leave-group
+func (client *MessagingApiAPI) LeaveGroupWithHttpInfo(
+
+	groupId string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/group/{groupId}/leave"
 
 	path = strings.Replace(path, "{groupId}", groupId, -1)
@@ -1907,27 +2630,27 @@ func (client *MessagingApiAPI) LeaveGroup(
 	log.Printf("Sending request: method=Post path=%s\n", path)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -1943,6 +2666,26 @@ func (client *MessagingApiAPI) LeaveRoom(
 	roomId string,
 
 ) (struct{}, error) {
+	_, body, error := client.LeaveRoomWithHttpInfo(
+
+		roomId,
+	)
+	return body, error
+}
+
+// LeaveRoom
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Leave multi-person chat
+// Parameters:
+//        roomId             Room ID
+
+// https://developers.line.biz/en/reference/messaging-api/#leave-room
+func (client *MessagingApiAPI) LeaveRoomWithHttpInfo(
+
+	roomId string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/room/{roomId}/leave"
 
 	path = strings.Replace(path, "{roomId}", roomId, -1)
@@ -1950,27 +2693,27 @@ func (client *MessagingApiAPI) LeaveRoom(
 	log.Printf("Sending request: method=Post path=%s\n", path)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -1989,6 +2732,31 @@ func (client *MessagingApiAPI) LinkRichMenuIdToUser(
 	richMenuId string,
 
 ) (struct{}, error) {
+	_, body, error := client.LinkRichMenuIdToUserWithHttpInfo(
+
+		userId,
+
+		richMenuId,
+	)
+	return body, error
+}
+
+// LinkRichMenuIdToUser
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Link rich menu to user.
+// Parameters:
+//        userId             User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE.
+//        richMenuId             ID of a rich menu
+
+// https://developers.line.biz/en/reference/messaging-api/#link-rich-menu-to-user
+func (client *MessagingApiAPI) LinkRichMenuIdToUserWithHttpInfo(
+
+	userId string,
+
+	richMenuId string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/user/{userId}/richmenu/{richMenuId}"
 
 	path = strings.Replace(path, "{userId}", userId, -1)
@@ -1998,27 +2766,27 @@ func (client *MessagingApiAPI) LinkRichMenuIdToUser(
 	log.Printf("Sending request: method=Post path=%s\n", path)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2034,17 +2802,37 @@ func (client *MessagingApiAPI) LinkRichMenuIdToUsers(
 	richMenuBulkLinkRequest *RichMenuBulkLinkRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.LinkRichMenuIdToUsersWithHttpInfo(
+
+		richMenuBulkLinkRequest,
+	)
+	return body, error
+}
+
+// LinkRichMenuIdToUsers
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Link rich menu to multiple users
+// Parameters:
+//        richMenuBulkLinkRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#link-rich-menu-to-users
+func (client *MessagingApiAPI) LinkRichMenuIdToUsersWithHttpInfo(
+
+	richMenuBulkLinkRequest *RichMenuBulkLinkRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/bulk/link"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(richMenuBulkLinkRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2052,20 +2840,20 @@ func (client *MessagingApiAPI) LinkRichMenuIdToUsers(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2081,17 +2869,37 @@ func (client *MessagingApiAPI) MarkMessagesAsRead(
 	markMessagesAsReadRequest *MarkMessagesAsReadRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.MarkMessagesAsReadWithHttpInfo(
+
+		markMessagesAsReadRequest,
+	)
+	return body, error
+}
+
+// MarkMessagesAsRead
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Mark messages from users as read
+// Parameters:
+//        markMessagesAsReadRequest
+
+// https://developers.line.biz/en/reference/partner-docs/#mark-messages-from-users-as-read
+func (client *MessagingApiAPI) MarkMessagesAsReadWithHttpInfo(
+
+	markMessagesAsReadRequest *MarkMessagesAsReadRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/message/markAsRead"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(markMessagesAsReadRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2099,20 +2907,20 @@ func (client *MessagingApiAPI) MarkMessagesAsRead(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2131,17 +2939,42 @@ func (client *MessagingApiAPI) Multicast(
 	xLineRetryKey string,
 
 ) (*map[string]interface{}, error) {
+	_, body, error := client.MulticastWithHttpInfo(
+
+		multicastRequest,
+
+		xLineRetryKey,
+	)
+	return body, error
+}
+
+// Multicast
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// An API that efficiently sends the same message to multiple user IDs. You can't send messages to group chats or multi-person chats.
+// Parameters:
+//        multicastRequest
+//        xLineRetryKey             Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key.
+
+// https://developers.line.biz/en/reference/messaging-api/#send-multicast-message
+func (client *MessagingApiAPI) MulticastWithHttpInfo(
+
+	multicastRequest *MulticastRequest,
+
+	xLineRetryKey string,
+
+) (*http.Response, *map[string]interface{}, error) {
 	path := "/v2/bot/message/multicast"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(multicastRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2151,29 +2984,54 @@ func (client *MessagingApiAPI) Multicast(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+	}
+
+	defer res.Body.Close()
+
+	decoder := json.NewDecoder(res.Body)
+	result := map[string]interface{}{}
+	if err := decoder.Decode(&result); err != nil {
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
+	return res, &result, nil
+
+}
+
+// Narrowcast
+//
+// Send narrowcast message
+// Parameters:
+//        narrowcastRequest
+//        xLineRetryKey             Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key.
+
+// https://developers.line.biz/en/reference/messaging-api/#send-narrowcast-message
+func (client *MessagingApiAPI) Narrowcast(
+
+	narrowcastRequest *NarrowcastRequest,
 
-	defer res.Body.Close()
+	xLineRetryKey string,
 
-	decoder := json.NewDecoder(res.Body)
-	result := map[string]interface{}{}
-	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
-	}
-	return &result, nil
+) (*map[string]interface{}, error) {
+	_, body, error := client.NarrowcastWithHttpInfo(
 
+		narrowcastRequest,
+
+		xLineRetryKey,
+	)
+	return body, error
 }
 
 // Narrowcast
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
 //
 // Send narrowcast message
 // Parameters:
@@ -2181,24 +3039,24 @@ func (client *MessagingApiAPI) Multicast(
 //        xLineRetryKey             Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key.
 
 // https://developers.line.biz/en/reference/messaging-api/#send-narrowcast-message
-func (client *MessagingApiAPI) Narrowcast(
+func (client *MessagingApiAPI) NarrowcastWithHttpInfo(
 
 	narrowcastRequest *NarrowcastRequest,
 
 	xLineRetryKey string,
 
-) (*map[string]interface{}, error) {
+) (*http.Response, *map[string]interface{}, error) {
 	path := "/v2/bot/message/narrowcast"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(narrowcastRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2208,15 +3066,15 @@ func (client *MessagingApiAPI) Narrowcast(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -2224,9 +3082,9 @@ func (client *MessagingApiAPI) Narrowcast(
 	decoder := json.NewDecoder(res.Body)
 	result := map[string]interface{}{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -2245,17 +3103,42 @@ func (client *MessagingApiAPI) PushMessage(
 	xLineRetryKey string,
 
 ) (*PushMessageResponse, error) {
+	_, body, error := client.PushMessageWithHttpInfo(
+
+		pushMessageRequest,
+
+		xLineRetryKey,
+	)
+	return body, error
+}
+
+// PushMessage
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Sends a message to a user, group chat, or multi-person chat at any time.
+// Parameters:
+//        pushMessageRequest
+//        xLineRetryKey             Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key.
+
+// https://developers.line.biz/en/reference/messaging-api/#send-push-message
+func (client *MessagingApiAPI) PushMessageWithHttpInfo(
+
+	pushMessageRequest *PushMessageRequest,
+
+	xLineRetryKey string,
+
+) (*http.Response, *PushMessageResponse, error) {
 	path := "/v2/bot/message/push"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(pushMessageRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2265,15 +3148,15 @@ func (client *MessagingApiAPI) PushMessage(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -2281,9 +3164,9 @@ func (client *MessagingApiAPI) PushMessage(
 	decoder := json.NewDecoder(res.Body)
 	result := PushMessageResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -2302,17 +3185,42 @@ func (client *MessagingApiAPI) PushMessagesByPhone(
 	xLineDeliveryTag string,
 
 ) (struct{}, error) {
+	_, body, error := client.PushMessagesByPhoneWithHttpInfo(
+
+		pnpMessagesRequest,
+
+		xLineDeliveryTag,
+	)
+	return body, error
+}
+
+// PushMessagesByPhone
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Send LINE notification message
+// Parameters:
+//        pnpMessagesRequest
+//        xLineDeliveryTag             String returned in the delivery.data property of the delivery completion event via Webhook.
+
+// https://developers.line.biz/en/reference/partner-docs/#send-line-notification-message
+func (client *MessagingApiAPI) PushMessagesByPhoneWithHttpInfo(
+
+	pnpMessagesRequest *PnpMessagesRequest,
+
+	xLineDeliveryTag string,
+
+) (*http.Response, struct{}, error) {
 	path := "/bot/pnp/push"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(pnpMessagesRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2322,20 +3230,20 @@ func (client *MessagingApiAPI) PushMessagesByPhone(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2351,17 +3259,37 @@ func (client *MessagingApiAPI) ReplyMessage(
 	replyMessageRequest *ReplyMessageRequest,
 
 ) (*ReplyMessageResponse, error) {
+	_, body, error := client.ReplyMessageWithHttpInfo(
+
+		replyMessageRequest,
+	)
+	return body, error
+}
+
+// ReplyMessage
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Send reply message
+// Parameters:
+//        replyMessageRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#send-reply-message
+func (client *MessagingApiAPI) ReplyMessageWithHttpInfo(
+
+	replyMessageRequest *ReplyMessageRequest,
+
+) (*http.Response, *ReplyMessageResponse, error) {
 	path := "/v2/bot/message/reply"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(replyMessageRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2369,15 +3297,15 @@ func (client *MessagingApiAPI) ReplyMessage(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -2385,9 +3313,9 @@ func (client *MessagingApiAPI) ReplyMessage(
 	decoder := json.NewDecoder(res.Body)
 	result := ReplyMessageResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -2403,17 +3331,37 @@ func (client *MessagingApiAPI) RichMenuBatch(
 	richMenuBatchRequest *RichMenuBatchRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.RichMenuBatchWithHttpInfo(
+
+		richMenuBatchRequest,
+	)
+	return body, error
+}
+
+// RichMenuBatch
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// You can use this endpoint to batch control the rich menu linked to the users using the endpoint such as Link rich menu to user.  The following operations are available:  1. Replace a rich menu with another rich menu for all users linked to a specific rich menu 2. Unlink a rich menu for all users linked to a specific rich menu 3. Unlink a rich menu for all users linked the rich menu
+// Parameters:
+//        richMenuBatchRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#batch-control-rich-menus-of-users
+func (client *MessagingApiAPI) RichMenuBatchWithHttpInfo(
+
+	richMenuBatchRequest *RichMenuBatchRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/batch"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(richMenuBatchRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2421,20 +3369,20 @@ func (client *MessagingApiAPI) RichMenuBatch(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2450,6 +3398,26 @@ func (client *MessagingApiAPI) SetDefaultRichMenu(
 	richMenuId string,
 
 ) (struct{}, error) {
+	_, body, error := client.SetDefaultRichMenuWithHttpInfo(
+
+		richMenuId,
+	)
+	return body, error
+}
+
+// SetDefaultRichMenu
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Set default rich menu
+// Parameters:
+//        richMenuId             ID of a rich menu
+
+// https://developers.line.biz/en/reference/messaging-api/#set-default-rich-menu
+func (client *MessagingApiAPI) SetDefaultRichMenuWithHttpInfo(
+
+	richMenuId string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/user/all/richmenu/{richMenuId}"
 
 	path = strings.Replace(path, "{richMenuId}", richMenuId, -1)
@@ -2457,27 +3425,27 @@ func (client *MessagingApiAPI) SetDefaultRichMenu(
 	log.Printf("Sending request: method=Post path=%s\n", path)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2493,17 +3461,37 @@ func (client *MessagingApiAPI) SetWebhookEndpoint(
 	setWebhookEndpointRequest *SetWebhookEndpointRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.SetWebhookEndpointWithHttpInfo(
+
+		setWebhookEndpointRequest,
+	)
+	return body, error
+}
+
+// SetWebhookEndpoint
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Set webhook endpoint URL
+// Parameters:
+//        setWebhookEndpointRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#set-webhook-endpoint-url
+func (client *MessagingApiAPI) SetWebhookEndpointWithHttpInfo(
+
+	setWebhookEndpointRequest *SetWebhookEndpointRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/channel/webhook/endpoint"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(setWebhookEndpointRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Put path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPut, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2511,20 +3499,20 @@ func (client *MessagingApiAPI) SetWebhookEndpoint(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2540,17 +3528,37 @@ func (client *MessagingApiAPI) TestWebhookEndpoint(
 	testWebhookEndpointRequest *TestWebhookEndpointRequest,
 
 ) (*TestWebhookEndpointResponse, error) {
+	_, body, error := client.TestWebhookEndpointWithHttpInfo(
+
+		testWebhookEndpointRequest,
+	)
+	return body, error
+}
+
+// TestWebhookEndpoint
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Test webhook endpoint
+// Parameters:
+//        testWebhookEndpointRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#test-webhook-endpoint
+func (client *MessagingApiAPI) TestWebhookEndpointWithHttpInfo(
+
+	testWebhookEndpointRequest *TestWebhookEndpointRequest,
+
+) (*http.Response, *TestWebhookEndpointResponse, error) {
 	path := "/v2/bot/channel/webhook/test"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(testWebhookEndpointRequest); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2558,15 +3566,15 @@ func (client *MessagingApiAPI) TestWebhookEndpoint(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -2574,9 +3582,9 @@ func (client *MessagingApiAPI) TestWebhookEndpoint(
 	decoder := json.NewDecoder(res.Body)
 	result := TestWebhookEndpointResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -2592,6 +3600,26 @@ func (client *MessagingApiAPI) UnlinkRichMenuIdFromUser(
 	userId string,
 
 ) (struct{}, error) {
+	_, body, error := client.UnlinkRichMenuIdFromUserWithHttpInfo(
+
+		userId,
+	)
+	return body, error
+}
+
+// UnlinkRichMenuIdFromUser
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Unlink rich menu from user
+// Parameters:
+//        userId             User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE.
+
+// https://developers.line.biz/en/reference/messaging-api/#unlink-rich-menu-from-user
+func (client *MessagingApiAPI) UnlinkRichMenuIdFromUserWithHttpInfo(
+
+	userId string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/user/{userId}/richmenu"
 
 	path = strings.Replace(path, "{userId}", userId, -1)
@@ -2599,27 +3627,27 @@ func (client *MessagingApiAPI) UnlinkRichMenuIdFromUser(
 	log.Printf("Sending request: method=Delete path=%s\n", path)
 	req, err := http.NewRequest(http.MethodDelete, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2635,17 +3663,37 @@ func (client *MessagingApiAPI) UnlinkRichMenuIdFromUsers(
 	richMenuBulkUnlinkRequest *RichMenuBulkUnlinkRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.UnlinkRichMenuIdFromUsersWithHttpInfo(
+
+		richMenuBulkUnlinkRequest,
+	)
+	return body, error
+}
+
+// UnlinkRichMenuIdFromUsers
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Unlink rich menus from multiple users
+// Parameters:
+//        richMenuBulkUnlinkRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#unlink-rich-menu-from-users
+func (client *MessagingApiAPI) UnlinkRichMenuIdFromUsersWithHttpInfo(
+
+	richMenuBulkUnlinkRequest *RichMenuBulkUnlinkRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/bulk/unlink"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(richMenuBulkUnlinkRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2653,20 +3701,20 @@ func (client *MessagingApiAPI) UnlinkRichMenuIdFromUsers(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2685,6 +3733,31 @@ func (client *MessagingApiAPI) UpdateRichMenuAlias(
 	updateRichMenuAliasRequest *UpdateRichMenuAliasRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.UpdateRichMenuAliasWithHttpInfo(
+
+		richMenuAliasId,
+
+		updateRichMenuAliasRequest,
+	)
+	return body, error
+}
+
+// UpdateRichMenuAlias
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Update rich menu alias
+// Parameters:
+//        richMenuAliasId             The rich menu alias ID you want to update.
+//        updateRichMenuAliasRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#update-rich-menu-alias
+func (client *MessagingApiAPI) UpdateRichMenuAliasWithHttpInfo(
+
+	richMenuAliasId string,
+
+	updateRichMenuAliasRequest *UpdateRichMenuAliasRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/alias/{richMenuAliasId}"
 
 	path = strings.Replace(path, "{richMenuAliasId}", richMenuAliasId, -1)
@@ -2692,12 +3765,12 @@ func (client *MessagingApiAPI) UpdateRichMenuAlias(
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(updateRichMenuAliasRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2705,20 +3778,20 @@ func (client *MessagingApiAPI) UpdateRichMenuAlias(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2734,17 +3807,37 @@ func (client *MessagingApiAPI) ValidateBroadcast(
 	validateMessageRequest *ValidateMessageRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.ValidateBroadcastWithHttpInfo(
+
+		validateMessageRequest,
+	)
+	return body, error
+}
+
+// ValidateBroadcast
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Validate message objects of a broadcast message
+// Parameters:
+//        validateMessageRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#validate-message-objects-of-broadcast-message
+func (client *MessagingApiAPI) ValidateBroadcastWithHttpInfo(
+
+	validateMessageRequest *ValidateMessageRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/message/validate/broadcast"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(validateMessageRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2752,20 +3845,20 @@ func (client *MessagingApiAPI) ValidateBroadcast(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2781,17 +3874,37 @@ func (client *MessagingApiAPI) ValidateMulticast(
 	validateMessageRequest *ValidateMessageRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.ValidateMulticastWithHttpInfo(
+
+		validateMessageRequest,
+	)
+	return body, error
+}
+
+// ValidateMulticast
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Validate message objects of a multicast message
+// Parameters:
+//        validateMessageRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#validate-message-objects-of-multicast-message
+func (client *MessagingApiAPI) ValidateMulticastWithHttpInfo(
+
+	validateMessageRequest *ValidateMessageRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/message/validate/multicast"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(validateMessageRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2799,20 +3912,20 @@ func (client *MessagingApiAPI) ValidateMulticast(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2828,17 +3941,37 @@ func (client *MessagingApiAPI) ValidateNarrowcast(
 	validateMessageRequest *ValidateMessageRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.ValidateNarrowcastWithHttpInfo(
+
+		validateMessageRequest,
+	)
+	return body, error
+}
+
+// ValidateNarrowcast
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Validate message objects of a narrowcast message
+// Parameters:
+//        validateMessageRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#validate-message-objects-of-narrowcast-message
+func (client *MessagingApiAPI) ValidateNarrowcastWithHttpInfo(
+
+	validateMessageRequest *ValidateMessageRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/message/validate/narrowcast"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(validateMessageRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2846,20 +3979,20 @@ func (client *MessagingApiAPI) ValidateNarrowcast(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2875,17 +4008,37 @@ func (client *MessagingApiAPI) ValidatePush(
 	validateMessageRequest *ValidateMessageRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.ValidatePushWithHttpInfo(
+
+		validateMessageRequest,
+	)
+	return body, error
+}
+
+// ValidatePush
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Validate message objects of a push message
+// Parameters:
+//        validateMessageRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#validate-message-objects-of-push-message
+func (client *MessagingApiAPI) ValidatePushWithHttpInfo(
+
+	validateMessageRequest *ValidateMessageRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/message/validate/push"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(validateMessageRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2893,20 +4046,20 @@ func (client *MessagingApiAPI) ValidatePush(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2922,17 +4075,37 @@ func (client *MessagingApiAPI) ValidateReply(
 	validateMessageRequest *ValidateMessageRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.ValidateReplyWithHttpInfo(
+
+		validateMessageRequest,
+	)
+	return body, error
+}
+
+// ValidateReply
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Validate message objects of a reply message
+// Parameters:
+//        validateMessageRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#validate-message-objects-of-reply-message
+func (client *MessagingApiAPI) ValidateReplyWithHttpInfo(
+
+	validateMessageRequest *ValidateMessageRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/message/validate/reply"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(validateMessageRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2940,20 +4113,20 @@ func (client *MessagingApiAPI) ValidateReply(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -2969,17 +4142,37 @@ func (client *MessagingApiAPI) ValidateRichMenuBatchRequest(
 	richMenuBatchRequest *RichMenuBatchRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.ValidateRichMenuBatchRequestWithHttpInfo(
+
+		richMenuBatchRequest,
+	)
+	return body, error
+}
+
+// ValidateRichMenuBatchRequest
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Validate a request body of the Replace or unlink the linked rich menus in batches endpoint.
+// Parameters:
+//        richMenuBatchRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#validate-batch-control-rich-menus-request
+func (client *MessagingApiAPI) ValidateRichMenuBatchRequestWithHttpInfo(
+
+	richMenuBatchRequest *RichMenuBatchRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/validate/batch"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(richMenuBatchRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -2987,20 +4180,20 @@ func (client *MessagingApiAPI) ValidateRichMenuBatchRequest(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -3016,17 +4209,37 @@ func (client *MessagingApiAPI) ValidateRichMenuObject(
 	richMenuRequest *RichMenuRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.ValidateRichMenuObjectWithHttpInfo(
+
+		richMenuRequest,
+	)
+	return body, error
+}
+
+// ValidateRichMenuObject
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Validate rich menu object
+// Parameters:
+//        richMenuRequest
+
+// https://developers.line.biz/en/reference/messaging-api/#validate-rich-menu-object
+func (client *MessagingApiAPI) ValidateRichMenuObjectWithHttpInfo(
+
+	richMenuRequest *RichMenuRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/validate"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(richMenuRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -3034,19 +4247,19 @@ func (client *MessagingApiAPI) ValidateRichMenuObject(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
diff --git a/linebot/messaging_api/api_messaging_api_blob.go b/linebot/messaging_api/api_messaging_api_blob.go
index 229dee8..2c0b62e 100644
--- a/linebot/messaging_api/api_messaging_api_blob.go
+++ b/linebot/messaging_api/api_messaging_api_blob.go
@@ -127,6 +127,27 @@ func (client *MessagingApiBlobAPI) GetMessageContent(
 	messageId string,
 
 ) (*http.Response, error) {
+	_, body, error := client.GetMessageContentWithHttpInfo(
+
+		messageId,
+	)
+	return body, error
+}
+
+// GetMessageContent
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Download image, video, and audio data sent from users.
+// Parameters:
+//        messageId             Message ID of video or audio
+
+// You must close the response body when finished with it.
+// https://developers.line.biz/en/reference/messaging-api/#get-content
+func (client *MessagingApiBlobAPI) GetMessageContentWithHttpInfo(
+
+	messageId string,
+
+) (*http.Response, *http.Response, error) {
 	path := "/v2/bot/message/{messageId}/content"
 
 	path = strings.Replace(path, "{messageId}", messageId, -1)
@@ -134,25 +155,25 @@ func (client *MessagingApiBlobAPI) GetMessageContent(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
-	return res, nil
+	return res, res, nil
 
 }
 
@@ -169,6 +190,27 @@ func (client *MessagingApiBlobAPI) GetMessageContentPreview(
 	messageId string,
 
 ) (*http.Response, error) {
+	_, body, error := client.GetMessageContentPreviewWithHttpInfo(
+
+		messageId,
+	)
+	return body, error
+}
+
+// GetMessageContentPreview
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Get a preview image of the image or video
+// Parameters:
+//        messageId             Message ID of image or video
+
+// You must close the response body when finished with it.
+// https://developers.line.biz/en/reference/messaging-api/#get-image-or-video-preview
+func (client *MessagingApiBlobAPI) GetMessageContentPreviewWithHttpInfo(
+
+	messageId string,
+
+) (*http.Response, *http.Response, error) {
 	path := "/v2/bot/message/{messageId}/content/preview"
 
 	path = strings.Replace(path, "{messageId}", messageId, -1)
@@ -176,25 +218,25 @@ func (client *MessagingApiBlobAPI) GetMessageContentPreview(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
-	return res, nil
+	return res, res, nil
 
 }
 
@@ -210,6 +252,26 @@ func (client *MessagingApiBlobAPI) GetMessageContentTranscodingByMessageId(
 	messageId string,
 
 ) (*GetMessageContentTranscodingResponse, error) {
+	_, body, error := client.GetMessageContentTranscodingByMessageIdWithHttpInfo(
+
+		messageId,
+	)
+	return body, error
+}
+
+// GetMessageContentTranscodingByMessageId
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Verify the preparation status of a video or audio for getting
+// Parameters:
+//        messageId             Message ID of video or audio
+
+// https://developers.line.biz/en/reference/messaging-api/#verify-video-or-audio-preparation-status
+func (client *MessagingApiBlobAPI) GetMessageContentTranscodingByMessageIdWithHttpInfo(
+
+	messageId string,
+
+) (*http.Response, *GetMessageContentTranscodingResponse, error) {
 	path := "/v2/bot/message/{messageId}/content/transcoding"
 
 	path = strings.Replace(path, "{messageId}", messageId, -1)
@@ -217,22 +279,22 @@ func (client *MessagingApiBlobAPI) GetMessageContentTranscodingByMessageId(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -240,9 +302,9 @@ func (client *MessagingApiBlobAPI) GetMessageContentTranscodingByMessageId(
 	decoder := json.NewDecoder(res.Body)
 	result := GetMessageContentTranscodingResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -259,6 +321,27 @@ func (client *MessagingApiBlobAPI) GetRichMenuImage(
 	richMenuId string,
 
 ) (*http.Response, error) {
+	_, body, error := client.GetRichMenuImageWithHttpInfo(
+
+		richMenuId,
+	)
+	return body, error
+}
+
+// GetRichMenuImage
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Download rich menu image.
+// Parameters:
+//        richMenuId             ID of the rich menu with the image to be downloaded
+
+// You must close the response body when finished with it.
+// https://developers.line.biz/en/reference/messaging-api/#download-rich-menu-image
+func (client *MessagingApiBlobAPI) GetRichMenuImageWithHttpInfo(
+
+	richMenuId string,
+
+) (*http.Response, *http.Response, error) {
 	path := "/v2/bot/richmenu/{richMenuId}/content"
 
 	path = strings.Replace(path, "{richMenuId}", richMenuId, -1)
@@ -266,25 +349,25 @@ func (client *MessagingApiBlobAPI) GetRichMenuImage(
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
-	return res, nil
+	return res, res, nil
 
 }
 
@@ -305,6 +388,34 @@ func (client *MessagingApiBlobAPI) SetRichMenuImage(
 	bodyReader io.Reader,
 
 ) (struct{}, error) {
+	_, body, error := client.SetRichMenuImageWithHttpInfo(
+
+		richMenuId,
+
+		bodyContentType,
+		bodyReader,
+	)
+	return body, error
+}
+
+// SetRichMenuImage
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Upload rich menu image
+// Parameters:
+//        richMenuId             The ID of the rich menu to attach the image to
+//        bodyContentType   content-type
+//        bodyReader        file content
+
+// https://developers.line.biz/en/reference/messaging-api/#upload-rich-menu-image
+func (client *MessagingApiBlobAPI) SetRichMenuImageWithHttpInfo(
+
+	richMenuId string,
+
+	bodyContentType string,
+	bodyReader io.Reader,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/richmenu/{richMenuId}/content"
 
 	path = strings.Replace(path, "{richMenuId}", richMenuId, -1)
@@ -312,7 +423,7 @@ func (client *MessagingApiBlobAPI) SetRichMenuImage(
 	log.Printf("Sending request: method=Post path=%s bodyContentType=%s\n", path, bodyContentType)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), bodyReader)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", bodyContentType)
 
@@ -320,19 +431,19 @@ func (client *MessagingApiBlobAPI) SetRichMenuImage(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
diff --git a/linebot/module/api_line_module.go b/linebot/module/api_line_module.go
index 08c44c5..79e09bc 100644
--- a/linebot/module/api_line_module.go
+++ b/linebot/module/api_line_module.go
@@ -130,6 +130,31 @@ func (client *LineModuleAPI) AcquireChatControl(
 	acquireChatControlRequest *AcquireChatControlRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.AcquireChatControlWithHttpInfo(
+
+		chatId,
+
+		acquireChatControlRequest,
+	)
+	return body, error
+}
+
+// AcquireChatControl
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// If the Standby Channel wants to take the initiative (Chat Control), it calls the Acquire Control API. The channel that was previously an Active Channel will automatically switch to a Standby Channel.
+// Parameters:
+//        chatId             The `userId`, `roomId`, or `groupId`
+//        acquireChatControlRequest
+
+// https://developers.line.biz/en/reference/partner-docs/#acquire-control-api
+func (client *LineModuleAPI) AcquireChatControlWithHttpInfo(
+
+	chatId string,
+
+	acquireChatControlRequest *AcquireChatControlRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/chat/{chatId}/control/acquire"
 
 	path = strings.Replace(path, "{chatId}", chatId, -1)
@@ -137,12 +162,12 @@ func (client *LineModuleAPI) AcquireChatControl(
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(acquireChatControlRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -150,20 +175,20 @@ func (client *LineModuleAPI) AcquireChatControl(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -179,17 +204,37 @@ func (client *LineModuleAPI) DetachModule(
 	detachModuleRequest *DetachModuleRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.DetachModuleWithHttpInfo(
+
+		detachModuleRequest,
+	)
+	return body, error
+}
+
+// DetachModule
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// The module channel admin calls the Detach API to detach the module channel from a LINE Official Account.
+// Parameters:
+//        detachModuleRequest
+
+// https://developers.line.biz/en/reference/partner-docs/#unlink-detach-module-channel-by-operation-mc-admin
+func (client *LineModuleAPI) DetachModuleWithHttpInfo(
+
+	detachModuleRequest *DetachModuleRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/channel/detach"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(detachModuleRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -197,20 +242,20 @@ func (client *LineModuleAPI) DetachModule(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
 
@@ -229,12 +274,37 @@ func (client *LineModuleAPI) GetModules(
 	limit int32,
 
 ) (*GetModulesResponse, error) {
+	_, body, error := client.GetModulesWithHttpInfo(
+
+		start,
+
+		limit,
+	)
+	return body, error
+}
+
+// GetModules
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Gets a list of basic information about the bots of multiple LINE Official Accounts that have attached module channels.
+// Parameters:
+//        start             Value of the continuation token found in the next property of the JSON object returned in the response. If you can't get all basic information about the bots in one request, include this parameter to get the remaining array.
+//        limit             Specify the maximum number of bots that you get basic information from. The default value is 100. Max value: 100
+
+// https://developers.line.biz/en/reference/partner-docs/#get-multiple-bot-info-api
+func (client *LineModuleAPI) GetModulesWithHttpInfo(
+
+	start string,
+
+	limit int32,
+
+) (*http.Response, *GetModulesResponse, error) {
 	path := "/v2/bot/list"
 
 	log.Printf("Sending request: method=Get path=%s\n", path)
 	req, err := http.NewRequest(http.MethodGet, client.Url(path), nil)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var query url.Values
@@ -247,15 +317,15 @@ func (client *LineModuleAPI) GetModules(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -263,9 +333,9 @@ func (client *LineModuleAPI) GetModules(
 	decoder := json.NewDecoder(res.Body)
 	result := GetModulesResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
 
@@ -281,6 +351,26 @@ func (client *LineModuleAPI) ReleaseChatControl(
 	chatId string,
 
 ) (struct{}, error) {
+	_, body, error := client.ReleaseChatControlWithHttpInfo(
+
+		chatId,
+	)
+	return body, error
+}
+
+// ReleaseChatControl
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// To return the initiative (Chat Control) of Active Channel to Primary Channel, call the Release Control API.
+// Parameters:
+//        chatId             The `userId`, `roomId`, or `groupId`
+
+// https://developers.line.biz/en/reference/partner-docs/#release-control-api
+func (client *LineModuleAPI) ReleaseChatControlWithHttpInfo(
+
+	chatId string,
+
+) (*http.Response, struct{}, error) {
 	path := "/v2/bot/chat/{chatId}/control/release"
 
 	path = strings.Replace(path, "{chatId}", chatId, -1)
@@ -288,26 +378,26 @@ func (client *LineModuleAPI) ReleaseChatControl(
 	log.Printf("Sending request: method=Post path=%s\n", path)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), nil)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 
 	res, err := client.Do(req)
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }
diff --git a/linebot/module_attach/api_line_module_attach.go b/linebot/module_attach/api_line_module_attach.go
index d882cc2..407c529 100644
--- a/linebot/module_attach/api_line_module_attach.go
+++ b/linebot/module_attach/api_line_module_attach.go
@@ -153,6 +153,71 @@ func (client *LineModuleAttachAPI) AttachModule(
 	brandType string,
 
 ) (*AttachModuleResponse, error) {
+	_, body, error := client.AttachModuleWithHttpInfo(
+
+		grantType,
+
+		code,
+
+		redirectUri,
+
+		codeVerifier,
+
+		clientId,
+
+		clientSecret,
+
+		region,
+
+		basicSearchId,
+
+		scope,
+
+		brandType,
+	)
+	return body, error
+}
+
+// AttachModule
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Attach by operation of the module channel provider
+// Parameters:
+//        grantType             authorization_code
+//        code             Authorization code received from the LINE Platform.
+//        redirectUri             Specify the redirect_uri specified in the URL for authentication and authorization.
+//        codeVerifier             Specify when using PKCE (Proof Key for Code Exchange) defined in the OAuth 2.0 extension specification as a countermeasure against authorization code interception attacks.
+//        clientId             Instead of using Authorization header, you can use this parameter to specify the channel ID of the module channel. You can find the channel ID of the module channel in the LINE Developers Console.
+//        clientSecret             Instead of using Authorization header, you can use this parameter to specify the channel secret of the module channel. You can find the channel secret of the module channel in the LINE Developers Console.
+//        region             If you specified a value for region in the URL for authentication and authorization, specify the same value.
+//        basicSearchId             If you specified a value for basic_search_id in the URL for authentication and authorization, specify the same value.
+//        scope             If you specified a value for scope in the URL for authentication and authorization, specify the same value.
+//        brandType             If you specified a value for brand_type in the URL for authentication and authorization, specify the same value.
+
+// https://developers.line.biz/en/reference/partner-docs/#link-attach-by-operation-module-channel-provider
+func (client *LineModuleAttachAPI) AttachModuleWithHttpInfo(
+
+	grantType string,
+
+	code string,
+
+	redirectUri string,
+
+	codeVerifier string,
+
+	clientId string,
+
+	clientSecret string,
+
+	region string,
+
+	basicSearchId string,
+
+	scope string,
+
+	brandType string,
+
+) (*http.Response, *AttachModuleResponse, error) {
 	path := "/module/auth/v1/token"
 
 	vs := url.Values{
@@ -173,7 +238,7 @@ func (client *LineModuleAttachAPI) AttachModule(
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf)
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), body)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 
@@ -181,15 +246,15 @@ func (client *LineModuleAttachAPI) AttachModule(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return nil, err
+		return res, nil, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, fmt.Errorf("failed to read response body: %w", err)
+			return res, nil, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, nil, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
@@ -197,8 +262,8 @@ func (client *LineModuleAttachAPI) AttachModule(
 	decoder := json.NewDecoder(res.Body)
 	result := AttachModuleResponse{}
 	if err := decoder.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON: %w", err)
+		return res, nil, fmt.Errorf("failed to decode JSON: %w", err)
 	}
-	return &result, nil
+	return res, &result, nil
 
 }
diff --git a/linebot/shop/api_shop.go b/linebot/shop/api_shop.go
index c7aa05b..1b308b4 100644
--- a/linebot/shop/api_shop.go
+++ b/linebot/shop/api_shop.go
@@ -126,17 +126,37 @@ func (client *ShopAPI) MissionStickerV3(
 	missionStickerRequest *MissionStickerRequest,
 
 ) (struct{}, error) {
+	_, body, error := client.MissionStickerV3WithHttpInfo(
+
+		missionStickerRequest,
+	)
+	return body, error
+}
+
+// MissionStickerV3
+// If you want to take advantage of the HTTPResponse object for status codes and headers, use this signature.
+//
+// Sends a mission sticker.
+// Parameters:
+//        missionStickerRequest
+
+// https://developers.line.biz/en/reference/partner-docs/#send-mission-stickers-v3
+func (client *ShopAPI) MissionStickerV3WithHttpInfo(
+
+	missionStickerRequest *MissionStickerRequest,
+
+) (*http.Response, struct{}, error) {
 	path := "/shop/v3/mission"
 
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	if err := enc.Encode(missionStickerRequest); err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	log.Printf("Sending request: method=Post path=%s body=%s\n", path, buf.String())
 	req, err := http.NewRequest(http.MethodPost, client.Url(path), &buf)
 	if err != nil {
-		return struct{}{}, err
+		return nil, struct{}{}, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 
@@ -144,19 +164,19 @@ func (client *ShopAPI) MissionStickerV3(
 	log.Printf("Got response from '%s %s': status=%d, contentLength=%d", req.Method, req.URL, res.StatusCode, res.ContentLength)
 
 	if err != nil {
-		return struct{}{}, err
+		return res, struct{}{}, err
 	}
 
 	if res.StatusCode/100 != 2 {
 		body, err := io.ReadAll(res.Body)
 		if err != nil {
-			return struct{}{}, fmt.Errorf("failed to read response body: %w", err)
+			return res, struct{}{}, fmt.Errorf("failed to read response body: %w", err)
 		}
-		return struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
+		return res, struct{}{}, fmt.Errorf("unexpected status code: %d, %s", res.StatusCode, string(body))
 	}
 
 	defer res.Body.Close()
 
-	return struct{}{}, nil
+	return res, struct{}{}, nil
 
 }


Test patch:
diff --git a/linebot/messaging_api/tests/handwritten/api_WithHttpInfo_test.go b/linebot/messaging_api/tests/handwritten/api_WithHttpInfo_test.go
new file mode 100644
index 0000000..d2db09b
--- /dev/null
+++ b/linebot/messaging_api/tests/handwritten/api_WithHttpInfo_test.go
@@ -0,0 +1,43 @@
+package tests
+
+import (
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/line/line-bot-sdk-go/v7/linebot/messaging_api"
+)
+
+func TestTextMessageWithHttpInfo(t *testing.T) {
+	server := httptest.NewServer(
+		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Add("X-Line-Request-Id", "1234567890")
+			w.Write([]byte(`{}`))
+		}),
+	)
+	client, err := messaging_api.NewMessagingApiAPI(
+		"channelToken",
+		messaging_api.WithEndpoint(server.URL),
+	)
+	if err != nil {
+		t.Fatalf("Failed to create client: %v", err)
+	}
+	resp, _, err := client.PushMessageWithHttpInfo(&messaging_api.PushMessageRequest{
+		Messages: []messaging_api.MessageInterface{
+			&messaging_api.TextMessage{
+				Text: "Hello, world",
+			},
+		},
+	}, "")
+	if err != nil {
+		t.Fatalf("Failed to create audience: %v", err)
+	}
+	log.Printf("Got response: %v", resp)
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("status: %d", resp.StatusCode)
+	}
+	if resp.Header.Get("X-Line-Request-Id") != "1234567890" {
+		t.Errorf("X-Line-Request-Id: %s", resp.Header.Get("X-Line-Request-Id"))
+	}
+}