1 /**
2  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
3  * SPDX-License-Identifier: Apache-2.0.
4  */
5 
6 #pragma once
7 #include <aws/apigateway/APIGateway_EXPORTS.h>
8 #include <aws/core/utils/memory/stl/AWSString.h>
9 #include <aws/core/utils/memory/stl/AWSMap.h>
10 #include <aws/apigateway/model/ContentHandlingStrategy.h>
11 #include <utility>
12 
13 namespace Aws
14 {
15 template<typename RESULT_TYPE>
16 class AmazonWebServiceResult;
17 
18 namespace Utils
19 {
20 namespace Json
21 {
22   class JsonValue;
23 } // namespace Json
24 } // namespace Utils
25 namespace APIGateway
26 {
27 namespace Model
28 {
29   /**
30    * <p>Represents an integration response. The status code must map to an existing
31    * <a>MethodResponse</a>, and parameters and templates can be used to transform the
32    * back-end response.</p> <div class="seeAlso"> <a
33    * href="https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-create-api.html">Creating
34    * an API</a> </div><p><h3>See Also:</h3>   <a
35    * href="http://docs.aws.amazon.com/goto/WebAPI/apigateway-2015-07-09/IntegrationResponse">AWS
36    * API Reference</a></p>
37    */
38   class AWS_APIGATEWAY_API PutIntegrationResponseResult
39   {
40   public:
41     PutIntegrationResponseResult();
42     PutIntegrationResponseResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
43     PutIntegrationResponseResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
44 
45 
46     /**
47      * <p>Specifies the status code that is used to map the integration response to an
48      * existing <a>MethodResponse</a>.</p>
49      */
GetStatusCode()50     inline const Aws::String& GetStatusCode() const{ return m_statusCode; }
51 
52     /**
53      * <p>Specifies the status code that is used to map the integration response to an
54      * existing <a>MethodResponse</a>.</p>
55      */
SetStatusCode(const Aws::String & value)56     inline void SetStatusCode(const Aws::String& value) { m_statusCode = value; }
57 
58     /**
59      * <p>Specifies the status code that is used to map the integration response to an
60      * existing <a>MethodResponse</a>.</p>
61      */
SetStatusCode(Aws::String && value)62     inline void SetStatusCode(Aws::String&& value) { m_statusCode = std::move(value); }
63 
64     /**
65      * <p>Specifies the status code that is used to map the integration response to an
66      * existing <a>MethodResponse</a>.</p>
67      */
SetStatusCode(const char * value)68     inline void SetStatusCode(const char* value) { m_statusCode.assign(value); }
69 
70     /**
71      * <p>Specifies the status code that is used to map the integration response to an
72      * existing <a>MethodResponse</a>.</p>
73      */
WithStatusCode(const Aws::String & value)74     inline PutIntegrationResponseResult& WithStatusCode(const Aws::String& value) { SetStatusCode(value); return *this;}
75 
76     /**
77      * <p>Specifies the status code that is used to map the integration response to an
78      * existing <a>MethodResponse</a>.</p>
79      */
WithStatusCode(Aws::String && value)80     inline PutIntegrationResponseResult& WithStatusCode(Aws::String&& value) { SetStatusCode(std::move(value)); return *this;}
81 
82     /**
83      * <p>Specifies the status code that is used to map the integration response to an
84      * existing <a>MethodResponse</a>.</p>
85      */
WithStatusCode(const char * value)86     inline PutIntegrationResponseResult& WithStatusCode(const char* value) { SetStatusCode(value); return *this;}
87 
88 
89     /**
90      * <p>Specifies the regular expression (regex) pattern used to choose an
91      * integration response based on the response from the back end. For example, if
92      * the success response returns nothing and the error response returns some string,
93      * you could use the <code>.+</code> regex to match error response. However, make
94      * sure that the error response does not contain any newline (<code>\n</code>)
95      * character in such cases. If the back end is an AWS Lambda function, the AWS
96      * Lambda function error header is matched. For all other HTTP and AWS back ends,
97      * the HTTP status code is matched.</p>
98      */
GetSelectionPattern()99     inline const Aws::String& GetSelectionPattern() const{ return m_selectionPattern; }
100 
101     /**
102      * <p>Specifies the regular expression (regex) pattern used to choose an
103      * integration response based on the response from the back end. For example, if
104      * the success response returns nothing and the error response returns some string,
105      * you could use the <code>.+</code> regex to match error response. However, make
106      * sure that the error response does not contain any newline (<code>\n</code>)
107      * character in such cases. If the back end is an AWS Lambda function, the AWS
108      * Lambda function error header is matched. For all other HTTP and AWS back ends,
109      * the HTTP status code is matched.</p>
110      */
SetSelectionPattern(const Aws::String & value)111     inline void SetSelectionPattern(const Aws::String& value) { m_selectionPattern = value; }
112 
113     /**
114      * <p>Specifies the regular expression (regex) pattern used to choose an
115      * integration response based on the response from the back end. For example, if
116      * the success response returns nothing and the error response returns some string,
117      * you could use the <code>.+</code> regex to match error response. However, make
118      * sure that the error response does not contain any newline (<code>\n</code>)
119      * character in such cases. If the back end is an AWS Lambda function, the AWS
120      * Lambda function error header is matched. For all other HTTP and AWS back ends,
121      * the HTTP status code is matched.</p>
122      */
SetSelectionPattern(Aws::String && value)123     inline void SetSelectionPattern(Aws::String&& value) { m_selectionPattern = std::move(value); }
124 
125     /**
126      * <p>Specifies the regular expression (regex) pattern used to choose an
127      * integration response based on the response from the back end. For example, if
128      * the success response returns nothing and the error response returns some string,
129      * you could use the <code>.+</code> regex to match error response. However, make
130      * sure that the error response does not contain any newline (<code>\n</code>)
131      * character in such cases. If the back end is an AWS Lambda function, the AWS
132      * Lambda function error header is matched. For all other HTTP and AWS back ends,
133      * the HTTP status code is matched.</p>
134      */
SetSelectionPattern(const char * value)135     inline void SetSelectionPattern(const char* value) { m_selectionPattern.assign(value); }
136 
137     /**
138      * <p>Specifies the regular expression (regex) pattern used to choose an
139      * integration response based on the response from the back end. For example, if
140      * the success response returns nothing and the error response returns some string,
141      * you could use the <code>.+</code> regex to match error response. However, make
142      * sure that the error response does not contain any newline (<code>\n</code>)
143      * character in such cases. If the back end is an AWS Lambda function, the AWS
144      * Lambda function error header is matched. For all other HTTP and AWS back ends,
145      * the HTTP status code is matched.</p>
146      */
WithSelectionPattern(const Aws::String & value)147     inline PutIntegrationResponseResult& WithSelectionPattern(const Aws::String& value) { SetSelectionPattern(value); return *this;}
148 
149     /**
150      * <p>Specifies the regular expression (regex) pattern used to choose an
151      * integration response based on the response from the back end. For example, if
152      * the success response returns nothing and the error response returns some string,
153      * you could use the <code>.+</code> regex to match error response. However, make
154      * sure that the error response does not contain any newline (<code>\n</code>)
155      * character in such cases. If the back end is an AWS Lambda function, the AWS
156      * Lambda function error header is matched. For all other HTTP and AWS back ends,
157      * the HTTP status code is matched.</p>
158      */
WithSelectionPattern(Aws::String && value)159     inline PutIntegrationResponseResult& WithSelectionPattern(Aws::String&& value) { SetSelectionPattern(std::move(value)); return *this;}
160 
161     /**
162      * <p>Specifies the regular expression (regex) pattern used to choose an
163      * integration response based on the response from the back end. For example, if
164      * the success response returns nothing and the error response returns some string,
165      * you could use the <code>.+</code> regex to match error response. However, make
166      * sure that the error response does not contain any newline (<code>\n</code>)
167      * character in such cases. If the back end is an AWS Lambda function, the AWS
168      * Lambda function error header is matched. For all other HTTP and AWS back ends,
169      * the HTTP status code is matched.</p>
170      */
WithSelectionPattern(const char * value)171     inline PutIntegrationResponseResult& WithSelectionPattern(const char* value) { SetSelectionPattern(value); return *this;}
172 
173 
174     /**
175      * <p>A key-value map specifying response parameters that are passed to the method
176      * response from the back end. The key is a method response header parameter name
177      * and the mapped value is an integration response header value, a static value
178      * enclosed within a pair of single quotes, or a JSON expression from the
179      * integration response body. The mapping key must match the pattern of
180      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
181      * and unique header name. The mapped non-static value must match the pattern of
182      * <code>integration.response.header.{name}</code> or
183      * <code>integration.response.body.{JSON-expression}</code>, where
184      * <code>name</code> is a valid and unique response header name and
185      * <code>JSON-expression</code> is a valid JSON expression without the
186      * <code>$</code> prefix.</p>
187      */
GetResponseParameters()188     inline const Aws::Map<Aws::String, Aws::String>& GetResponseParameters() const{ return m_responseParameters; }
189 
190     /**
191      * <p>A key-value map specifying response parameters that are passed to the method
192      * response from the back end. The key is a method response header parameter name
193      * and the mapped value is an integration response header value, a static value
194      * enclosed within a pair of single quotes, or a JSON expression from the
195      * integration response body. The mapping key must match the pattern of
196      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
197      * and unique header name. The mapped non-static value must match the pattern of
198      * <code>integration.response.header.{name}</code> or
199      * <code>integration.response.body.{JSON-expression}</code>, where
200      * <code>name</code> is a valid and unique response header name and
201      * <code>JSON-expression</code> is a valid JSON expression without the
202      * <code>$</code> prefix.</p>
203      */
SetResponseParameters(const Aws::Map<Aws::String,Aws::String> & value)204     inline void SetResponseParameters(const Aws::Map<Aws::String, Aws::String>& value) { m_responseParameters = value; }
205 
206     /**
207      * <p>A key-value map specifying response parameters that are passed to the method
208      * response from the back end. The key is a method response header parameter name
209      * and the mapped value is an integration response header value, a static value
210      * enclosed within a pair of single quotes, or a JSON expression from the
211      * integration response body. The mapping key must match the pattern of
212      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
213      * and unique header name. The mapped non-static value must match the pattern of
214      * <code>integration.response.header.{name}</code> or
215      * <code>integration.response.body.{JSON-expression}</code>, where
216      * <code>name</code> is a valid and unique response header name and
217      * <code>JSON-expression</code> is a valid JSON expression without the
218      * <code>$</code> prefix.</p>
219      */
SetResponseParameters(Aws::Map<Aws::String,Aws::String> && value)220     inline void SetResponseParameters(Aws::Map<Aws::String, Aws::String>&& value) { m_responseParameters = std::move(value); }
221 
222     /**
223      * <p>A key-value map specifying response parameters that are passed to the method
224      * response from the back end. The key is a method response header parameter name
225      * and the mapped value is an integration response header value, a static value
226      * enclosed within a pair of single quotes, or a JSON expression from the
227      * integration response body. The mapping key must match the pattern of
228      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
229      * and unique header name. The mapped non-static value must match the pattern of
230      * <code>integration.response.header.{name}</code> or
231      * <code>integration.response.body.{JSON-expression}</code>, where
232      * <code>name</code> is a valid and unique response header name and
233      * <code>JSON-expression</code> is a valid JSON expression without the
234      * <code>$</code> prefix.</p>
235      */
WithResponseParameters(const Aws::Map<Aws::String,Aws::String> & value)236     inline PutIntegrationResponseResult& WithResponseParameters(const Aws::Map<Aws::String, Aws::String>& value) { SetResponseParameters(value); return *this;}
237 
238     /**
239      * <p>A key-value map specifying response parameters that are passed to the method
240      * response from the back end. The key is a method response header parameter name
241      * and the mapped value is an integration response header value, a static value
242      * enclosed within a pair of single quotes, or a JSON expression from the
243      * integration response body. The mapping key must match the pattern of
244      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
245      * and unique header name. The mapped non-static value must match the pattern of
246      * <code>integration.response.header.{name}</code> or
247      * <code>integration.response.body.{JSON-expression}</code>, where
248      * <code>name</code> is a valid and unique response header name and
249      * <code>JSON-expression</code> is a valid JSON expression without the
250      * <code>$</code> prefix.</p>
251      */
WithResponseParameters(Aws::Map<Aws::String,Aws::String> && value)252     inline PutIntegrationResponseResult& WithResponseParameters(Aws::Map<Aws::String, Aws::String>&& value) { SetResponseParameters(std::move(value)); return *this;}
253 
254     /**
255      * <p>A key-value map specifying response parameters that are passed to the method
256      * response from the back end. The key is a method response header parameter name
257      * and the mapped value is an integration response header value, a static value
258      * enclosed within a pair of single quotes, or a JSON expression from the
259      * integration response body. The mapping key must match the pattern of
260      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
261      * and unique header name. The mapped non-static value must match the pattern of
262      * <code>integration.response.header.{name}</code> or
263      * <code>integration.response.body.{JSON-expression}</code>, where
264      * <code>name</code> is a valid and unique response header name and
265      * <code>JSON-expression</code> is a valid JSON expression without the
266      * <code>$</code> prefix.</p>
267      */
AddResponseParameters(const Aws::String & key,const Aws::String & value)268     inline PutIntegrationResponseResult& AddResponseParameters(const Aws::String& key, const Aws::String& value) { m_responseParameters.emplace(key, value); return *this; }
269 
270     /**
271      * <p>A key-value map specifying response parameters that are passed to the method
272      * response from the back end. The key is a method response header parameter name
273      * and the mapped value is an integration response header value, a static value
274      * enclosed within a pair of single quotes, or a JSON expression from the
275      * integration response body. The mapping key must match the pattern of
276      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
277      * and unique header name. The mapped non-static value must match the pattern of
278      * <code>integration.response.header.{name}</code> or
279      * <code>integration.response.body.{JSON-expression}</code>, where
280      * <code>name</code> is a valid and unique response header name and
281      * <code>JSON-expression</code> is a valid JSON expression without the
282      * <code>$</code> prefix.</p>
283      */
AddResponseParameters(Aws::String && key,const Aws::String & value)284     inline PutIntegrationResponseResult& AddResponseParameters(Aws::String&& key, const Aws::String& value) { m_responseParameters.emplace(std::move(key), value); return *this; }
285 
286     /**
287      * <p>A key-value map specifying response parameters that are passed to the method
288      * response from the back end. The key is a method response header parameter name
289      * and the mapped value is an integration response header value, a static value
290      * enclosed within a pair of single quotes, or a JSON expression from the
291      * integration response body. The mapping key must match the pattern of
292      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
293      * and unique header name. The mapped non-static value must match the pattern of
294      * <code>integration.response.header.{name}</code> or
295      * <code>integration.response.body.{JSON-expression}</code>, where
296      * <code>name</code> is a valid and unique response header name and
297      * <code>JSON-expression</code> is a valid JSON expression without the
298      * <code>$</code> prefix.</p>
299      */
AddResponseParameters(const Aws::String & key,Aws::String && value)300     inline PutIntegrationResponseResult& AddResponseParameters(const Aws::String& key, Aws::String&& value) { m_responseParameters.emplace(key, std::move(value)); return *this; }
301 
302     /**
303      * <p>A key-value map specifying response parameters that are passed to the method
304      * response from the back end. The key is a method response header parameter name
305      * and the mapped value is an integration response header value, a static value
306      * enclosed within a pair of single quotes, or a JSON expression from the
307      * integration response body. The mapping key must match the pattern of
308      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
309      * and unique header name. The mapped non-static value must match the pattern of
310      * <code>integration.response.header.{name}</code> or
311      * <code>integration.response.body.{JSON-expression}</code>, where
312      * <code>name</code> is a valid and unique response header name and
313      * <code>JSON-expression</code> is a valid JSON expression without the
314      * <code>$</code> prefix.</p>
315      */
AddResponseParameters(Aws::String && key,Aws::String && value)316     inline PutIntegrationResponseResult& AddResponseParameters(Aws::String&& key, Aws::String&& value) { m_responseParameters.emplace(std::move(key), std::move(value)); return *this; }
317 
318     /**
319      * <p>A key-value map specifying response parameters that are passed to the method
320      * response from the back end. The key is a method response header parameter name
321      * and the mapped value is an integration response header value, a static value
322      * enclosed within a pair of single quotes, or a JSON expression from the
323      * integration response body. The mapping key must match the pattern of
324      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
325      * and unique header name. The mapped non-static value must match the pattern of
326      * <code>integration.response.header.{name}</code> or
327      * <code>integration.response.body.{JSON-expression}</code>, where
328      * <code>name</code> is a valid and unique response header name and
329      * <code>JSON-expression</code> is a valid JSON expression without the
330      * <code>$</code> prefix.</p>
331      */
AddResponseParameters(const char * key,Aws::String && value)332     inline PutIntegrationResponseResult& AddResponseParameters(const char* key, Aws::String&& value) { m_responseParameters.emplace(key, std::move(value)); return *this; }
333 
334     /**
335      * <p>A key-value map specifying response parameters that are passed to the method
336      * response from the back end. The key is a method response header parameter name
337      * and the mapped value is an integration response header value, a static value
338      * enclosed within a pair of single quotes, or a JSON expression from the
339      * integration response body. The mapping key must match the pattern of
340      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
341      * and unique header name. The mapped non-static value must match the pattern of
342      * <code>integration.response.header.{name}</code> or
343      * <code>integration.response.body.{JSON-expression}</code>, where
344      * <code>name</code> is a valid and unique response header name and
345      * <code>JSON-expression</code> is a valid JSON expression without the
346      * <code>$</code> prefix.</p>
347      */
AddResponseParameters(Aws::String && key,const char * value)348     inline PutIntegrationResponseResult& AddResponseParameters(Aws::String&& key, const char* value) { m_responseParameters.emplace(std::move(key), value); return *this; }
349 
350     /**
351      * <p>A key-value map specifying response parameters that are passed to the method
352      * response from the back end. The key is a method response header parameter name
353      * and the mapped value is an integration response header value, a static value
354      * enclosed within a pair of single quotes, or a JSON expression from the
355      * integration response body. The mapping key must match the pattern of
356      * <code>method.response.header.{name}</code>, where <code>name</code> is a valid
357      * and unique header name. The mapped non-static value must match the pattern of
358      * <code>integration.response.header.{name}</code> or
359      * <code>integration.response.body.{JSON-expression}</code>, where
360      * <code>name</code> is a valid and unique response header name and
361      * <code>JSON-expression</code> is a valid JSON expression without the
362      * <code>$</code> prefix.</p>
363      */
AddResponseParameters(const char * key,const char * value)364     inline PutIntegrationResponseResult& AddResponseParameters(const char* key, const char* value) { m_responseParameters.emplace(key, value); return *this; }
365 
366 
367     /**
368      * <p>Specifies the templates used to transform the integration response body.
369      * Response templates are represented as a key/value map, with a content-type as
370      * the key and a template as the value.</p>
371      */
GetResponseTemplates()372     inline const Aws::Map<Aws::String, Aws::String>& GetResponseTemplates() const{ return m_responseTemplates; }
373 
374     /**
375      * <p>Specifies the templates used to transform the integration response body.
376      * Response templates are represented as a key/value map, with a content-type as
377      * the key and a template as the value.</p>
378      */
SetResponseTemplates(const Aws::Map<Aws::String,Aws::String> & value)379     inline void SetResponseTemplates(const Aws::Map<Aws::String, Aws::String>& value) { m_responseTemplates = value; }
380 
381     /**
382      * <p>Specifies the templates used to transform the integration response body.
383      * Response templates are represented as a key/value map, with a content-type as
384      * the key and a template as the value.</p>
385      */
SetResponseTemplates(Aws::Map<Aws::String,Aws::String> && value)386     inline void SetResponseTemplates(Aws::Map<Aws::String, Aws::String>&& value) { m_responseTemplates = std::move(value); }
387 
388     /**
389      * <p>Specifies the templates used to transform the integration response body.
390      * Response templates are represented as a key/value map, with a content-type as
391      * the key and a template as the value.</p>
392      */
WithResponseTemplates(const Aws::Map<Aws::String,Aws::String> & value)393     inline PutIntegrationResponseResult& WithResponseTemplates(const Aws::Map<Aws::String, Aws::String>& value) { SetResponseTemplates(value); return *this;}
394 
395     /**
396      * <p>Specifies the templates used to transform the integration response body.
397      * Response templates are represented as a key/value map, with a content-type as
398      * the key and a template as the value.</p>
399      */
WithResponseTemplates(Aws::Map<Aws::String,Aws::String> && value)400     inline PutIntegrationResponseResult& WithResponseTemplates(Aws::Map<Aws::String, Aws::String>&& value) { SetResponseTemplates(std::move(value)); return *this;}
401 
402     /**
403      * <p>Specifies the templates used to transform the integration response body.
404      * Response templates are represented as a key/value map, with a content-type as
405      * the key and a template as the value.</p>
406      */
AddResponseTemplates(const Aws::String & key,const Aws::String & value)407     inline PutIntegrationResponseResult& AddResponseTemplates(const Aws::String& key, const Aws::String& value) { m_responseTemplates.emplace(key, value); return *this; }
408 
409     /**
410      * <p>Specifies the templates used to transform the integration response body.
411      * Response templates are represented as a key/value map, with a content-type as
412      * the key and a template as the value.</p>
413      */
AddResponseTemplates(Aws::String && key,const Aws::String & value)414     inline PutIntegrationResponseResult& AddResponseTemplates(Aws::String&& key, const Aws::String& value) { m_responseTemplates.emplace(std::move(key), value); return *this; }
415 
416     /**
417      * <p>Specifies the templates used to transform the integration response body.
418      * Response templates are represented as a key/value map, with a content-type as
419      * the key and a template as the value.</p>
420      */
AddResponseTemplates(const Aws::String & key,Aws::String && value)421     inline PutIntegrationResponseResult& AddResponseTemplates(const Aws::String& key, Aws::String&& value) { m_responseTemplates.emplace(key, std::move(value)); return *this; }
422 
423     /**
424      * <p>Specifies the templates used to transform the integration response body.
425      * Response templates are represented as a key/value map, with a content-type as
426      * the key and a template as the value.</p>
427      */
AddResponseTemplates(Aws::String && key,Aws::String && value)428     inline PutIntegrationResponseResult& AddResponseTemplates(Aws::String&& key, Aws::String&& value) { m_responseTemplates.emplace(std::move(key), std::move(value)); return *this; }
429 
430     /**
431      * <p>Specifies the templates used to transform the integration response body.
432      * Response templates are represented as a key/value map, with a content-type as
433      * the key and a template as the value.</p>
434      */
AddResponseTemplates(const char * key,Aws::String && value)435     inline PutIntegrationResponseResult& AddResponseTemplates(const char* key, Aws::String&& value) { m_responseTemplates.emplace(key, std::move(value)); return *this; }
436 
437     /**
438      * <p>Specifies the templates used to transform the integration response body.
439      * Response templates are represented as a key/value map, with a content-type as
440      * the key and a template as the value.</p>
441      */
AddResponseTemplates(Aws::String && key,const char * value)442     inline PutIntegrationResponseResult& AddResponseTemplates(Aws::String&& key, const char* value) { m_responseTemplates.emplace(std::move(key), value); return *this; }
443 
444     /**
445      * <p>Specifies the templates used to transform the integration response body.
446      * Response templates are represented as a key/value map, with a content-type as
447      * the key and a template as the value.</p>
448      */
AddResponseTemplates(const char * key,const char * value)449     inline PutIntegrationResponseResult& AddResponseTemplates(const char* key, const char* value) { m_responseTemplates.emplace(key, value); return *this; }
450 
451 
452     /**
453      * <p>Specifies how to handle response payload content type conversions. Supported
454      * values are <code>CONVERT_TO_BINARY</code> and <code>CONVERT_TO_TEXT</code>, with
455      * the following behaviors:</p> <ul> <li><p><code>CONVERT_TO_BINARY</code>:
456      * Converts a response payload from a Base64-encoded string to the corresponding
457      * binary blob.</p></li> <li><p><code>CONVERT_TO_TEXT</code>: Converts a response
458      * payload from a binary blob to a Base64-encoded string.</p></li> </ul> <p>If this
459      * property is not defined, the response payload will be passed through from the
460      * integration response to the method response without modification.</p>
461      */
GetContentHandling()462     inline const ContentHandlingStrategy& GetContentHandling() const{ return m_contentHandling; }
463 
464     /**
465      * <p>Specifies how to handle response payload content type conversions. Supported
466      * values are <code>CONVERT_TO_BINARY</code> and <code>CONVERT_TO_TEXT</code>, with
467      * the following behaviors:</p> <ul> <li><p><code>CONVERT_TO_BINARY</code>:
468      * Converts a response payload from a Base64-encoded string to the corresponding
469      * binary blob.</p></li> <li><p><code>CONVERT_TO_TEXT</code>: Converts a response
470      * payload from a binary blob to a Base64-encoded string.</p></li> </ul> <p>If this
471      * property is not defined, the response payload will be passed through from the
472      * integration response to the method response without modification.</p>
473      */
SetContentHandling(const ContentHandlingStrategy & value)474     inline void SetContentHandling(const ContentHandlingStrategy& value) { m_contentHandling = value; }
475 
476     /**
477      * <p>Specifies how to handle response payload content type conversions. Supported
478      * values are <code>CONVERT_TO_BINARY</code> and <code>CONVERT_TO_TEXT</code>, with
479      * the following behaviors:</p> <ul> <li><p><code>CONVERT_TO_BINARY</code>:
480      * Converts a response payload from a Base64-encoded string to the corresponding
481      * binary blob.</p></li> <li><p><code>CONVERT_TO_TEXT</code>: Converts a response
482      * payload from a binary blob to a Base64-encoded string.</p></li> </ul> <p>If this
483      * property is not defined, the response payload will be passed through from the
484      * integration response to the method response without modification.</p>
485      */
SetContentHandling(ContentHandlingStrategy && value)486     inline void SetContentHandling(ContentHandlingStrategy&& value) { m_contentHandling = std::move(value); }
487 
488     /**
489      * <p>Specifies how to handle response payload content type conversions. Supported
490      * values are <code>CONVERT_TO_BINARY</code> and <code>CONVERT_TO_TEXT</code>, with
491      * the following behaviors:</p> <ul> <li><p><code>CONVERT_TO_BINARY</code>:
492      * Converts a response payload from a Base64-encoded string to the corresponding
493      * binary blob.</p></li> <li><p><code>CONVERT_TO_TEXT</code>: Converts a response
494      * payload from a binary blob to a Base64-encoded string.</p></li> </ul> <p>If this
495      * property is not defined, the response payload will be passed through from the
496      * integration response to the method response without modification.</p>
497      */
WithContentHandling(const ContentHandlingStrategy & value)498     inline PutIntegrationResponseResult& WithContentHandling(const ContentHandlingStrategy& value) { SetContentHandling(value); return *this;}
499 
500     /**
501      * <p>Specifies how to handle response payload content type conversions. Supported
502      * values are <code>CONVERT_TO_BINARY</code> and <code>CONVERT_TO_TEXT</code>, with
503      * the following behaviors:</p> <ul> <li><p><code>CONVERT_TO_BINARY</code>:
504      * Converts a response payload from a Base64-encoded string to the corresponding
505      * binary blob.</p></li> <li><p><code>CONVERT_TO_TEXT</code>: Converts a response
506      * payload from a binary blob to a Base64-encoded string.</p></li> </ul> <p>If this
507      * property is not defined, the response payload will be passed through from the
508      * integration response to the method response without modification.</p>
509      */
WithContentHandling(ContentHandlingStrategy && value)510     inline PutIntegrationResponseResult& WithContentHandling(ContentHandlingStrategy&& value) { SetContentHandling(std::move(value)); return *this;}
511 
512   private:
513 
514     Aws::String m_statusCode;
515 
516     Aws::String m_selectionPattern;
517 
518     Aws::Map<Aws::String, Aws::String> m_responseParameters;
519 
520     Aws::Map<Aws::String, Aws::String> m_responseTemplates;
521 
522     ContentHandlingStrategy m_contentHandling;
523   };
524 
525 } // namespace Model
526 } // namespace APIGateway
527 } // namespace Aws
528