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