1// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
2
3package apigateway
4
5import (
6	"time"
7
8	"github.com/aws/aws-sdk-go/aws"
9	"github.com/aws/aws-sdk-go/aws/awsutil"
10	"github.com/aws/aws-sdk-go/aws/request"
11	"github.com/aws/aws-sdk-go/private/protocol"
12	"github.com/aws/aws-sdk-go/private/protocol/restjson"
13)
14
15const opCreateApiKey = "CreateApiKey"
16
17// CreateApiKeyRequest generates a "aws/request.Request" representing the
18// client's request for the CreateApiKey operation. The "output" return
19// value will be populated with the request's response once the request completes
20// successfully.
21//
22// Use "Send" method on the returned Request to send the API call to the service.
23// the "output" return value is not valid until after Send returns without error.
24//
25// See CreateApiKey for more information on using the CreateApiKey
26// API call, and error handling.
27//
28// This method is useful when you want to inject custom logic or configuration
29// into the SDK's request lifecycle. Such as custom headers, or retry logic.
30//
31//
32//    // Example sending a request using the CreateApiKeyRequest method.
33//    req, resp := client.CreateApiKeyRequest(params)
34//
35//    err := req.Send()
36//    if err == nil { // resp is now filled
37//        fmt.Println(resp)
38//    }
39func (c *APIGateway) CreateApiKeyRequest(input *CreateApiKeyInput) (req *request.Request, output *ApiKey) {
40	op := &request.Operation{
41		Name:       opCreateApiKey,
42		HTTPMethod: "POST",
43		HTTPPath:   "/apikeys",
44	}
45
46	if input == nil {
47		input = &CreateApiKeyInput{}
48	}
49
50	output = &ApiKey{}
51	req = c.newRequest(op, input, output)
52	return
53}
54
55// CreateApiKey API operation for Amazon API Gateway.
56//
57// Create an ApiKey resource.
58//
59// AWS CLI (https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-api-key.html)
60//
61// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
62// with awserr.Error's Code and Message methods to get detailed information about
63// the error.
64//
65// See the AWS API reference guide for Amazon API Gateway's
66// API operation CreateApiKey for usage and error information.
67//
68// Returned Error Codes:
69//   * ErrCodeUnauthorizedException "UnauthorizedException"
70//   The request is denied because the caller has insufficient permissions.
71//
72//   * ErrCodeNotFoundException "NotFoundException"
73//   The requested resource is not found. Make sure that the request URI is correct.
74//
75//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
76//   The request has reached its throttling limit. Retry after the specified time
77//   period.
78//
79//   * ErrCodeLimitExceededException "LimitExceededException"
80//   The request exceeded the rate limit. Retry after the specified time period.
81//
82//   * ErrCodeBadRequestException "BadRequestException"
83//   The submitted request is not valid, for example, the input is incomplete
84//   or incorrect. See the accompanying error message for details.
85//
86//   * ErrCodeConflictException "ConflictException"
87//   The request configuration has conflicts. For details, see the accompanying
88//   error message.
89//
90func (c *APIGateway) CreateApiKey(input *CreateApiKeyInput) (*ApiKey, error) {
91	req, out := c.CreateApiKeyRequest(input)
92	return out, req.Send()
93}
94
95// CreateApiKeyWithContext is the same as CreateApiKey with the addition of
96// the ability to pass a context and additional request options.
97//
98// See CreateApiKey for details on how to use this API operation.
99//
100// The context must be non-nil and will be used for request cancellation. If
101// the context is nil a panic will occur. In the future the SDK may create
102// sub-contexts for http.Requests. See https://golang.org/pkg/context/
103// for more information on using Contexts.
104func (c *APIGateway) CreateApiKeyWithContext(ctx aws.Context, input *CreateApiKeyInput, opts ...request.Option) (*ApiKey, error) {
105	req, out := c.CreateApiKeyRequest(input)
106	req.SetContext(ctx)
107	req.ApplyOptions(opts...)
108	return out, req.Send()
109}
110
111const opCreateAuthorizer = "CreateAuthorizer"
112
113// CreateAuthorizerRequest generates a "aws/request.Request" representing the
114// client's request for the CreateAuthorizer operation. The "output" return
115// value will be populated with the request's response once the request completes
116// successfully.
117//
118// Use "Send" method on the returned Request to send the API call to the service.
119// the "output" return value is not valid until after Send returns without error.
120//
121// See CreateAuthorizer for more information on using the CreateAuthorizer
122// API call, and error handling.
123//
124// This method is useful when you want to inject custom logic or configuration
125// into the SDK's request lifecycle. Such as custom headers, or retry logic.
126//
127//
128//    // Example sending a request using the CreateAuthorizerRequest method.
129//    req, resp := client.CreateAuthorizerRequest(params)
130//
131//    err := req.Send()
132//    if err == nil { // resp is now filled
133//        fmt.Println(resp)
134//    }
135func (c *APIGateway) CreateAuthorizerRequest(input *CreateAuthorizerInput) (req *request.Request, output *Authorizer) {
136	op := &request.Operation{
137		Name:       opCreateAuthorizer,
138		HTTPMethod: "POST",
139		HTTPPath:   "/restapis/{restapi_id}/authorizers",
140	}
141
142	if input == nil {
143		input = &CreateAuthorizerInput{}
144	}
145
146	output = &Authorizer{}
147	req = c.newRequest(op, input, output)
148	return
149}
150
151// CreateAuthorizer API operation for Amazon API Gateway.
152//
153// Adds a new Authorizer resource to an existing RestApi resource.
154//
155// AWS CLI (https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-authorizer.html)
156//
157// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
158// with awserr.Error's Code and Message methods to get detailed information about
159// the error.
160//
161// See the AWS API reference guide for Amazon API Gateway's
162// API operation CreateAuthorizer for usage and error information.
163//
164// Returned Error Codes:
165//   * ErrCodeBadRequestException "BadRequestException"
166//   The submitted request is not valid, for example, the input is incomplete
167//   or incorrect. See the accompanying error message for details.
168//
169//   * ErrCodeUnauthorizedException "UnauthorizedException"
170//   The request is denied because the caller has insufficient permissions.
171//
172//   * ErrCodeNotFoundException "NotFoundException"
173//   The requested resource is not found. Make sure that the request URI is correct.
174//
175//   * ErrCodeLimitExceededException "LimitExceededException"
176//   The request exceeded the rate limit. Retry after the specified time period.
177//
178//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
179//   The request has reached its throttling limit. Retry after the specified time
180//   period.
181//
182func (c *APIGateway) CreateAuthorizer(input *CreateAuthorizerInput) (*Authorizer, error) {
183	req, out := c.CreateAuthorizerRequest(input)
184	return out, req.Send()
185}
186
187// CreateAuthorizerWithContext is the same as CreateAuthorizer with the addition of
188// the ability to pass a context and additional request options.
189//
190// See CreateAuthorizer for details on how to use this API operation.
191//
192// The context must be non-nil and will be used for request cancellation. If
193// the context is nil a panic will occur. In the future the SDK may create
194// sub-contexts for http.Requests. See https://golang.org/pkg/context/
195// for more information on using Contexts.
196func (c *APIGateway) CreateAuthorizerWithContext(ctx aws.Context, input *CreateAuthorizerInput, opts ...request.Option) (*Authorizer, error) {
197	req, out := c.CreateAuthorizerRequest(input)
198	req.SetContext(ctx)
199	req.ApplyOptions(opts...)
200	return out, req.Send()
201}
202
203const opCreateBasePathMapping = "CreateBasePathMapping"
204
205// CreateBasePathMappingRequest generates a "aws/request.Request" representing the
206// client's request for the CreateBasePathMapping operation. The "output" return
207// value will be populated with the request's response once the request completes
208// successfully.
209//
210// Use "Send" method on the returned Request to send the API call to the service.
211// the "output" return value is not valid until after Send returns without error.
212//
213// See CreateBasePathMapping for more information on using the CreateBasePathMapping
214// API call, and error handling.
215//
216// This method is useful when you want to inject custom logic or configuration
217// into the SDK's request lifecycle. Such as custom headers, or retry logic.
218//
219//
220//    // Example sending a request using the CreateBasePathMappingRequest method.
221//    req, resp := client.CreateBasePathMappingRequest(params)
222//
223//    err := req.Send()
224//    if err == nil { // resp is now filled
225//        fmt.Println(resp)
226//    }
227func (c *APIGateway) CreateBasePathMappingRequest(input *CreateBasePathMappingInput) (req *request.Request, output *BasePathMapping) {
228	op := &request.Operation{
229		Name:       opCreateBasePathMapping,
230		HTTPMethod: "POST",
231		HTTPPath:   "/domainnames/{domain_name}/basepathmappings",
232	}
233
234	if input == nil {
235		input = &CreateBasePathMappingInput{}
236	}
237
238	output = &BasePathMapping{}
239	req = c.newRequest(op, input, output)
240	return
241}
242
243// CreateBasePathMapping API operation for Amazon API Gateway.
244//
245// Creates a new BasePathMapping resource.
246//
247// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
248// with awserr.Error's Code and Message methods to get detailed information about
249// the error.
250//
251// See the AWS API reference guide for Amazon API Gateway's
252// API operation CreateBasePathMapping for usage and error information.
253//
254// Returned Error Codes:
255//   * ErrCodeUnauthorizedException "UnauthorizedException"
256//   The request is denied because the caller has insufficient permissions.
257//
258//   * ErrCodeConflictException "ConflictException"
259//   The request configuration has conflicts. For details, see the accompanying
260//   error message.
261//
262//   * ErrCodeBadRequestException "BadRequestException"
263//   The submitted request is not valid, for example, the input is incomplete
264//   or incorrect. See the accompanying error message for details.
265//
266//   * ErrCodeNotFoundException "NotFoundException"
267//   The requested resource is not found. Make sure that the request URI is correct.
268//
269//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
270//   The request has reached its throttling limit. Retry after the specified time
271//   period.
272//
273func (c *APIGateway) CreateBasePathMapping(input *CreateBasePathMappingInput) (*BasePathMapping, error) {
274	req, out := c.CreateBasePathMappingRequest(input)
275	return out, req.Send()
276}
277
278// CreateBasePathMappingWithContext is the same as CreateBasePathMapping with the addition of
279// the ability to pass a context and additional request options.
280//
281// See CreateBasePathMapping for details on how to use this API operation.
282//
283// The context must be non-nil and will be used for request cancellation. If
284// the context is nil a panic will occur. In the future the SDK may create
285// sub-contexts for http.Requests. See https://golang.org/pkg/context/
286// for more information on using Contexts.
287func (c *APIGateway) CreateBasePathMappingWithContext(ctx aws.Context, input *CreateBasePathMappingInput, opts ...request.Option) (*BasePathMapping, error) {
288	req, out := c.CreateBasePathMappingRequest(input)
289	req.SetContext(ctx)
290	req.ApplyOptions(opts...)
291	return out, req.Send()
292}
293
294const opCreateDeployment = "CreateDeployment"
295
296// CreateDeploymentRequest generates a "aws/request.Request" representing the
297// client's request for the CreateDeployment operation. The "output" return
298// value will be populated with the request's response once the request completes
299// successfully.
300//
301// Use "Send" method on the returned Request to send the API call to the service.
302// the "output" return value is not valid until after Send returns without error.
303//
304// See CreateDeployment for more information on using the CreateDeployment
305// API call, and error handling.
306//
307// This method is useful when you want to inject custom logic or configuration
308// into the SDK's request lifecycle. Such as custom headers, or retry logic.
309//
310//
311//    // Example sending a request using the CreateDeploymentRequest method.
312//    req, resp := client.CreateDeploymentRequest(params)
313//
314//    err := req.Send()
315//    if err == nil { // resp is now filled
316//        fmt.Println(resp)
317//    }
318func (c *APIGateway) CreateDeploymentRequest(input *CreateDeploymentInput) (req *request.Request, output *Deployment) {
319	op := &request.Operation{
320		Name:       opCreateDeployment,
321		HTTPMethod: "POST",
322		HTTPPath:   "/restapis/{restapi_id}/deployments",
323	}
324
325	if input == nil {
326		input = &CreateDeploymentInput{}
327	}
328
329	output = &Deployment{}
330	req = c.newRequest(op, input, output)
331	return
332}
333
334// CreateDeployment API operation for Amazon API Gateway.
335//
336// Creates a Deployment resource, which makes a specified RestApi callable over
337// the internet.
338//
339// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
340// with awserr.Error's Code and Message methods to get detailed information about
341// the error.
342//
343// See the AWS API reference guide for Amazon API Gateway's
344// API operation CreateDeployment for usage and error information.
345//
346// Returned Error Codes:
347//   * ErrCodeUnauthorizedException "UnauthorizedException"
348//   The request is denied because the caller has insufficient permissions.
349//
350//   * ErrCodeBadRequestException "BadRequestException"
351//   The submitted request is not valid, for example, the input is incomplete
352//   or incorrect. See the accompanying error message for details.
353//
354//   * ErrCodeNotFoundException "NotFoundException"
355//   The requested resource is not found. Make sure that the request URI is correct.
356//
357//   * ErrCodeConflictException "ConflictException"
358//   The request configuration has conflicts. For details, see the accompanying
359//   error message.
360//
361//   * ErrCodeLimitExceededException "LimitExceededException"
362//   The request exceeded the rate limit. Retry after the specified time period.
363//
364//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
365//   The request has reached its throttling limit. Retry after the specified time
366//   period.
367//
368//   * ErrCodeServiceUnavailableException "ServiceUnavailableException"
369//   The requested service is not available. For details see the accompanying
370//   error message. Retry after the specified time period.
371//
372func (c *APIGateway) CreateDeployment(input *CreateDeploymentInput) (*Deployment, error) {
373	req, out := c.CreateDeploymentRequest(input)
374	return out, req.Send()
375}
376
377// CreateDeploymentWithContext is the same as CreateDeployment with the addition of
378// the ability to pass a context and additional request options.
379//
380// See CreateDeployment for details on how to use this API operation.
381//
382// The context must be non-nil and will be used for request cancellation. If
383// the context is nil a panic will occur. In the future the SDK may create
384// sub-contexts for http.Requests. See https://golang.org/pkg/context/
385// for more information on using Contexts.
386func (c *APIGateway) CreateDeploymentWithContext(ctx aws.Context, input *CreateDeploymentInput, opts ...request.Option) (*Deployment, error) {
387	req, out := c.CreateDeploymentRequest(input)
388	req.SetContext(ctx)
389	req.ApplyOptions(opts...)
390	return out, req.Send()
391}
392
393const opCreateDocumentationPart = "CreateDocumentationPart"
394
395// CreateDocumentationPartRequest generates a "aws/request.Request" representing the
396// client's request for the CreateDocumentationPart operation. The "output" return
397// value will be populated with the request's response once the request completes
398// successfully.
399//
400// Use "Send" method on the returned Request to send the API call to the service.
401// the "output" return value is not valid until after Send returns without error.
402//
403// See CreateDocumentationPart for more information on using the CreateDocumentationPart
404// API call, and error handling.
405//
406// This method is useful when you want to inject custom logic or configuration
407// into the SDK's request lifecycle. Such as custom headers, or retry logic.
408//
409//
410//    // Example sending a request using the CreateDocumentationPartRequest method.
411//    req, resp := client.CreateDocumentationPartRequest(params)
412//
413//    err := req.Send()
414//    if err == nil { // resp is now filled
415//        fmt.Println(resp)
416//    }
417func (c *APIGateway) CreateDocumentationPartRequest(input *CreateDocumentationPartInput) (req *request.Request, output *DocumentationPart) {
418	op := &request.Operation{
419		Name:       opCreateDocumentationPart,
420		HTTPMethod: "POST",
421		HTTPPath:   "/restapis/{restapi_id}/documentation/parts",
422	}
423
424	if input == nil {
425		input = &CreateDocumentationPartInput{}
426	}
427
428	output = &DocumentationPart{}
429	req = c.newRequest(op, input, output)
430	return
431}
432
433// CreateDocumentationPart API operation for Amazon API Gateway.
434//
435// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
436// with awserr.Error's Code and Message methods to get detailed information about
437// the error.
438//
439// See the AWS API reference guide for Amazon API Gateway's
440// API operation CreateDocumentationPart for usage and error information.
441//
442// Returned Error Codes:
443//   * ErrCodeBadRequestException "BadRequestException"
444//   The submitted request is not valid, for example, the input is incomplete
445//   or incorrect. See the accompanying error message for details.
446//
447//   * ErrCodeConflictException "ConflictException"
448//   The request configuration has conflicts. For details, see the accompanying
449//   error message.
450//
451//   * ErrCodeUnauthorizedException "UnauthorizedException"
452//   The request is denied because the caller has insufficient permissions.
453//
454//   * ErrCodeNotFoundException "NotFoundException"
455//   The requested resource is not found. Make sure that the request URI is correct.
456//
457//   * ErrCodeLimitExceededException "LimitExceededException"
458//   The request exceeded the rate limit. Retry after the specified time period.
459//
460//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
461//   The request has reached its throttling limit. Retry after the specified time
462//   period.
463//
464func (c *APIGateway) CreateDocumentationPart(input *CreateDocumentationPartInput) (*DocumentationPart, error) {
465	req, out := c.CreateDocumentationPartRequest(input)
466	return out, req.Send()
467}
468
469// CreateDocumentationPartWithContext is the same as CreateDocumentationPart with the addition of
470// the ability to pass a context and additional request options.
471//
472// See CreateDocumentationPart for details on how to use this API operation.
473//
474// The context must be non-nil and will be used for request cancellation. If
475// the context is nil a panic will occur. In the future the SDK may create
476// sub-contexts for http.Requests. See https://golang.org/pkg/context/
477// for more information on using Contexts.
478func (c *APIGateway) CreateDocumentationPartWithContext(ctx aws.Context, input *CreateDocumentationPartInput, opts ...request.Option) (*DocumentationPart, error) {
479	req, out := c.CreateDocumentationPartRequest(input)
480	req.SetContext(ctx)
481	req.ApplyOptions(opts...)
482	return out, req.Send()
483}
484
485const opCreateDocumentationVersion = "CreateDocumentationVersion"
486
487// CreateDocumentationVersionRequest generates a "aws/request.Request" representing the
488// client's request for the CreateDocumentationVersion operation. The "output" return
489// value will be populated with the request's response once the request completes
490// successfully.
491//
492// Use "Send" method on the returned Request to send the API call to the service.
493// the "output" return value is not valid until after Send returns without error.
494//
495// See CreateDocumentationVersion for more information on using the CreateDocumentationVersion
496// API call, and error handling.
497//
498// This method is useful when you want to inject custom logic or configuration
499// into the SDK's request lifecycle. Such as custom headers, or retry logic.
500//
501//
502//    // Example sending a request using the CreateDocumentationVersionRequest method.
503//    req, resp := client.CreateDocumentationVersionRequest(params)
504//
505//    err := req.Send()
506//    if err == nil { // resp is now filled
507//        fmt.Println(resp)
508//    }
509func (c *APIGateway) CreateDocumentationVersionRequest(input *CreateDocumentationVersionInput) (req *request.Request, output *DocumentationVersion) {
510	op := &request.Operation{
511		Name:       opCreateDocumentationVersion,
512		HTTPMethod: "POST",
513		HTTPPath:   "/restapis/{restapi_id}/documentation/versions",
514	}
515
516	if input == nil {
517		input = &CreateDocumentationVersionInput{}
518	}
519
520	output = &DocumentationVersion{}
521	req = c.newRequest(op, input, output)
522	return
523}
524
525// CreateDocumentationVersion API operation for Amazon API Gateway.
526//
527// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
528// with awserr.Error's Code and Message methods to get detailed information about
529// the error.
530//
531// See the AWS API reference guide for Amazon API Gateway's
532// API operation CreateDocumentationVersion for usage and error information.
533//
534// Returned Error Codes:
535//   * ErrCodeBadRequestException "BadRequestException"
536//   The submitted request is not valid, for example, the input is incomplete
537//   or incorrect. See the accompanying error message for details.
538//
539//   * ErrCodeConflictException "ConflictException"
540//   The request configuration has conflicts. For details, see the accompanying
541//   error message.
542//
543//   * ErrCodeUnauthorizedException "UnauthorizedException"
544//   The request is denied because the caller has insufficient permissions.
545//
546//   * ErrCodeNotFoundException "NotFoundException"
547//   The requested resource is not found. Make sure that the request URI is correct.
548//
549//   * ErrCodeLimitExceededException "LimitExceededException"
550//   The request exceeded the rate limit. Retry after the specified time period.
551//
552//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
553//   The request has reached its throttling limit. Retry after the specified time
554//   period.
555//
556func (c *APIGateway) CreateDocumentationVersion(input *CreateDocumentationVersionInput) (*DocumentationVersion, error) {
557	req, out := c.CreateDocumentationVersionRequest(input)
558	return out, req.Send()
559}
560
561// CreateDocumentationVersionWithContext is the same as CreateDocumentationVersion with the addition of
562// the ability to pass a context and additional request options.
563//
564// See CreateDocumentationVersion for details on how to use this API operation.
565//
566// The context must be non-nil and will be used for request cancellation. If
567// the context is nil a panic will occur. In the future the SDK may create
568// sub-contexts for http.Requests. See https://golang.org/pkg/context/
569// for more information on using Contexts.
570func (c *APIGateway) CreateDocumentationVersionWithContext(ctx aws.Context, input *CreateDocumentationVersionInput, opts ...request.Option) (*DocumentationVersion, error) {
571	req, out := c.CreateDocumentationVersionRequest(input)
572	req.SetContext(ctx)
573	req.ApplyOptions(opts...)
574	return out, req.Send()
575}
576
577const opCreateDomainName = "CreateDomainName"
578
579// CreateDomainNameRequest generates a "aws/request.Request" representing the
580// client's request for the CreateDomainName operation. The "output" return
581// value will be populated with the request's response once the request completes
582// successfully.
583//
584// Use "Send" method on the returned Request to send the API call to the service.
585// the "output" return value is not valid until after Send returns without error.
586//
587// See CreateDomainName for more information on using the CreateDomainName
588// API call, and error handling.
589//
590// This method is useful when you want to inject custom logic or configuration
591// into the SDK's request lifecycle. Such as custom headers, or retry logic.
592//
593//
594//    // Example sending a request using the CreateDomainNameRequest method.
595//    req, resp := client.CreateDomainNameRequest(params)
596//
597//    err := req.Send()
598//    if err == nil { // resp is now filled
599//        fmt.Println(resp)
600//    }
601func (c *APIGateway) CreateDomainNameRequest(input *CreateDomainNameInput) (req *request.Request, output *DomainName) {
602	op := &request.Operation{
603		Name:       opCreateDomainName,
604		HTTPMethod: "POST",
605		HTTPPath:   "/domainnames",
606	}
607
608	if input == nil {
609		input = &CreateDomainNameInput{}
610	}
611
612	output = &DomainName{}
613	req = c.newRequest(op, input, output)
614	return
615}
616
617// CreateDomainName API operation for Amazon API Gateway.
618//
619// Creates a new domain name.
620//
621// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
622// with awserr.Error's Code and Message methods to get detailed information about
623// the error.
624//
625// See the AWS API reference guide for Amazon API Gateway's
626// API operation CreateDomainName for usage and error information.
627//
628// Returned Error Codes:
629//   * ErrCodeUnauthorizedException "UnauthorizedException"
630//   The request is denied because the caller has insufficient permissions.
631//
632//   * ErrCodeBadRequestException "BadRequestException"
633//   The submitted request is not valid, for example, the input is incomplete
634//   or incorrect. See the accompanying error message for details.
635//
636//   * ErrCodeConflictException "ConflictException"
637//   The request configuration has conflicts. For details, see the accompanying
638//   error message.
639//
640//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
641//   The request has reached its throttling limit. Retry after the specified time
642//   period.
643//
644func (c *APIGateway) CreateDomainName(input *CreateDomainNameInput) (*DomainName, error) {
645	req, out := c.CreateDomainNameRequest(input)
646	return out, req.Send()
647}
648
649// CreateDomainNameWithContext is the same as CreateDomainName with the addition of
650// the ability to pass a context and additional request options.
651//
652// See CreateDomainName for details on how to use this API operation.
653//
654// The context must be non-nil and will be used for request cancellation. If
655// the context is nil a panic will occur. In the future the SDK may create
656// sub-contexts for http.Requests. See https://golang.org/pkg/context/
657// for more information on using Contexts.
658func (c *APIGateway) CreateDomainNameWithContext(ctx aws.Context, input *CreateDomainNameInput, opts ...request.Option) (*DomainName, error) {
659	req, out := c.CreateDomainNameRequest(input)
660	req.SetContext(ctx)
661	req.ApplyOptions(opts...)
662	return out, req.Send()
663}
664
665const opCreateModel = "CreateModel"
666
667// CreateModelRequest generates a "aws/request.Request" representing the
668// client's request for the CreateModel operation. The "output" return
669// value will be populated with the request's response once the request completes
670// successfully.
671//
672// Use "Send" method on the returned Request to send the API call to the service.
673// the "output" return value is not valid until after Send returns without error.
674//
675// See CreateModel for more information on using the CreateModel
676// API call, and error handling.
677//
678// This method is useful when you want to inject custom logic or configuration
679// into the SDK's request lifecycle. Such as custom headers, or retry logic.
680//
681//
682//    // Example sending a request using the CreateModelRequest method.
683//    req, resp := client.CreateModelRequest(params)
684//
685//    err := req.Send()
686//    if err == nil { // resp is now filled
687//        fmt.Println(resp)
688//    }
689func (c *APIGateway) CreateModelRequest(input *CreateModelInput) (req *request.Request, output *Model) {
690	op := &request.Operation{
691		Name:       opCreateModel,
692		HTTPMethod: "POST",
693		HTTPPath:   "/restapis/{restapi_id}/models",
694	}
695
696	if input == nil {
697		input = &CreateModelInput{}
698	}
699
700	output = &Model{}
701	req = c.newRequest(op, input, output)
702	return
703}
704
705// CreateModel API operation for Amazon API Gateway.
706//
707// Adds a new Model resource to an existing RestApi resource.
708//
709// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
710// with awserr.Error's Code and Message methods to get detailed information about
711// the error.
712//
713// See the AWS API reference guide for Amazon API Gateway's
714// API operation CreateModel for usage and error information.
715//
716// Returned Error Codes:
717//   * ErrCodeBadRequestException "BadRequestException"
718//   The submitted request is not valid, for example, the input is incomplete
719//   or incorrect. See the accompanying error message for details.
720//
721//   * ErrCodeUnauthorizedException "UnauthorizedException"
722//   The request is denied because the caller has insufficient permissions.
723//
724//   * ErrCodeNotFoundException "NotFoundException"
725//   The requested resource is not found. Make sure that the request URI is correct.
726//
727//   * ErrCodeConflictException "ConflictException"
728//   The request configuration has conflicts. For details, see the accompanying
729//   error message.
730//
731//   * ErrCodeLimitExceededException "LimitExceededException"
732//   The request exceeded the rate limit. Retry after the specified time period.
733//
734//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
735//   The request has reached its throttling limit. Retry after the specified time
736//   period.
737//
738func (c *APIGateway) CreateModel(input *CreateModelInput) (*Model, error) {
739	req, out := c.CreateModelRequest(input)
740	return out, req.Send()
741}
742
743// CreateModelWithContext is the same as CreateModel with the addition of
744// the ability to pass a context and additional request options.
745//
746// See CreateModel for details on how to use this API operation.
747//
748// The context must be non-nil and will be used for request cancellation. If
749// the context is nil a panic will occur. In the future the SDK may create
750// sub-contexts for http.Requests. See https://golang.org/pkg/context/
751// for more information on using Contexts.
752func (c *APIGateway) CreateModelWithContext(ctx aws.Context, input *CreateModelInput, opts ...request.Option) (*Model, error) {
753	req, out := c.CreateModelRequest(input)
754	req.SetContext(ctx)
755	req.ApplyOptions(opts...)
756	return out, req.Send()
757}
758
759const opCreateRequestValidator = "CreateRequestValidator"
760
761// CreateRequestValidatorRequest generates a "aws/request.Request" representing the
762// client's request for the CreateRequestValidator operation. The "output" return
763// value will be populated with the request's response once the request completes
764// successfully.
765//
766// Use "Send" method on the returned Request to send the API call to the service.
767// the "output" return value is not valid until after Send returns without error.
768//
769// See CreateRequestValidator for more information on using the CreateRequestValidator
770// API call, and error handling.
771//
772// This method is useful when you want to inject custom logic or configuration
773// into the SDK's request lifecycle. Such as custom headers, or retry logic.
774//
775//
776//    // Example sending a request using the CreateRequestValidatorRequest method.
777//    req, resp := client.CreateRequestValidatorRequest(params)
778//
779//    err := req.Send()
780//    if err == nil { // resp is now filled
781//        fmt.Println(resp)
782//    }
783func (c *APIGateway) CreateRequestValidatorRequest(input *CreateRequestValidatorInput) (req *request.Request, output *UpdateRequestValidatorOutput) {
784	op := &request.Operation{
785		Name:       opCreateRequestValidator,
786		HTTPMethod: "POST",
787		HTTPPath:   "/restapis/{restapi_id}/requestvalidators",
788	}
789
790	if input == nil {
791		input = &CreateRequestValidatorInput{}
792	}
793
794	output = &UpdateRequestValidatorOutput{}
795	req = c.newRequest(op, input, output)
796	return
797}
798
799// CreateRequestValidator API operation for Amazon API Gateway.
800//
801// Creates a ReqeustValidator of a given RestApi.
802//
803// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
804// with awserr.Error's Code and Message methods to get detailed information about
805// the error.
806//
807// See the AWS API reference guide for Amazon API Gateway's
808// API operation CreateRequestValidator for usage and error information.
809//
810// Returned Error Codes:
811//   * ErrCodeBadRequestException "BadRequestException"
812//   The submitted request is not valid, for example, the input is incomplete
813//   or incorrect. See the accompanying error message for details.
814//
815//   * ErrCodeUnauthorizedException "UnauthorizedException"
816//   The request is denied because the caller has insufficient permissions.
817//
818//   * ErrCodeNotFoundException "NotFoundException"
819//   The requested resource is not found. Make sure that the request URI is correct.
820//
821//   * ErrCodeLimitExceededException "LimitExceededException"
822//   The request exceeded the rate limit. Retry after the specified time period.
823//
824//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
825//   The request has reached its throttling limit. Retry after the specified time
826//   period.
827//
828func (c *APIGateway) CreateRequestValidator(input *CreateRequestValidatorInput) (*UpdateRequestValidatorOutput, error) {
829	req, out := c.CreateRequestValidatorRequest(input)
830	return out, req.Send()
831}
832
833// CreateRequestValidatorWithContext is the same as CreateRequestValidator with the addition of
834// the ability to pass a context and additional request options.
835//
836// See CreateRequestValidator for details on how to use this API operation.
837//
838// The context must be non-nil and will be used for request cancellation. If
839// the context is nil a panic will occur. In the future the SDK may create
840// sub-contexts for http.Requests. See https://golang.org/pkg/context/
841// for more information on using Contexts.
842func (c *APIGateway) CreateRequestValidatorWithContext(ctx aws.Context, input *CreateRequestValidatorInput, opts ...request.Option) (*UpdateRequestValidatorOutput, error) {
843	req, out := c.CreateRequestValidatorRequest(input)
844	req.SetContext(ctx)
845	req.ApplyOptions(opts...)
846	return out, req.Send()
847}
848
849const opCreateResource = "CreateResource"
850
851// CreateResourceRequest generates a "aws/request.Request" representing the
852// client's request for the CreateResource operation. The "output" return
853// value will be populated with the request's response once the request completes
854// successfully.
855//
856// Use "Send" method on the returned Request to send the API call to the service.
857// the "output" return value is not valid until after Send returns without error.
858//
859// See CreateResource for more information on using the CreateResource
860// API call, and error handling.
861//
862// This method is useful when you want to inject custom logic or configuration
863// into the SDK's request lifecycle. Such as custom headers, or retry logic.
864//
865//
866//    // Example sending a request using the CreateResourceRequest method.
867//    req, resp := client.CreateResourceRequest(params)
868//
869//    err := req.Send()
870//    if err == nil { // resp is now filled
871//        fmt.Println(resp)
872//    }
873func (c *APIGateway) CreateResourceRequest(input *CreateResourceInput) (req *request.Request, output *Resource) {
874	op := &request.Operation{
875		Name:       opCreateResource,
876		HTTPMethod: "POST",
877		HTTPPath:   "/restapis/{restapi_id}/resources/{parent_id}",
878	}
879
880	if input == nil {
881		input = &CreateResourceInput{}
882	}
883
884	output = &Resource{}
885	req = c.newRequest(op, input, output)
886	return
887}
888
889// CreateResource API operation for Amazon API Gateway.
890//
891// Creates a Resource resource.
892//
893// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
894// with awserr.Error's Code and Message methods to get detailed information about
895// the error.
896//
897// See the AWS API reference guide for Amazon API Gateway's
898// API operation CreateResource for usage and error information.
899//
900// Returned Error Codes:
901//   * ErrCodeUnauthorizedException "UnauthorizedException"
902//   The request is denied because the caller has insufficient permissions.
903//
904//   * ErrCodeNotFoundException "NotFoundException"
905//   The requested resource is not found. Make sure that the request URI is correct.
906//
907//   * ErrCodeConflictException "ConflictException"
908//   The request configuration has conflicts. For details, see the accompanying
909//   error message.
910//
911//   * ErrCodeLimitExceededException "LimitExceededException"
912//   The request exceeded the rate limit. Retry after the specified time period.
913//
914//   * ErrCodeBadRequestException "BadRequestException"
915//   The submitted request is not valid, for example, the input is incomplete
916//   or incorrect. See the accompanying error message for details.
917//
918//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
919//   The request has reached its throttling limit. Retry after the specified time
920//   period.
921//
922func (c *APIGateway) CreateResource(input *CreateResourceInput) (*Resource, error) {
923	req, out := c.CreateResourceRequest(input)
924	return out, req.Send()
925}
926
927// CreateResourceWithContext is the same as CreateResource with the addition of
928// the ability to pass a context and additional request options.
929//
930// See CreateResource for details on how to use this API operation.
931//
932// The context must be non-nil and will be used for request cancellation. If
933// the context is nil a panic will occur. In the future the SDK may create
934// sub-contexts for http.Requests. See https://golang.org/pkg/context/
935// for more information on using Contexts.
936func (c *APIGateway) CreateResourceWithContext(ctx aws.Context, input *CreateResourceInput, opts ...request.Option) (*Resource, error) {
937	req, out := c.CreateResourceRequest(input)
938	req.SetContext(ctx)
939	req.ApplyOptions(opts...)
940	return out, req.Send()
941}
942
943const opCreateRestApi = "CreateRestApi"
944
945// CreateRestApiRequest generates a "aws/request.Request" representing the
946// client's request for the CreateRestApi operation. The "output" return
947// value will be populated with the request's response once the request completes
948// successfully.
949//
950// Use "Send" method on the returned Request to send the API call to the service.
951// the "output" return value is not valid until after Send returns without error.
952//
953// See CreateRestApi for more information on using the CreateRestApi
954// API call, and error handling.
955//
956// This method is useful when you want to inject custom logic or configuration
957// into the SDK's request lifecycle. Such as custom headers, or retry logic.
958//
959//
960//    // Example sending a request using the CreateRestApiRequest method.
961//    req, resp := client.CreateRestApiRequest(params)
962//
963//    err := req.Send()
964//    if err == nil { // resp is now filled
965//        fmt.Println(resp)
966//    }
967func (c *APIGateway) CreateRestApiRequest(input *CreateRestApiInput) (req *request.Request, output *RestApi) {
968	op := &request.Operation{
969		Name:       opCreateRestApi,
970		HTTPMethod: "POST",
971		HTTPPath:   "/restapis",
972	}
973
974	if input == nil {
975		input = &CreateRestApiInput{}
976	}
977
978	output = &RestApi{}
979	req = c.newRequest(op, input, output)
980	return
981}
982
983// CreateRestApi API operation for Amazon API Gateway.
984//
985// Creates a new RestApi resource.
986//
987// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
988// with awserr.Error's Code and Message methods to get detailed information about
989// the error.
990//
991// See the AWS API reference guide for Amazon API Gateway's
992// API operation CreateRestApi for usage and error information.
993//
994// Returned Error Codes:
995//   * ErrCodeUnauthorizedException "UnauthorizedException"
996//   The request is denied because the caller has insufficient permissions.
997//
998//   * ErrCodeLimitExceededException "LimitExceededException"
999//   The request exceeded the rate limit. Retry after the specified time period.
1000//
1001//   * ErrCodeBadRequestException "BadRequestException"
1002//   The submitted request is not valid, for example, the input is incomplete
1003//   or incorrect. See the accompanying error message for details.
1004//
1005//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1006//   The request has reached its throttling limit. Retry after the specified time
1007//   period.
1008//
1009func (c *APIGateway) CreateRestApi(input *CreateRestApiInput) (*RestApi, error) {
1010	req, out := c.CreateRestApiRequest(input)
1011	return out, req.Send()
1012}
1013
1014// CreateRestApiWithContext is the same as CreateRestApi with the addition of
1015// the ability to pass a context and additional request options.
1016//
1017// See CreateRestApi for details on how to use this API operation.
1018//
1019// The context must be non-nil and will be used for request cancellation. If
1020// the context is nil a panic will occur. In the future the SDK may create
1021// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1022// for more information on using Contexts.
1023func (c *APIGateway) CreateRestApiWithContext(ctx aws.Context, input *CreateRestApiInput, opts ...request.Option) (*RestApi, error) {
1024	req, out := c.CreateRestApiRequest(input)
1025	req.SetContext(ctx)
1026	req.ApplyOptions(opts...)
1027	return out, req.Send()
1028}
1029
1030const opCreateStage = "CreateStage"
1031
1032// CreateStageRequest generates a "aws/request.Request" representing the
1033// client's request for the CreateStage operation. The "output" return
1034// value will be populated with the request's response once the request completes
1035// successfully.
1036//
1037// Use "Send" method on the returned Request to send the API call to the service.
1038// the "output" return value is not valid until after Send returns without error.
1039//
1040// See CreateStage for more information on using the CreateStage
1041// API call, and error handling.
1042//
1043// This method is useful when you want to inject custom logic or configuration
1044// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1045//
1046//
1047//    // Example sending a request using the CreateStageRequest method.
1048//    req, resp := client.CreateStageRequest(params)
1049//
1050//    err := req.Send()
1051//    if err == nil { // resp is now filled
1052//        fmt.Println(resp)
1053//    }
1054func (c *APIGateway) CreateStageRequest(input *CreateStageInput) (req *request.Request, output *Stage) {
1055	op := &request.Operation{
1056		Name:       opCreateStage,
1057		HTTPMethod: "POST",
1058		HTTPPath:   "/restapis/{restapi_id}/stages",
1059	}
1060
1061	if input == nil {
1062		input = &CreateStageInput{}
1063	}
1064
1065	output = &Stage{}
1066	req = c.newRequest(op, input, output)
1067	return
1068}
1069
1070// CreateStage API operation for Amazon API Gateway.
1071//
1072// Creates a new Stage resource that references a pre-existing Deployment for
1073// the API.
1074//
1075// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1076// with awserr.Error's Code and Message methods to get detailed information about
1077// the error.
1078//
1079// See the AWS API reference guide for Amazon API Gateway's
1080// API operation CreateStage for usage and error information.
1081//
1082// Returned Error Codes:
1083//   * ErrCodeUnauthorizedException "UnauthorizedException"
1084//   The request is denied because the caller has insufficient permissions.
1085//
1086//   * ErrCodeBadRequestException "BadRequestException"
1087//   The submitted request is not valid, for example, the input is incomplete
1088//   or incorrect. See the accompanying error message for details.
1089//
1090//   * ErrCodeNotFoundException "NotFoundException"
1091//   The requested resource is not found. Make sure that the request URI is correct.
1092//
1093//   * ErrCodeConflictException "ConflictException"
1094//   The request configuration has conflicts. For details, see the accompanying
1095//   error message.
1096//
1097//   * ErrCodeLimitExceededException "LimitExceededException"
1098//   The request exceeded the rate limit. Retry after the specified time period.
1099//
1100//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1101//   The request has reached its throttling limit. Retry after the specified time
1102//   period.
1103//
1104func (c *APIGateway) CreateStage(input *CreateStageInput) (*Stage, error) {
1105	req, out := c.CreateStageRequest(input)
1106	return out, req.Send()
1107}
1108
1109// CreateStageWithContext is the same as CreateStage with the addition of
1110// the ability to pass a context and additional request options.
1111//
1112// See CreateStage for details on how to use this API operation.
1113//
1114// The context must be non-nil and will be used for request cancellation. If
1115// the context is nil a panic will occur. In the future the SDK may create
1116// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1117// for more information on using Contexts.
1118func (c *APIGateway) CreateStageWithContext(ctx aws.Context, input *CreateStageInput, opts ...request.Option) (*Stage, error) {
1119	req, out := c.CreateStageRequest(input)
1120	req.SetContext(ctx)
1121	req.ApplyOptions(opts...)
1122	return out, req.Send()
1123}
1124
1125const opCreateUsagePlan = "CreateUsagePlan"
1126
1127// CreateUsagePlanRequest generates a "aws/request.Request" representing the
1128// client's request for the CreateUsagePlan operation. The "output" return
1129// value will be populated with the request's response once the request completes
1130// successfully.
1131//
1132// Use "Send" method on the returned Request to send the API call to the service.
1133// the "output" return value is not valid until after Send returns without error.
1134//
1135// See CreateUsagePlan for more information on using the CreateUsagePlan
1136// API call, and error handling.
1137//
1138// This method is useful when you want to inject custom logic or configuration
1139// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1140//
1141//
1142//    // Example sending a request using the CreateUsagePlanRequest method.
1143//    req, resp := client.CreateUsagePlanRequest(params)
1144//
1145//    err := req.Send()
1146//    if err == nil { // resp is now filled
1147//        fmt.Println(resp)
1148//    }
1149func (c *APIGateway) CreateUsagePlanRequest(input *CreateUsagePlanInput) (req *request.Request, output *UsagePlan) {
1150	op := &request.Operation{
1151		Name:       opCreateUsagePlan,
1152		HTTPMethod: "POST",
1153		HTTPPath:   "/usageplans",
1154	}
1155
1156	if input == nil {
1157		input = &CreateUsagePlanInput{}
1158	}
1159
1160	output = &UsagePlan{}
1161	req = c.newRequest(op, input, output)
1162	return
1163}
1164
1165// CreateUsagePlan API operation for Amazon API Gateway.
1166//
1167// Creates a usage plan with the throttle and quota limits, as well as the associated
1168// API stages, specified in the payload.
1169//
1170// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1171// with awserr.Error's Code and Message methods to get detailed information about
1172// the error.
1173//
1174// See the AWS API reference guide for Amazon API Gateway's
1175// API operation CreateUsagePlan for usage and error information.
1176//
1177// Returned Error Codes:
1178//   * ErrCodeBadRequestException "BadRequestException"
1179//   The submitted request is not valid, for example, the input is incomplete
1180//   or incorrect. See the accompanying error message for details.
1181//
1182//   * ErrCodeUnauthorizedException "UnauthorizedException"
1183//   The request is denied because the caller has insufficient permissions.
1184//
1185//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1186//   The request has reached its throttling limit. Retry after the specified time
1187//   period.
1188//
1189//   * ErrCodeLimitExceededException "LimitExceededException"
1190//   The request exceeded the rate limit. Retry after the specified time period.
1191//
1192//   * ErrCodeConflictException "ConflictException"
1193//   The request configuration has conflicts. For details, see the accompanying
1194//   error message.
1195//
1196//   * ErrCodeNotFoundException "NotFoundException"
1197//   The requested resource is not found. Make sure that the request URI is correct.
1198//
1199func (c *APIGateway) CreateUsagePlan(input *CreateUsagePlanInput) (*UsagePlan, error) {
1200	req, out := c.CreateUsagePlanRequest(input)
1201	return out, req.Send()
1202}
1203
1204// CreateUsagePlanWithContext is the same as CreateUsagePlan with the addition of
1205// the ability to pass a context and additional request options.
1206//
1207// See CreateUsagePlan for details on how to use this API operation.
1208//
1209// The context must be non-nil and will be used for request cancellation. If
1210// the context is nil a panic will occur. In the future the SDK may create
1211// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1212// for more information on using Contexts.
1213func (c *APIGateway) CreateUsagePlanWithContext(ctx aws.Context, input *CreateUsagePlanInput, opts ...request.Option) (*UsagePlan, error) {
1214	req, out := c.CreateUsagePlanRequest(input)
1215	req.SetContext(ctx)
1216	req.ApplyOptions(opts...)
1217	return out, req.Send()
1218}
1219
1220const opCreateUsagePlanKey = "CreateUsagePlanKey"
1221
1222// CreateUsagePlanKeyRequest generates a "aws/request.Request" representing the
1223// client's request for the CreateUsagePlanKey operation. The "output" return
1224// value will be populated with the request's response once the request completes
1225// successfully.
1226//
1227// Use "Send" method on the returned Request to send the API call to the service.
1228// the "output" return value is not valid until after Send returns without error.
1229//
1230// See CreateUsagePlanKey for more information on using the CreateUsagePlanKey
1231// API call, and error handling.
1232//
1233// This method is useful when you want to inject custom logic or configuration
1234// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1235//
1236//
1237//    // Example sending a request using the CreateUsagePlanKeyRequest method.
1238//    req, resp := client.CreateUsagePlanKeyRequest(params)
1239//
1240//    err := req.Send()
1241//    if err == nil { // resp is now filled
1242//        fmt.Println(resp)
1243//    }
1244func (c *APIGateway) CreateUsagePlanKeyRequest(input *CreateUsagePlanKeyInput) (req *request.Request, output *UsagePlanKey) {
1245	op := &request.Operation{
1246		Name:       opCreateUsagePlanKey,
1247		HTTPMethod: "POST",
1248		HTTPPath:   "/usageplans/{usageplanId}/keys",
1249	}
1250
1251	if input == nil {
1252		input = &CreateUsagePlanKeyInput{}
1253	}
1254
1255	output = &UsagePlanKey{}
1256	req = c.newRequest(op, input, output)
1257	return
1258}
1259
1260// CreateUsagePlanKey API operation for Amazon API Gateway.
1261//
1262// Creates a usage plan key for adding an existing API key to a usage plan.
1263//
1264// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1265// with awserr.Error's Code and Message methods to get detailed information about
1266// the error.
1267//
1268// See the AWS API reference guide for Amazon API Gateway's
1269// API operation CreateUsagePlanKey for usage and error information.
1270//
1271// Returned Error Codes:
1272//   * ErrCodeBadRequestException "BadRequestException"
1273//   The submitted request is not valid, for example, the input is incomplete
1274//   or incorrect. See the accompanying error message for details.
1275//
1276//   * ErrCodeConflictException "ConflictException"
1277//   The request configuration has conflicts. For details, see the accompanying
1278//   error message.
1279//
1280//   * ErrCodeUnauthorizedException "UnauthorizedException"
1281//   The request is denied because the caller has insufficient permissions.
1282//
1283//   * ErrCodeNotFoundException "NotFoundException"
1284//   The requested resource is not found. Make sure that the request URI is correct.
1285//
1286//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1287//   The request has reached its throttling limit. Retry after the specified time
1288//   period.
1289//
1290func (c *APIGateway) CreateUsagePlanKey(input *CreateUsagePlanKeyInput) (*UsagePlanKey, error) {
1291	req, out := c.CreateUsagePlanKeyRequest(input)
1292	return out, req.Send()
1293}
1294
1295// CreateUsagePlanKeyWithContext is the same as CreateUsagePlanKey with the addition of
1296// the ability to pass a context and additional request options.
1297//
1298// See CreateUsagePlanKey for details on how to use this API operation.
1299//
1300// The context must be non-nil and will be used for request cancellation. If
1301// the context is nil a panic will occur. In the future the SDK may create
1302// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1303// for more information on using Contexts.
1304func (c *APIGateway) CreateUsagePlanKeyWithContext(ctx aws.Context, input *CreateUsagePlanKeyInput, opts ...request.Option) (*UsagePlanKey, error) {
1305	req, out := c.CreateUsagePlanKeyRequest(input)
1306	req.SetContext(ctx)
1307	req.ApplyOptions(opts...)
1308	return out, req.Send()
1309}
1310
1311const opCreateVpcLink = "CreateVpcLink"
1312
1313// CreateVpcLinkRequest generates a "aws/request.Request" representing the
1314// client's request for the CreateVpcLink operation. The "output" return
1315// value will be populated with the request's response once the request completes
1316// successfully.
1317//
1318// Use "Send" method on the returned Request to send the API call to the service.
1319// the "output" return value is not valid until after Send returns without error.
1320//
1321// See CreateVpcLink for more information on using the CreateVpcLink
1322// API call, and error handling.
1323//
1324// This method is useful when you want to inject custom logic or configuration
1325// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1326//
1327//
1328//    // Example sending a request using the CreateVpcLinkRequest method.
1329//    req, resp := client.CreateVpcLinkRequest(params)
1330//
1331//    err := req.Send()
1332//    if err == nil { // resp is now filled
1333//        fmt.Println(resp)
1334//    }
1335func (c *APIGateway) CreateVpcLinkRequest(input *CreateVpcLinkInput) (req *request.Request, output *UpdateVpcLinkOutput) {
1336	op := &request.Operation{
1337		Name:       opCreateVpcLink,
1338		HTTPMethod: "POST",
1339		HTTPPath:   "/vpclinks",
1340	}
1341
1342	if input == nil {
1343		input = &CreateVpcLinkInput{}
1344	}
1345
1346	output = &UpdateVpcLinkOutput{}
1347	req = c.newRequest(op, input, output)
1348	return
1349}
1350
1351// CreateVpcLink API operation for Amazon API Gateway.
1352//
1353// Creates a VPC link, under the caller's account in a selected region, in an
1354// asynchronous operation that typically takes 2-4 minutes to complete and become
1355// operational. The caller must have permissions to create and update VPC Endpoint
1356// services.
1357//
1358// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1359// with awserr.Error's Code and Message methods to get detailed information about
1360// the error.
1361//
1362// See the AWS API reference guide for Amazon API Gateway's
1363// API operation CreateVpcLink for usage and error information.
1364//
1365// Returned Error Codes:
1366//   * ErrCodeUnauthorizedException "UnauthorizedException"
1367//   The request is denied because the caller has insufficient permissions.
1368//
1369//   * ErrCodeBadRequestException "BadRequestException"
1370//   The submitted request is not valid, for example, the input is incomplete
1371//   or incorrect. See the accompanying error message for details.
1372//
1373//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1374//   The request has reached its throttling limit. Retry after the specified time
1375//   period.
1376//
1377func (c *APIGateway) CreateVpcLink(input *CreateVpcLinkInput) (*UpdateVpcLinkOutput, error) {
1378	req, out := c.CreateVpcLinkRequest(input)
1379	return out, req.Send()
1380}
1381
1382// CreateVpcLinkWithContext is the same as CreateVpcLink with the addition of
1383// the ability to pass a context and additional request options.
1384//
1385// See CreateVpcLink for details on how to use this API operation.
1386//
1387// The context must be non-nil and will be used for request cancellation. If
1388// the context is nil a panic will occur. In the future the SDK may create
1389// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1390// for more information on using Contexts.
1391func (c *APIGateway) CreateVpcLinkWithContext(ctx aws.Context, input *CreateVpcLinkInput, opts ...request.Option) (*UpdateVpcLinkOutput, error) {
1392	req, out := c.CreateVpcLinkRequest(input)
1393	req.SetContext(ctx)
1394	req.ApplyOptions(opts...)
1395	return out, req.Send()
1396}
1397
1398const opDeleteApiKey = "DeleteApiKey"
1399
1400// DeleteApiKeyRequest generates a "aws/request.Request" representing the
1401// client's request for the DeleteApiKey operation. The "output" return
1402// value will be populated with the request's response once the request completes
1403// successfully.
1404//
1405// Use "Send" method on the returned Request to send the API call to the service.
1406// the "output" return value is not valid until after Send returns without error.
1407//
1408// See DeleteApiKey for more information on using the DeleteApiKey
1409// API call, and error handling.
1410//
1411// This method is useful when you want to inject custom logic or configuration
1412// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1413//
1414//
1415//    // Example sending a request using the DeleteApiKeyRequest method.
1416//    req, resp := client.DeleteApiKeyRequest(params)
1417//
1418//    err := req.Send()
1419//    if err == nil { // resp is now filled
1420//        fmt.Println(resp)
1421//    }
1422func (c *APIGateway) DeleteApiKeyRequest(input *DeleteApiKeyInput) (req *request.Request, output *DeleteApiKeyOutput) {
1423	op := &request.Operation{
1424		Name:       opDeleteApiKey,
1425		HTTPMethod: "DELETE",
1426		HTTPPath:   "/apikeys/{api_Key}",
1427	}
1428
1429	if input == nil {
1430		input = &DeleteApiKeyInput{}
1431	}
1432
1433	output = &DeleteApiKeyOutput{}
1434	req = c.newRequest(op, input, output)
1435	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
1436	return
1437}
1438
1439// DeleteApiKey API operation for Amazon API Gateway.
1440//
1441// Deletes the ApiKey resource.
1442//
1443// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1444// with awserr.Error's Code and Message methods to get detailed information about
1445// the error.
1446//
1447// See the AWS API reference guide for Amazon API Gateway's
1448// API operation DeleteApiKey for usage and error information.
1449//
1450// Returned Error Codes:
1451//   * ErrCodeUnauthorizedException "UnauthorizedException"
1452//   The request is denied because the caller has insufficient permissions.
1453//
1454//   * ErrCodeNotFoundException "NotFoundException"
1455//   The requested resource is not found. Make sure that the request URI is correct.
1456//
1457//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1458//   The request has reached its throttling limit. Retry after the specified time
1459//   period.
1460//
1461func (c *APIGateway) DeleteApiKey(input *DeleteApiKeyInput) (*DeleteApiKeyOutput, error) {
1462	req, out := c.DeleteApiKeyRequest(input)
1463	return out, req.Send()
1464}
1465
1466// DeleteApiKeyWithContext is the same as DeleteApiKey with the addition of
1467// the ability to pass a context and additional request options.
1468//
1469// See DeleteApiKey for details on how to use this API operation.
1470//
1471// The context must be non-nil and will be used for request cancellation. If
1472// the context is nil a panic will occur. In the future the SDK may create
1473// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1474// for more information on using Contexts.
1475func (c *APIGateway) DeleteApiKeyWithContext(ctx aws.Context, input *DeleteApiKeyInput, opts ...request.Option) (*DeleteApiKeyOutput, error) {
1476	req, out := c.DeleteApiKeyRequest(input)
1477	req.SetContext(ctx)
1478	req.ApplyOptions(opts...)
1479	return out, req.Send()
1480}
1481
1482const opDeleteAuthorizer = "DeleteAuthorizer"
1483
1484// DeleteAuthorizerRequest generates a "aws/request.Request" representing the
1485// client's request for the DeleteAuthorizer operation. The "output" return
1486// value will be populated with the request's response once the request completes
1487// successfully.
1488//
1489// Use "Send" method on the returned Request to send the API call to the service.
1490// the "output" return value is not valid until after Send returns without error.
1491//
1492// See DeleteAuthorizer for more information on using the DeleteAuthorizer
1493// API call, and error handling.
1494//
1495// This method is useful when you want to inject custom logic or configuration
1496// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1497//
1498//
1499//    // Example sending a request using the DeleteAuthorizerRequest method.
1500//    req, resp := client.DeleteAuthorizerRequest(params)
1501//
1502//    err := req.Send()
1503//    if err == nil { // resp is now filled
1504//        fmt.Println(resp)
1505//    }
1506func (c *APIGateway) DeleteAuthorizerRequest(input *DeleteAuthorizerInput) (req *request.Request, output *DeleteAuthorizerOutput) {
1507	op := &request.Operation{
1508		Name:       opDeleteAuthorizer,
1509		HTTPMethod: "DELETE",
1510		HTTPPath:   "/restapis/{restapi_id}/authorizers/{authorizer_id}",
1511	}
1512
1513	if input == nil {
1514		input = &DeleteAuthorizerInput{}
1515	}
1516
1517	output = &DeleteAuthorizerOutput{}
1518	req = c.newRequest(op, input, output)
1519	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
1520	return
1521}
1522
1523// DeleteAuthorizer API operation for Amazon API Gateway.
1524//
1525// Deletes an existing Authorizer resource.
1526//
1527// AWS CLI (https://docs.aws.amazon.com/cli/latest/reference/apigateway/delete-authorizer.html)
1528//
1529// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1530// with awserr.Error's Code and Message methods to get detailed information about
1531// the error.
1532//
1533// See the AWS API reference guide for Amazon API Gateway's
1534// API operation DeleteAuthorizer for usage and error information.
1535//
1536// Returned Error Codes:
1537//   * ErrCodeUnauthorizedException "UnauthorizedException"
1538//   The request is denied because the caller has insufficient permissions.
1539//
1540//   * ErrCodeNotFoundException "NotFoundException"
1541//   The requested resource is not found. Make sure that the request URI is correct.
1542//
1543//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1544//   The request has reached its throttling limit. Retry after the specified time
1545//   period.
1546//
1547//   * ErrCodeBadRequestException "BadRequestException"
1548//   The submitted request is not valid, for example, the input is incomplete
1549//   or incorrect. See the accompanying error message for details.
1550//
1551//   * ErrCodeConflictException "ConflictException"
1552//   The request configuration has conflicts. For details, see the accompanying
1553//   error message.
1554//
1555func (c *APIGateway) DeleteAuthorizer(input *DeleteAuthorizerInput) (*DeleteAuthorizerOutput, error) {
1556	req, out := c.DeleteAuthorizerRequest(input)
1557	return out, req.Send()
1558}
1559
1560// DeleteAuthorizerWithContext is the same as DeleteAuthorizer with the addition of
1561// the ability to pass a context and additional request options.
1562//
1563// See DeleteAuthorizer for details on how to use this API operation.
1564//
1565// The context must be non-nil and will be used for request cancellation. If
1566// the context is nil a panic will occur. In the future the SDK may create
1567// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1568// for more information on using Contexts.
1569func (c *APIGateway) DeleteAuthorizerWithContext(ctx aws.Context, input *DeleteAuthorizerInput, opts ...request.Option) (*DeleteAuthorizerOutput, error) {
1570	req, out := c.DeleteAuthorizerRequest(input)
1571	req.SetContext(ctx)
1572	req.ApplyOptions(opts...)
1573	return out, req.Send()
1574}
1575
1576const opDeleteBasePathMapping = "DeleteBasePathMapping"
1577
1578// DeleteBasePathMappingRequest generates a "aws/request.Request" representing the
1579// client's request for the DeleteBasePathMapping operation. The "output" return
1580// value will be populated with the request's response once the request completes
1581// successfully.
1582//
1583// Use "Send" method on the returned Request to send the API call to the service.
1584// the "output" return value is not valid until after Send returns without error.
1585//
1586// See DeleteBasePathMapping for more information on using the DeleteBasePathMapping
1587// API call, and error handling.
1588//
1589// This method is useful when you want to inject custom logic or configuration
1590// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1591//
1592//
1593//    // Example sending a request using the DeleteBasePathMappingRequest method.
1594//    req, resp := client.DeleteBasePathMappingRequest(params)
1595//
1596//    err := req.Send()
1597//    if err == nil { // resp is now filled
1598//        fmt.Println(resp)
1599//    }
1600func (c *APIGateway) DeleteBasePathMappingRequest(input *DeleteBasePathMappingInput) (req *request.Request, output *DeleteBasePathMappingOutput) {
1601	op := &request.Operation{
1602		Name:       opDeleteBasePathMapping,
1603		HTTPMethod: "DELETE",
1604		HTTPPath:   "/domainnames/{domain_name}/basepathmappings/{base_path}",
1605	}
1606
1607	if input == nil {
1608		input = &DeleteBasePathMappingInput{}
1609	}
1610
1611	output = &DeleteBasePathMappingOutput{}
1612	req = c.newRequest(op, input, output)
1613	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
1614	return
1615}
1616
1617// DeleteBasePathMapping API operation for Amazon API Gateway.
1618//
1619// Deletes the BasePathMapping resource.
1620//
1621// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1622// with awserr.Error's Code and Message methods to get detailed information about
1623// the error.
1624//
1625// See the AWS API reference guide for Amazon API Gateway's
1626// API operation DeleteBasePathMapping for usage and error information.
1627//
1628// Returned Error Codes:
1629//   * ErrCodeUnauthorizedException "UnauthorizedException"
1630//   The request is denied because the caller has insufficient permissions.
1631//
1632//   * ErrCodeNotFoundException "NotFoundException"
1633//   The requested resource is not found. Make sure that the request URI is correct.
1634//
1635//   * ErrCodeConflictException "ConflictException"
1636//   The request configuration has conflicts. For details, see the accompanying
1637//   error message.
1638//
1639//   * ErrCodeBadRequestException "BadRequestException"
1640//   The submitted request is not valid, for example, the input is incomplete
1641//   or incorrect. See the accompanying error message for details.
1642//
1643//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1644//   The request has reached its throttling limit. Retry after the specified time
1645//   period.
1646//
1647func (c *APIGateway) DeleteBasePathMapping(input *DeleteBasePathMappingInput) (*DeleteBasePathMappingOutput, error) {
1648	req, out := c.DeleteBasePathMappingRequest(input)
1649	return out, req.Send()
1650}
1651
1652// DeleteBasePathMappingWithContext is the same as DeleteBasePathMapping with the addition of
1653// the ability to pass a context and additional request options.
1654//
1655// See DeleteBasePathMapping for details on how to use this API operation.
1656//
1657// The context must be non-nil and will be used for request cancellation. If
1658// the context is nil a panic will occur. In the future the SDK may create
1659// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1660// for more information on using Contexts.
1661func (c *APIGateway) DeleteBasePathMappingWithContext(ctx aws.Context, input *DeleteBasePathMappingInput, opts ...request.Option) (*DeleteBasePathMappingOutput, error) {
1662	req, out := c.DeleteBasePathMappingRequest(input)
1663	req.SetContext(ctx)
1664	req.ApplyOptions(opts...)
1665	return out, req.Send()
1666}
1667
1668const opDeleteClientCertificate = "DeleteClientCertificate"
1669
1670// DeleteClientCertificateRequest generates a "aws/request.Request" representing the
1671// client's request for the DeleteClientCertificate operation. The "output" return
1672// value will be populated with the request's response once the request completes
1673// successfully.
1674//
1675// Use "Send" method on the returned Request to send the API call to the service.
1676// the "output" return value is not valid until after Send returns without error.
1677//
1678// See DeleteClientCertificate for more information on using the DeleteClientCertificate
1679// API call, and error handling.
1680//
1681// This method is useful when you want to inject custom logic or configuration
1682// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1683//
1684//
1685//    // Example sending a request using the DeleteClientCertificateRequest method.
1686//    req, resp := client.DeleteClientCertificateRequest(params)
1687//
1688//    err := req.Send()
1689//    if err == nil { // resp is now filled
1690//        fmt.Println(resp)
1691//    }
1692func (c *APIGateway) DeleteClientCertificateRequest(input *DeleteClientCertificateInput) (req *request.Request, output *DeleteClientCertificateOutput) {
1693	op := &request.Operation{
1694		Name:       opDeleteClientCertificate,
1695		HTTPMethod: "DELETE",
1696		HTTPPath:   "/clientcertificates/{clientcertificate_id}",
1697	}
1698
1699	if input == nil {
1700		input = &DeleteClientCertificateInput{}
1701	}
1702
1703	output = &DeleteClientCertificateOutput{}
1704	req = c.newRequest(op, input, output)
1705	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
1706	return
1707}
1708
1709// DeleteClientCertificate API operation for Amazon API Gateway.
1710//
1711// Deletes the ClientCertificate resource.
1712//
1713// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1714// with awserr.Error's Code and Message methods to get detailed information about
1715// the error.
1716//
1717// See the AWS API reference guide for Amazon API Gateway's
1718// API operation DeleteClientCertificate for usage and error information.
1719//
1720// Returned Error Codes:
1721//   * ErrCodeUnauthorizedException "UnauthorizedException"
1722//   The request is denied because the caller has insufficient permissions.
1723//
1724//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1725//   The request has reached its throttling limit. Retry after the specified time
1726//   period.
1727//
1728//   * ErrCodeBadRequestException "BadRequestException"
1729//   The submitted request is not valid, for example, the input is incomplete
1730//   or incorrect. See the accompanying error message for details.
1731//
1732//   * ErrCodeNotFoundException "NotFoundException"
1733//   The requested resource is not found. Make sure that the request URI is correct.
1734//
1735func (c *APIGateway) DeleteClientCertificate(input *DeleteClientCertificateInput) (*DeleteClientCertificateOutput, error) {
1736	req, out := c.DeleteClientCertificateRequest(input)
1737	return out, req.Send()
1738}
1739
1740// DeleteClientCertificateWithContext is the same as DeleteClientCertificate with the addition of
1741// the ability to pass a context and additional request options.
1742//
1743// See DeleteClientCertificate for details on how to use this API operation.
1744//
1745// The context must be non-nil and will be used for request cancellation. If
1746// the context is nil a panic will occur. In the future the SDK may create
1747// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1748// for more information on using Contexts.
1749func (c *APIGateway) DeleteClientCertificateWithContext(ctx aws.Context, input *DeleteClientCertificateInput, opts ...request.Option) (*DeleteClientCertificateOutput, error) {
1750	req, out := c.DeleteClientCertificateRequest(input)
1751	req.SetContext(ctx)
1752	req.ApplyOptions(opts...)
1753	return out, req.Send()
1754}
1755
1756const opDeleteDeployment = "DeleteDeployment"
1757
1758// DeleteDeploymentRequest generates a "aws/request.Request" representing the
1759// client's request for the DeleteDeployment operation. The "output" return
1760// value will be populated with the request's response once the request completes
1761// successfully.
1762//
1763// Use "Send" method on the returned Request to send the API call to the service.
1764// the "output" return value is not valid until after Send returns without error.
1765//
1766// See DeleteDeployment for more information on using the DeleteDeployment
1767// API call, and error handling.
1768//
1769// This method is useful when you want to inject custom logic or configuration
1770// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1771//
1772//
1773//    // Example sending a request using the DeleteDeploymentRequest method.
1774//    req, resp := client.DeleteDeploymentRequest(params)
1775//
1776//    err := req.Send()
1777//    if err == nil { // resp is now filled
1778//        fmt.Println(resp)
1779//    }
1780func (c *APIGateway) DeleteDeploymentRequest(input *DeleteDeploymentInput) (req *request.Request, output *DeleteDeploymentOutput) {
1781	op := &request.Operation{
1782		Name:       opDeleteDeployment,
1783		HTTPMethod: "DELETE",
1784		HTTPPath:   "/restapis/{restapi_id}/deployments/{deployment_id}",
1785	}
1786
1787	if input == nil {
1788		input = &DeleteDeploymentInput{}
1789	}
1790
1791	output = &DeleteDeploymentOutput{}
1792	req = c.newRequest(op, input, output)
1793	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
1794	return
1795}
1796
1797// DeleteDeployment API operation for Amazon API Gateway.
1798//
1799// Deletes a Deployment resource. Deleting a deployment will only succeed if
1800// there are no Stage resources associated with it.
1801//
1802// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1803// with awserr.Error's Code and Message methods to get detailed information about
1804// the error.
1805//
1806// See the AWS API reference guide for Amazon API Gateway's
1807// API operation DeleteDeployment for usage and error information.
1808//
1809// Returned Error Codes:
1810//   * ErrCodeUnauthorizedException "UnauthorizedException"
1811//   The request is denied because the caller has insufficient permissions.
1812//
1813//   * ErrCodeNotFoundException "NotFoundException"
1814//   The requested resource is not found. Make sure that the request URI is correct.
1815//
1816//   * ErrCodeBadRequestException "BadRequestException"
1817//   The submitted request is not valid, for example, the input is incomplete
1818//   or incorrect. See the accompanying error message for details.
1819//
1820//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1821//   The request has reached its throttling limit. Retry after the specified time
1822//   period.
1823//
1824func (c *APIGateway) DeleteDeployment(input *DeleteDeploymentInput) (*DeleteDeploymentOutput, error) {
1825	req, out := c.DeleteDeploymentRequest(input)
1826	return out, req.Send()
1827}
1828
1829// DeleteDeploymentWithContext is the same as DeleteDeployment with the addition of
1830// the ability to pass a context and additional request options.
1831//
1832// See DeleteDeployment for details on how to use this API operation.
1833//
1834// The context must be non-nil and will be used for request cancellation. If
1835// the context is nil a panic will occur. In the future the SDK may create
1836// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1837// for more information on using Contexts.
1838func (c *APIGateway) DeleteDeploymentWithContext(ctx aws.Context, input *DeleteDeploymentInput, opts ...request.Option) (*DeleteDeploymentOutput, error) {
1839	req, out := c.DeleteDeploymentRequest(input)
1840	req.SetContext(ctx)
1841	req.ApplyOptions(opts...)
1842	return out, req.Send()
1843}
1844
1845const opDeleteDocumentationPart = "DeleteDocumentationPart"
1846
1847// DeleteDocumentationPartRequest generates a "aws/request.Request" representing the
1848// client's request for the DeleteDocumentationPart operation. The "output" return
1849// value will be populated with the request's response once the request completes
1850// successfully.
1851//
1852// Use "Send" method on the returned Request to send the API call to the service.
1853// the "output" return value is not valid until after Send returns without error.
1854//
1855// See DeleteDocumentationPart for more information on using the DeleteDocumentationPart
1856// API call, and error handling.
1857//
1858// This method is useful when you want to inject custom logic or configuration
1859// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1860//
1861//
1862//    // Example sending a request using the DeleteDocumentationPartRequest method.
1863//    req, resp := client.DeleteDocumentationPartRequest(params)
1864//
1865//    err := req.Send()
1866//    if err == nil { // resp is now filled
1867//        fmt.Println(resp)
1868//    }
1869func (c *APIGateway) DeleteDocumentationPartRequest(input *DeleteDocumentationPartInput) (req *request.Request, output *DeleteDocumentationPartOutput) {
1870	op := &request.Operation{
1871		Name:       opDeleteDocumentationPart,
1872		HTTPMethod: "DELETE",
1873		HTTPPath:   "/restapis/{restapi_id}/documentation/parts/{part_id}",
1874	}
1875
1876	if input == nil {
1877		input = &DeleteDocumentationPartInput{}
1878	}
1879
1880	output = &DeleteDocumentationPartOutput{}
1881	req = c.newRequest(op, input, output)
1882	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
1883	return
1884}
1885
1886// DeleteDocumentationPart API operation for Amazon API Gateway.
1887//
1888// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1889// with awserr.Error's Code and Message methods to get detailed information about
1890// the error.
1891//
1892// See the AWS API reference guide for Amazon API Gateway's
1893// API operation DeleteDocumentationPart for usage and error information.
1894//
1895// Returned Error Codes:
1896//   * ErrCodeUnauthorizedException "UnauthorizedException"
1897//   The request is denied because the caller has insufficient permissions.
1898//
1899//   * ErrCodeNotFoundException "NotFoundException"
1900//   The requested resource is not found. Make sure that the request URI is correct.
1901//
1902//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
1903//   The request has reached its throttling limit. Retry after the specified time
1904//   period.
1905//
1906//   * ErrCodeConflictException "ConflictException"
1907//   The request configuration has conflicts. For details, see the accompanying
1908//   error message.
1909//
1910//   * ErrCodeBadRequestException "BadRequestException"
1911//   The submitted request is not valid, for example, the input is incomplete
1912//   or incorrect. See the accompanying error message for details.
1913//
1914func (c *APIGateway) DeleteDocumentationPart(input *DeleteDocumentationPartInput) (*DeleteDocumentationPartOutput, error) {
1915	req, out := c.DeleteDocumentationPartRequest(input)
1916	return out, req.Send()
1917}
1918
1919// DeleteDocumentationPartWithContext is the same as DeleteDocumentationPart with the addition of
1920// the ability to pass a context and additional request options.
1921//
1922// See DeleteDocumentationPart for details on how to use this API operation.
1923//
1924// The context must be non-nil and will be used for request cancellation. If
1925// the context is nil a panic will occur. In the future the SDK may create
1926// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1927// for more information on using Contexts.
1928func (c *APIGateway) DeleteDocumentationPartWithContext(ctx aws.Context, input *DeleteDocumentationPartInput, opts ...request.Option) (*DeleteDocumentationPartOutput, error) {
1929	req, out := c.DeleteDocumentationPartRequest(input)
1930	req.SetContext(ctx)
1931	req.ApplyOptions(opts...)
1932	return out, req.Send()
1933}
1934
1935const opDeleteDocumentationVersion = "DeleteDocumentationVersion"
1936
1937// DeleteDocumentationVersionRequest generates a "aws/request.Request" representing the
1938// client's request for the DeleteDocumentationVersion operation. The "output" return
1939// value will be populated with the request's response once the request completes
1940// successfully.
1941//
1942// Use "Send" method on the returned Request to send the API call to the service.
1943// the "output" return value is not valid until after Send returns without error.
1944//
1945// See DeleteDocumentationVersion for more information on using the DeleteDocumentationVersion
1946// API call, and error handling.
1947//
1948// This method is useful when you want to inject custom logic or configuration
1949// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1950//
1951//
1952//    // Example sending a request using the DeleteDocumentationVersionRequest method.
1953//    req, resp := client.DeleteDocumentationVersionRequest(params)
1954//
1955//    err := req.Send()
1956//    if err == nil { // resp is now filled
1957//        fmt.Println(resp)
1958//    }
1959func (c *APIGateway) DeleteDocumentationVersionRequest(input *DeleteDocumentationVersionInput) (req *request.Request, output *DeleteDocumentationVersionOutput) {
1960	op := &request.Operation{
1961		Name:       opDeleteDocumentationVersion,
1962		HTTPMethod: "DELETE",
1963		HTTPPath:   "/restapis/{restapi_id}/documentation/versions/{doc_version}",
1964	}
1965
1966	if input == nil {
1967		input = &DeleteDocumentationVersionInput{}
1968	}
1969
1970	output = &DeleteDocumentationVersionOutput{}
1971	req = c.newRequest(op, input, output)
1972	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
1973	return
1974}
1975
1976// DeleteDocumentationVersion API operation for Amazon API Gateway.
1977//
1978// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1979// with awserr.Error's Code and Message methods to get detailed information about
1980// the error.
1981//
1982// See the AWS API reference guide for Amazon API Gateway's
1983// API operation DeleteDocumentationVersion for usage and error information.
1984//
1985// Returned Error Codes:
1986//   * ErrCodeUnauthorizedException "UnauthorizedException"
1987//   The request is denied because the caller has insufficient permissions.
1988//
1989//   * ErrCodeNotFoundException "NotFoundException"
1990//   The requested resource is not found. Make sure that the request URI is correct.
1991//
1992//   * ErrCodeBadRequestException "BadRequestException"
1993//   The submitted request is not valid, for example, the input is incomplete
1994//   or incorrect. See the accompanying error message for details.
1995//
1996//   * ErrCodeConflictException "ConflictException"
1997//   The request configuration has conflicts. For details, see the accompanying
1998//   error message.
1999//
2000//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2001//   The request has reached its throttling limit. Retry after the specified time
2002//   period.
2003//
2004func (c *APIGateway) DeleteDocumentationVersion(input *DeleteDocumentationVersionInput) (*DeleteDocumentationVersionOutput, error) {
2005	req, out := c.DeleteDocumentationVersionRequest(input)
2006	return out, req.Send()
2007}
2008
2009// DeleteDocumentationVersionWithContext is the same as DeleteDocumentationVersion with the addition of
2010// the ability to pass a context and additional request options.
2011//
2012// See DeleteDocumentationVersion for details on how to use this API operation.
2013//
2014// The context must be non-nil and will be used for request cancellation. If
2015// the context is nil a panic will occur. In the future the SDK may create
2016// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2017// for more information on using Contexts.
2018func (c *APIGateway) DeleteDocumentationVersionWithContext(ctx aws.Context, input *DeleteDocumentationVersionInput, opts ...request.Option) (*DeleteDocumentationVersionOutput, error) {
2019	req, out := c.DeleteDocumentationVersionRequest(input)
2020	req.SetContext(ctx)
2021	req.ApplyOptions(opts...)
2022	return out, req.Send()
2023}
2024
2025const opDeleteDomainName = "DeleteDomainName"
2026
2027// DeleteDomainNameRequest generates a "aws/request.Request" representing the
2028// client's request for the DeleteDomainName operation. The "output" return
2029// value will be populated with the request's response once the request completes
2030// successfully.
2031//
2032// Use "Send" method on the returned Request to send the API call to the service.
2033// the "output" return value is not valid until after Send returns without error.
2034//
2035// See DeleteDomainName for more information on using the DeleteDomainName
2036// API call, and error handling.
2037//
2038// This method is useful when you want to inject custom logic or configuration
2039// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2040//
2041//
2042//    // Example sending a request using the DeleteDomainNameRequest method.
2043//    req, resp := client.DeleteDomainNameRequest(params)
2044//
2045//    err := req.Send()
2046//    if err == nil { // resp is now filled
2047//        fmt.Println(resp)
2048//    }
2049func (c *APIGateway) DeleteDomainNameRequest(input *DeleteDomainNameInput) (req *request.Request, output *DeleteDomainNameOutput) {
2050	op := &request.Operation{
2051		Name:       opDeleteDomainName,
2052		HTTPMethod: "DELETE",
2053		HTTPPath:   "/domainnames/{domain_name}",
2054	}
2055
2056	if input == nil {
2057		input = &DeleteDomainNameInput{}
2058	}
2059
2060	output = &DeleteDomainNameOutput{}
2061	req = c.newRequest(op, input, output)
2062	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2063	return
2064}
2065
2066// DeleteDomainName API operation for Amazon API Gateway.
2067//
2068// Deletes the DomainName resource.
2069//
2070// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2071// with awserr.Error's Code and Message methods to get detailed information about
2072// the error.
2073//
2074// See the AWS API reference guide for Amazon API Gateway's
2075// API operation DeleteDomainName for usage and error information.
2076//
2077// Returned Error Codes:
2078//   * ErrCodeUnauthorizedException "UnauthorizedException"
2079//   The request is denied because the caller has insufficient permissions.
2080//
2081//   * ErrCodeNotFoundException "NotFoundException"
2082//   The requested resource is not found. Make sure that the request URI is correct.
2083//
2084//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2085//   The request has reached its throttling limit. Retry after the specified time
2086//   period.
2087//
2088//   * ErrCodeBadRequestException "BadRequestException"
2089//   The submitted request is not valid, for example, the input is incomplete
2090//   or incorrect. See the accompanying error message for details.
2091//
2092func (c *APIGateway) DeleteDomainName(input *DeleteDomainNameInput) (*DeleteDomainNameOutput, error) {
2093	req, out := c.DeleteDomainNameRequest(input)
2094	return out, req.Send()
2095}
2096
2097// DeleteDomainNameWithContext is the same as DeleteDomainName with the addition of
2098// the ability to pass a context and additional request options.
2099//
2100// See DeleteDomainName for details on how to use this API operation.
2101//
2102// The context must be non-nil and will be used for request cancellation. If
2103// the context is nil a panic will occur. In the future the SDK may create
2104// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2105// for more information on using Contexts.
2106func (c *APIGateway) DeleteDomainNameWithContext(ctx aws.Context, input *DeleteDomainNameInput, opts ...request.Option) (*DeleteDomainNameOutput, error) {
2107	req, out := c.DeleteDomainNameRequest(input)
2108	req.SetContext(ctx)
2109	req.ApplyOptions(opts...)
2110	return out, req.Send()
2111}
2112
2113const opDeleteGatewayResponse = "DeleteGatewayResponse"
2114
2115// DeleteGatewayResponseRequest generates a "aws/request.Request" representing the
2116// client's request for the DeleteGatewayResponse operation. The "output" return
2117// value will be populated with the request's response once the request completes
2118// successfully.
2119//
2120// Use "Send" method on the returned Request to send the API call to the service.
2121// the "output" return value is not valid until after Send returns without error.
2122//
2123// See DeleteGatewayResponse for more information on using the DeleteGatewayResponse
2124// API call, and error handling.
2125//
2126// This method is useful when you want to inject custom logic or configuration
2127// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2128//
2129//
2130//    // Example sending a request using the DeleteGatewayResponseRequest method.
2131//    req, resp := client.DeleteGatewayResponseRequest(params)
2132//
2133//    err := req.Send()
2134//    if err == nil { // resp is now filled
2135//        fmt.Println(resp)
2136//    }
2137func (c *APIGateway) DeleteGatewayResponseRequest(input *DeleteGatewayResponseInput) (req *request.Request, output *DeleteGatewayResponseOutput) {
2138	op := &request.Operation{
2139		Name:       opDeleteGatewayResponse,
2140		HTTPMethod: "DELETE",
2141		HTTPPath:   "/restapis/{restapi_id}/gatewayresponses/{response_type}",
2142	}
2143
2144	if input == nil {
2145		input = &DeleteGatewayResponseInput{}
2146	}
2147
2148	output = &DeleteGatewayResponseOutput{}
2149	req = c.newRequest(op, input, output)
2150	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2151	return
2152}
2153
2154// DeleteGatewayResponse API operation for Amazon API Gateway.
2155//
2156// Clears any customization of a GatewayResponse of a specified response type
2157// on the given RestApi and resets it with the default settings.
2158//
2159// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2160// with awserr.Error's Code and Message methods to get detailed information about
2161// the error.
2162//
2163// See the AWS API reference guide for Amazon API Gateway's
2164// API operation DeleteGatewayResponse for usage and error information.
2165//
2166// Returned Error Codes:
2167//   * ErrCodeUnauthorizedException "UnauthorizedException"
2168//   The request is denied because the caller has insufficient permissions.
2169//
2170//   * ErrCodeNotFoundException "NotFoundException"
2171//   The requested resource is not found. Make sure that the request URI is correct.
2172//
2173//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2174//   The request has reached its throttling limit. Retry after the specified time
2175//   period.
2176//
2177//   * ErrCodeBadRequestException "BadRequestException"
2178//   The submitted request is not valid, for example, the input is incomplete
2179//   or incorrect. See the accompanying error message for details.
2180//
2181//   * ErrCodeConflictException "ConflictException"
2182//   The request configuration has conflicts. For details, see the accompanying
2183//   error message.
2184//
2185func (c *APIGateway) DeleteGatewayResponse(input *DeleteGatewayResponseInput) (*DeleteGatewayResponseOutput, error) {
2186	req, out := c.DeleteGatewayResponseRequest(input)
2187	return out, req.Send()
2188}
2189
2190// DeleteGatewayResponseWithContext is the same as DeleteGatewayResponse with the addition of
2191// the ability to pass a context and additional request options.
2192//
2193// See DeleteGatewayResponse for details on how to use this API operation.
2194//
2195// The context must be non-nil and will be used for request cancellation. If
2196// the context is nil a panic will occur. In the future the SDK may create
2197// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2198// for more information on using Contexts.
2199func (c *APIGateway) DeleteGatewayResponseWithContext(ctx aws.Context, input *DeleteGatewayResponseInput, opts ...request.Option) (*DeleteGatewayResponseOutput, error) {
2200	req, out := c.DeleteGatewayResponseRequest(input)
2201	req.SetContext(ctx)
2202	req.ApplyOptions(opts...)
2203	return out, req.Send()
2204}
2205
2206const opDeleteIntegration = "DeleteIntegration"
2207
2208// DeleteIntegrationRequest generates a "aws/request.Request" representing the
2209// client's request for the DeleteIntegration operation. The "output" return
2210// value will be populated with the request's response once the request completes
2211// successfully.
2212//
2213// Use "Send" method on the returned Request to send the API call to the service.
2214// the "output" return value is not valid until after Send returns without error.
2215//
2216// See DeleteIntegration for more information on using the DeleteIntegration
2217// API call, and error handling.
2218//
2219// This method is useful when you want to inject custom logic or configuration
2220// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2221//
2222//
2223//    // Example sending a request using the DeleteIntegrationRequest method.
2224//    req, resp := client.DeleteIntegrationRequest(params)
2225//
2226//    err := req.Send()
2227//    if err == nil { // resp is now filled
2228//        fmt.Println(resp)
2229//    }
2230func (c *APIGateway) DeleteIntegrationRequest(input *DeleteIntegrationInput) (req *request.Request, output *DeleteIntegrationOutput) {
2231	op := &request.Operation{
2232		Name:       opDeleteIntegration,
2233		HTTPMethod: "DELETE",
2234		HTTPPath:   "/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration",
2235	}
2236
2237	if input == nil {
2238		input = &DeleteIntegrationInput{}
2239	}
2240
2241	output = &DeleteIntegrationOutput{}
2242	req = c.newRequest(op, input, output)
2243	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2244	return
2245}
2246
2247// DeleteIntegration API operation for Amazon API Gateway.
2248//
2249// Represents a delete integration.
2250//
2251// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2252// with awserr.Error's Code and Message methods to get detailed information about
2253// the error.
2254//
2255// See the AWS API reference guide for Amazon API Gateway's
2256// API operation DeleteIntegration for usage and error information.
2257//
2258// Returned Error Codes:
2259//   * ErrCodeUnauthorizedException "UnauthorizedException"
2260//   The request is denied because the caller has insufficient permissions.
2261//
2262//   * ErrCodeNotFoundException "NotFoundException"
2263//   The requested resource is not found. Make sure that the request URI is correct.
2264//
2265//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2266//   The request has reached its throttling limit. Retry after the specified time
2267//   period.
2268//
2269//   * ErrCodeConflictException "ConflictException"
2270//   The request configuration has conflicts. For details, see the accompanying
2271//   error message.
2272//
2273func (c *APIGateway) DeleteIntegration(input *DeleteIntegrationInput) (*DeleteIntegrationOutput, error) {
2274	req, out := c.DeleteIntegrationRequest(input)
2275	return out, req.Send()
2276}
2277
2278// DeleteIntegrationWithContext is the same as DeleteIntegration with the addition of
2279// the ability to pass a context and additional request options.
2280//
2281// See DeleteIntegration for details on how to use this API operation.
2282//
2283// The context must be non-nil and will be used for request cancellation. If
2284// the context is nil a panic will occur. In the future the SDK may create
2285// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2286// for more information on using Contexts.
2287func (c *APIGateway) DeleteIntegrationWithContext(ctx aws.Context, input *DeleteIntegrationInput, opts ...request.Option) (*DeleteIntegrationOutput, error) {
2288	req, out := c.DeleteIntegrationRequest(input)
2289	req.SetContext(ctx)
2290	req.ApplyOptions(opts...)
2291	return out, req.Send()
2292}
2293
2294const opDeleteIntegrationResponse = "DeleteIntegrationResponse"
2295
2296// DeleteIntegrationResponseRequest generates a "aws/request.Request" representing the
2297// client's request for the DeleteIntegrationResponse operation. The "output" return
2298// value will be populated with the request's response once the request completes
2299// successfully.
2300//
2301// Use "Send" method on the returned Request to send the API call to the service.
2302// the "output" return value is not valid until after Send returns without error.
2303//
2304// See DeleteIntegrationResponse for more information on using the DeleteIntegrationResponse
2305// API call, and error handling.
2306//
2307// This method is useful when you want to inject custom logic or configuration
2308// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2309//
2310//
2311//    // Example sending a request using the DeleteIntegrationResponseRequest method.
2312//    req, resp := client.DeleteIntegrationResponseRequest(params)
2313//
2314//    err := req.Send()
2315//    if err == nil { // resp is now filled
2316//        fmt.Println(resp)
2317//    }
2318func (c *APIGateway) DeleteIntegrationResponseRequest(input *DeleteIntegrationResponseInput) (req *request.Request, output *DeleteIntegrationResponseOutput) {
2319	op := &request.Operation{
2320		Name:       opDeleteIntegrationResponse,
2321		HTTPMethod: "DELETE",
2322		HTTPPath:   "/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration/responses/{status_code}",
2323	}
2324
2325	if input == nil {
2326		input = &DeleteIntegrationResponseInput{}
2327	}
2328
2329	output = &DeleteIntegrationResponseOutput{}
2330	req = c.newRequest(op, input, output)
2331	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2332	return
2333}
2334
2335// DeleteIntegrationResponse API operation for Amazon API Gateway.
2336//
2337// Represents a delete integration response.
2338//
2339// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2340// with awserr.Error's Code and Message methods to get detailed information about
2341// the error.
2342//
2343// See the AWS API reference guide for Amazon API Gateway's
2344// API operation DeleteIntegrationResponse for usage and error information.
2345//
2346// Returned Error Codes:
2347//   * ErrCodeUnauthorizedException "UnauthorizedException"
2348//   The request is denied because the caller has insufficient permissions.
2349//
2350//   * ErrCodeNotFoundException "NotFoundException"
2351//   The requested resource is not found. Make sure that the request URI is correct.
2352//
2353//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2354//   The request has reached its throttling limit. Retry after the specified time
2355//   period.
2356//
2357//   * ErrCodeBadRequestException "BadRequestException"
2358//   The submitted request is not valid, for example, the input is incomplete
2359//   or incorrect. See the accompanying error message for details.
2360//
2361//   * ErrCodeConflictException "ConflictException"
2362//   The request configuration has conflicts. For details, see the accompanying
2363//   error message.
2364//
2365func (c *APIGateway) DeleteIntegrationResponse(input *DeleteIntegrationResponseInput) (*DeleteIntegrationResponseOutput, error) {
2366	req, out := c.DeleteIntegrationResponseRequest(input)
2367	return out, req.Send()
2368}
2369
2370// DeleteIntegrationResponseWithContext is the same as DeleteIntegrationResponse with the addition of
2371// the ability to pass a context and additional request options.
2372//
2373// See DeleteIntegrationResponse for details on how to use this API operation.
2374//
2375// The context must be non-nil and will be used for request cancellation. If
2376// the context is nil a panic will occur. In the future the SDK may create
2377// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2378// for more information on using Contexts.
2379func (c *APIGateway) DeleteIntegrationResponseWithContext(ctx aws.Context, input *DeleteIntegrationResponseInput, opts ...request.Option) (*DeleteIntegrationResponseOutput, error) {
2380	req, out := c.DeleteIntegrationResponseRequest(input)
2381	req.SetContext(ctx)
2382	req.ApplyOptions(opts...)
2383	return out, req.Send()
2384}
2385
2386const opDeleteMethod = "DeleteMethod"
2387
2388// DeleteMethodRequest generates a "aws/request.Request" representing the
2389// client's request for the DeleteMethod operation. The "output" return
2390// value will be populated with the request's response once the request completes
2391// successfully.
2392//
2393// Use "Send" method on the returned Request to send the API call to the service.
2394// the "output" return value is not valid until after Send returns without error.
2395//
2396// See DeleteMethod for more information on using the DeleteMethod
2397// API call, and error handling.
2398//
2399// This method is useful when you want to inject custom logic or configuration
2400// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2401//
2402//
2403//    // Example sending a request using the DeleteMethodRequest method.
2404//    req, resp := client.DeleteMethodRequest(params)
2405//
2406//    err := req.Send()
2407//    if err == nil { // resp is now filled
2408//        fmt.Println(resp)
2409//    }
2410func (c *APIGateway) DeleteMethodRequest(input *DeleteMethodInput) (req *request.Request, output *DeleteMethodOutput) {
2411	op := &request.Operation{
2412		Name:       opDeleteMethod,
2413		HTTPMethod: "DELETE",
2414		HTTPPath:   "/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}",
2415	}
2416
2417	if input == nil {
2418		input = &DeleteMethodInput{}
2419	}
2420
2421	output = &DeleteMethodOutput{}
2422	req = c.newRequest(op, input, output)
2423	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2424	return
2425}
2426
2427// DeleteMethod API operation for Amazon API Gateway.
2428//
2429// Deletes an existing Method resource.
2430//
2431// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2432// with awserr.Error's Code and Message methods to get detailed information about
2433// the error.
2434//
2435// See the AWS API reference guide for Amazon API Gateway's
2436// API operation DeleteMethod for usage and error information.
2437//
2438// Returned Error Codes:
2439//   * ErrCodeUnauthorizedException "UnauthorizedException"
2440//   The request is denied because the caller has insufficient permissions.
2441//
2442//   * ErrCodeNotFoundException "NotFoundException"
2443//   The requested resource is not found. Make sure that the request URI is correct.
2444//
2445//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2446//   The request has reached its throttling limit. Retry after the specified time
2447//   period.
2448//
2449//   * ErrCodeConflictException "ConflictException"
2450//   The request configuration has conflicts. For details, see the accompanying
2451//   error message.
2452//
2453func (c *APIGateway) DeleteMethod(input *DeleteMethodInput) (*DeleteMethodOutput, error) {
2454	req, out := c.DeleteMethodRequest(input)
2455	return out, req.Send()
2456}
2457
2458// DeleteMethodWithContext is the same as DeleteMethod with the addition of
2459// the ability to pass a context and additional request options.
2460//
2461// See DeleteMethod for details on how to use this API operation.
2462//
2463// The context must be non-nil and will be used for request cancellation. If
2464// the context is nil a panic will occur. In the future the SDK may create
2465// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2466// for more information on using Contexts.
2467func (c *APIGateway) DeleteMethodWithContext(ctx aws.Context, input *DeleteMethodInput, opts ...request.Option) (*DeleteMethodOutput, error) {
2468	req, out := c.DeleteMethodRequest(input)
2469	req.SetContext(ctx)
2470	req.ApplyOptions(opts...)
2471	return out, req.Send()
2472}
2473
2474const opDeleteMethodResponse = "DeleteMethodResponse"
2475
2476// DeleteMethodResponseRequest generates a "aws/request.Request" representing the
2477// client's request for the DeleteMethodResponse operation. The "output" return
2478// value will be populated with the request's response once the request completes
2479// successfully.
2480//
2481// Use "Send" method on the returned Request to send the API call to the service.
2482// the "output" return value is not valid until after Send returns without error.
2483//
2484// See DeleteMethodResponse for more information on using the DeleteMethodResponse
2485// API call, and error handling.
2486//
2487// This method is useful when you want to inject custom logic or configuration
2488// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2489//
2490//
2491//    // Example sending a request using the DeleteMethodResponseRequest method.
2492//    req, resp := client.DeleteMethodResponseRequest(params)
2493//
2494//    err := req.Send()
2495//    if err == nil { // resp is now filled
2496//        fmt.Println(resp)
2497//    }
2498func (c *APIGateway) DeleteMethodResponseRequest(input *DeleteMethodResponseInput) (req *request.Request, output *DeleteMethodResponseOutput) {
2499	op := &request.Operation{
2500		Name:       opDeleteMethodResponse,
2501		HTTPMethod: "DELETE",
2502		HTTPPath:   "/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/responses/{status_code}",
2503	}
2504
2505	if input == nil {
2506		input = &DeleteMethodResponseInput{}
2507	}
2508
2509	output = &DeleteMethodResponseOutput{}
2510	req = c.newRequest(op, input, output)
2511	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2512	return
2513}
2514
2515// DeleteMethodResponse API operation for Amazon API Gateway.
2516//
2517// Deletes an existing MethodResponse resource.
2518//
2519// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2520// with awserr.Error's Code and Message methods to get detailed information about
2521// the error.
2522//
2523// See the AWS API reference guide for Amazon API Gateway's
2524// API operation DeleteMethodResponse for usage and error information.
2525//
2526// Returned Error Codes:
2527//   * ErrCodeUnauthorizedException "UnauthorizedException"
2528//   The request is denied because the caller has insufficient permissions.
2529//
2530//   * ErrCodeNotFoundException "NotFoundException"
2531//   The requested resource is not found. Make sure that the request URI is correct.
2532//
2533//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2534//   The request has reached its throttling limit. Retry after the specified time
2535//   period.
2536//
2537//   * ErrCodeBadRequestException "BadRequestException"
2538//   The submitted request is not valid, for example, the input is incomplete
2539//   or incorrect. See the accompanying error message for details.
2540//
2541//   * ErrCodeConflictException "ConflictException"
2542//   The request configuration has conflicts. For details, see the accompanying
2543//   error message.
2544//
2545func (c *APIGateway) DeleteMethodResponse(input *DeleteMethodResponseInput) (*DeleteMethodResponseOutput, error) {
2546	req, out := c.DeleteMethodResponseRequest(input)
2547	return out, req.Send()
2548}
2549
2550// DeleteMethodResponseWithContext is the same as DeleteMethodResponse with the addition of
2551// the ability to pass a context and additional request options.
2552//
2553// See DeleteMethodResponse for details on how to use this API operation.
2554//
2555// The context must be non-nil and will be used for request cancellation. If
2556// the context is nil a panic will occur. In the future the SDK may create
2557// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2558// for more information on using Contexts.
2559func (c *APIGateway) DeleteMethodResponseWithContext(ctx aws.Context, input *DeleteMethodResponseInput, opts ...request.Option) (*DeleteMethodResponseOutput, error) {
2560	req, out := c.DeleteMethodResponseRequest(input)
2561	req.SetContext(ctx)
2562	req.ApplyOptions(opts...)
2563	return out, req.Send()
2564}
2565
2566const opDeleteModel = "DeleteModel"
2567
2568// DeleteModelRequest generates a "aws/request.Request" representing the
2569// client's request for the DeleteModel operation. The "output" return
2570// value will be populated with the request's response once the request completes
2571// successfully.
2572//
2573// Use "Send" method on the returned Request to send the API call to the service.
2574// the "output" return value is not valid until after Send returns without error.
2575//
2576// See DeleteModel for more information on using the DeleteModel
2577// API call, and error handling.
2578//
2579// This method is useful when you want to inject custom logic or configuration
2580// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2581//
2582//
2583//    // Example sending a request using the DeleteModelRequest method.
2584//    req, resp := client.DeleteModelRequest(params)
2585//
2586//    err := req.Send()
2587//    if err == nil { // resp is now filled
2588//        fmt.Println(resp)
2589//    }
2590func (c *APIGateway) DeleteModelRequest(input *DeleteModelInput) (req *request.Request, output *DeleteModelOutput) {
2591	op := &request.Operation{
2592		Name:       opDeleteModel,
2593		HTTPMethod: "DELETE",
2594		HTTPPath:   "/restapis/{restapi_id}/models/{model_name}",
2595	}
2596
2597	if input == nil {
2598		input = &DeleteModelInput{}
2599	}
2600
2601	output = &DeleteModelOutput{}
2602	req = c.newRequest(op, input, output)
2603	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2604	return
2605}
2606
2607// DeleteModel API operation for Amazon API Gateway.
2608//
2609// Deletes a model.
2610//
2611// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2612// with awserr.Error's Code and Message methods to get detailed information about
2613// the error.
2614//
2615// See the AWS API reference guide for Amazon API Gateway's
2616// API operation DeleteModel for usage and error information.
2617//
2618// Returned Error Codes:
2619//   * ErrCodeUnauthorizedException "UnauthorizedException"
2620//   The request is denied because the caller has insufficient permissions.
2621//
2622//   * ErrCodeNotFoundException "NotFoundException"
2623//   The requested resource is not found. Make sure that the request URI is correct.
2624//
2625//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2626//   The request has reached its throttling limit. Retry after the specified time
2627//   period.
2628//
2629//   * ErrCodeBadRequestException "BadRequestException"
2630//   The submitted request is not valid, for example, the input is incomplete
2631//   or incorrect. See the accompanying error message for details.
2632//
2633//   * ErrCodeConflictException "ConflictException"
2634//   The request configuration has conflicts. For details, see the accompanying
2635//   error message.
2636//
2637func (c *APIGateway) DeleteModel(input *DeleteModelInput) (*DeleteModelOutput, error) {
2638	req, out := c.DeleteModelRequest(input)
2639	return out, req.Send()
2640}
2641
2642// DeleteModelWithContext is the same as DeleteModel with the addition of
2643// the ability to pass a context and additional request options.
2644//
2645// See DeleteModel for details on how to use this API operation.
2646//
2647// The context must be non-nil and will be used for request cancellation. If
2648// the context is nil a panic will occur. In the future the SDK may create
2649// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2650// for more information on using Contexts.
2651func (c *APIGateway) DeleteModelWithContext(ctx aws.Context, input *DeleteModelInput, opts ...request.Option) (*DeleteModelOutput, error) {
2652	req, out := c.DeleteModelRequest(input)
2653	req.SetContext(ctx)
2654	req.ApplyOptions(opts...)
2655	return out, req.Send()
2656}
2657
2658const opDeleteRequestValidator = "DeleteRequestValidator"
2659
2660// DeleteRequestValidatorRequest generates a "aws/request.Request" representing the
2661// client's request for the DeleteRequestValidator operation. The "output" return
2662// value will be populated with the request's response once the request completes
2663// successfully.
2664//
2665// Use "Send" method on the returned Request to send the API call to the service.
2666// the "output" return value is not valid until after Send returns without error.
2667//
2668// See DeleteRequestValidator for more information on using the DeleteRequestValidator
2669// API call, and error handling.
2670//
2671// This method is useful when you want to inject custom logic or configuration
2672// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2673//
2674//
2675//    // Example sending a request using the DeleteRequestValidatorRequest method.
2676//    req, resp := client.DeleteRequestValidatorRequest(params)
2677//
2678//    err := req.Send()
2679//    if err == nil { // resp is now filled
2680//        fmt.Println(resp)
2681//    }
2682func (c *APIGateway) DeleteRequestValidatorRequest(input *DeleteRequestValidatorInput) (req *request.Request, output *DeleteRequestValidatorOutput) {
2683	op := &request.Operation{
2684		Name:       opDeleteRequestValidator,
2685		HTTPMethod: "DELETE",
2686		HTTPPath:   "/restapis/{restapi_id}/requestvalidators/{requestvalidator_id}",
2687	}
2688
2689	if input == nil {
2690		input = &DeleteRequestValidatorInput{}
2691	}
2692
2693	output = &DeleteRequestValidatorOutput{}
2694	req = c.newRequest(op, input, output)
2695	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2696	return
2697}
2698
2699// DeleteRequestValidator API operation for Amazon API Gateway.
2700//
2701// Deletes a RequestValidator of a given RestApi.
2702//
2703// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2704// with awserr.Error's Code and Message methods to get detailed information about
2705// the error.
2706//
2707// See the AWS API reference guide for Amazon API Gateway's
2708// API operation DeleteRequestValidator for usage and error information.
2709//
2710// Returned Error Codes:
2711//   * ErrCodeUnauthorizedException "UnauthorizedException"
2712//   The request is denied because the caller has insufficient permissions.
2713//
2714//   * ErrCodeNotFoundException "NotFoundException"
2715//   The requested resource is not found. Make sure that the request URI is correct.
2716//
2717//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2718//   The request has reached its throttling limit. Retry after the specified time
2719//   period.
2720//
2721//   * ErrCodeBadRequestException "BadRequestException"
2722//   The submitted request is not valid, for example, the input is incomplete
2723//   or incorrect. See the accompanying error message for details.
2724//
2725//   * ErrCodeConflictException "ConflictException"
2726//   The request configuration has conflicts. For details, see the accompanying
2727//   error message.
2728//
2729func (c *APIGateway) DeleteRequestValidator(input *DeleteRequestValidatorInput) (*DeleteRequestValidatorOutput, error) {
2730	req, out := c.DeleteRequestValidatorRequest(input)
2731	return out, req.Send()
2732}
2733
2734// DeleteRequestValidatorWithContext is the same as DeleteRequestValidator with the addition of
2735// the ability to pass a context and additional request options.
2736//
2737// See DeleteRequestValidator for details on how to use this API operation.
2738//
2739// The context must be non-nil and will be used for request cancellation. If
2740// the context is nil a panic will occur. In the future the SDK may create
2741// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2742// for more information on using Contexts.
2743func (c *APIGateway) DeleteRequestValidatorWithContext(ctx aws.Context, input *DeleteRequestValidatorInput, opts ...request.Option) (*DeleteRequestValidatorOutput, error) {
2744	req, out := c.DeleteRequestValidatorRequest(input)
2745	req.SetContext(ctx)
2746	req.ApplyOptions(opts...)
2747	return out, req.Send()
2748}
2749
2750const opDeleteResource = "DeleteResource"
2751
2752// DeleteResourceRequest generates a "aws/request.Request" representing the
2753// client's request for the DeleteResource operation. The "output" return
2754// value will be populated with the request's response once the request completes
2755// successfully.
2756//
2757// Use "Send" method on the returned Request to send the API call to the service.
2758// the "output" return value is not valid until after Send returns without error.
2759//
2760// See DeleteResource for more information on using the DeleteResource
2761// API call, and error handling.
2762//
2763// This method is useful when you want to inject custom logic or configuration
2764// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2765//
2766//
2767//    // Example sending a request using the DeleteResourceRequest method.
2768//    req, resp := client.DeleteResourceRequest(params)
2769//
2770//    err := req.Send()
2771//    if err == nil { // resp is now filled
2772//        fmt.Println(resp)
2773//    }
2774func (c *APIGateway) DeleteResourceRequest(input *DeleteResourceInput) (req *request.Request, output *DeleteResourceOutput) {
2775	op := &request.Operation{
2776		Name:       opDeleteResource,
2777		HTTPMethod: "DELETE",
2778		HTTPPath:   "/restapis/{restapi_id}/resources/{resource_id}",
2779	}
2780
2781	if input == nil {
2782		input = &DeleteResourceInput{}
2783	}
2784
2785	output = &DeleteResourceOutput{}
2786	req = c.newRequest(op, input, output)
2787	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2788	return
2789}
2790
2791// DeleteResource API operation for Amazon API Gateway.
2792//
2793// Deletes a Resource resource.
2794//
2795// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2796// with awserr.Error's Code and Message methods to get detailed information about
2797// the error.
2798//
2799// See the AWS API reference guide for Amazon API Gateway's
2800// API operation DeleteResource for usage and error information.
2801//
2802// Returned Error Codes:
2803//   * ErrCodeUnauthorizedException "UnauthorizedException"
2804//   The request is denied because the caller has insufficient permissions.
2805//
2806//   * ErrCodeNotFoundException "NotFoundException"
2807//   The requested resource is not found. Make sure that the request URI is correct.
2808//
2809//   * ErrCodeBadRequestException "BadRequestException"
2810//   The submitted request is not valid, for example, the input is incomplete
2811//   or incorrect. See the accompanying error message for details.
2812//
2813//   * ErrCodeConflictException "ConflictException"
2814//   The request configuration has conflicts. For details, see the accompanying
2815//   error message.
2816//
2817//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2818//   The request has reached its throttling limit. Retry after the specified time
2819//   period.
2820//
2821func (c *APIGateway) DeleteResource(input *DeleteResourceInput) (*DeleteResourceOutput, error) {
2822	req, out := c.DeleteResourceRequest(input)
2823	return out, req.Send()
2824}
2825
2826// DeleteResourceWithContext is the same as DeleteResource with the addition of
2827// the ability to pass a context and additional request options.
2828//
2829// See DeleteResource for details on how to use this API operation.
2830//
2831// The context must be non-nil and will be used for request cancellation. If
2832// the context is nil a panic will occur. In the future the SDK may create
2833// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2834// for more information on using Contexts.
2835func (c *APIGateway) DeleteResourceWithContext(ctx aws.Context, input *DeleteResourceInput, opts ...request.Option) (*DeleteResourceOutput, error) {
2836	req, out := c.DeleteResourceRequest(input)
2837	req.SetContext(ctx)
2838	req.ApplyOptions(opts...)
2839	return out, req.Send()
2840}
2841
2842const opDeleteRestApi = "DeleteRestApi"
2843
2844// DeleteRestApiRequest generates a "aws/request.Request" representing the
2845// client's request for the DeleteRestApi operation. The "output" return
2846// value will be populated with the request's response once the request completes
2847// successfully.
2848//
2849// Use "Send" method on the returned Request to send the API call to the service.
2850// the "output" return value is not valid until after Send returns without error.
2851//
2852// See DeleteRestApi for more information on using the DeleteRestApi
2853// API call, and error handling.
2854//
2855// This method is useful when you want to inject custom logic or configuration
2856// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2857//
2858//
2859//    // Example sending a request using the DeleteRestApiRequest method.
2860//    req, resp := client.DeleteRestApiRequest(params)
2861//
2862//    err := req.Send()
2863//    if err == nil { // resp is now filled
2864//        fmt.Println(resp)
2865//    }
2866func (c *APIGateway) DeleteRestApiRequest(input *DeleteRestApiInput) (req *request.Request, output *DeleteRestApiOutput) {
2867	op := &request.Operation{
2868		Name:       opDeleteRestApi,
2869		HTTPMethod: "DELETE",
2870		HTTPPath:   "/restapis/{restapi_id}",
2871	}
2872
2873	if input == nil {
2874		input = &DeleteRestApiInput{}
2875	}
2876
2877	output = &DeleteRestApiOutput{}
2878	req = c.newRequest(op, input, output)
2879	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2880	return
2881}
2882
2883// DeleteRestApi API operation for Amazon API Gateway.
2884//
2885// Deletes the specified API.
2886//
2887// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2888// with awserr.Error's Code and Message methods to get detailed information about
2889// the error.
2890//
2891// See the AWS API reference guide for Amazon API Gateway's
2892// API operation DeleteRestApi for usage and error information.
2893//
2894// Returned Error Codes:
2895//   * ErrCodeUnauthorizedException "UnauthorizedException"
2896//   The request is denied because the caller has insufficient permissions.
2897//
2898//   * ErrCodeNotFoundException "NotFoundException"
2899//   The requested resource is not found. Make sure that the request URI is correct.
2900//
2901//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2902//   The request has reached its throttling limit. Retry after the specified time
2903//   period.
2904//
2905//   * ErrCodeBadRequestException "BadRequestException"
2906//   The submitted request is not valid, for example, the input is incomplete
2907//   or incorrect. See the accompanying error message for details.
2908//
2909func (c *APIGateway) DeleteRestApi(input *DeleteRestApiInput) (*DeleteRestApiOutput, error) {
2910	req, out := c.DeleteRestApiRequest(input)
2911	return out, req.Send()
2912}
2913
2914// DeleteRestApiWithContext is the same as DeleteRestApi with the addition of
2915// the ability to pass a context and additional request options.
2916//
2917// See DeleteRestApi for details on how to use this API operation.
2918//
2919// The context must be non-nil and will be used for request cancellation. If
2920// the context is nil a panic will occur. In the future the SDK may create
2921// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2922// for more information on using Contexts.
2923func (c *APIGateway) DeleteRestApiWithContext(ctx aws.Context, input *DeleteRestApiInput, opts ...request.Option) (*DeleteRestApiOutput, error) {
2924	req, out := c.DeleteRestApiRequest(input)
2925	req.SetContext(ctx)
2926	req.ApplyOptions(opts...)
2927	return out, req.Send()
2928}
2929
2930const opDeleteStage = "DeleteStage"
2931
2932// DeleteStageRequest generates a "aws/request.Request" representing the
2933// client's request for the DeleteStage operation. The "output" return
2934// value will be populated with the request's response once the request completes
2935// successfully.
2936//
2937// Use "Send" method on the returned Request to send the API call to the service.
2938// the "output" return value is not valid until after Send returns without error.
2939//
2940// See DeleteStage for more information on using the DeleteStage
2941// API call, and error handling.
2942//
2943// This method is useful when you want to inject custom logic or configuration
2944// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2945//
2946//
2947//    // Example sending a request using the DeleteStageRequest method.
2948//    req, resp := client.DeleteStageRequest(params)
2949//
2950//    err := req.Send()
2951//    if err == nil { // resp is now filled
2952//        fmt.Println(resp)
2953//    }
2954func (c *APIGateway) DeleteStageRequest(input *DeleteStageInput) (req *request.Request, output *DeleteStageOutput) {
2955	op := &request.Operation{
2956		Name:       opDeleteStage,
2957		HTTPMethod: "DELETE",
2958		HTTPPath:   "/restapis/{restapi_id}/stages/{stage_name}",
2959	}
2960
2961	if input == nil {
2962		input = &DeleteStageInput{}
2963	}
2964
2965	output = &DeleteStageOutput{}
2966	req = c.newRequest(op, input, output)
2967	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2968	return
2969}
2970
2971// DeleteStage API operation for Amazon API Gateway.
2972//
2973// Deletes a Stage resource.
2974//
2975// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2976// with awserr.Error's Code and Message methods to get detailed information about
2977// the error.
2978//
2979// See the AWS API reference guide for Amazon API Gateway's
2980// API operation DeleteStage for usage and error information.
2981//
2982// Returned Error Codes:
2983//   * ErrCodeUnauthorizedException "UnauthorizedException"
2984//   The request is denied because the caller has insufficient permissions.
2985//
2986//   * ErrCodeNotFoundException "NotFoundException"
2987//   The requested resource is not found. Make sure that the request URI is correct.
2988//
2989//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
2990//   The request has reached its throttling limit. Retry after the specified time
2991//   period.
2992//
2993//   * ErrCodeBadRequestException "BadRequestException"
2994//   The submitted request is not valid, for example, the input is incomplete
2995//   or incorrect. See the accompanying error message for details.
2996//
2997func (c *APIGateway) DeleteStage(input *DeleteStageInput) (*DeleteStageOutput, error) {
2998	req, out := c.DeleteStageRequest(input)
2999	return out, req.Send()
3000}
3001
3002// DeleteStageWithContext is the same as DeleteStage with the addition of
3003// the ability to pass a context and additional request options.
3004//
3005// See DeleteStage for details on how to use this API operation.
3006//
3007// The context must be non-nil and will be used for request cancellation. If
3008// the context is nil a panic will occur. In the future the SDK may create
3009// sub-contexts for http.Requests. See https://golang.org/pkg/context/
3010// for more information on using Contexts.
3011func (c *APIGateway) DeleteStageWithContext(ctx aws.Context, input *DeleteStageInput, opts ...request.Option) (*DeleteStageOutput, error) {
3012	req, out := c.DeleteStageRequest(input)
3013	req.SetContext(ctx)
3014	req.ApplyOptions(opts...)
3015	return out, req.Send()
3016}
3017
3018const opDeleteUsagePlan = "DeleteUsagePlan"
3019
3020// DeleteUsagePlanRequest generates a "aws/request.Request" representing the
3021// client's request for the DeleteUsagePlan operation. The "output" return
3022// value will be populated with the request's response once the request completes
3023// successfully.
3024//
3025// Use "Send" method on the returned Request to send the API call to the service.
3026// the "output" return value is not valid until after Send returns without error.
3027//
3028// See DeleteUsagePlan for more information on using the DeleteUsagePlan
3029// API call, and error handling.
3030//
3031// This method is useful when you want to inject custom logic or configuration
3032// into the SDK's request lifecycle. Such as custom headers, or retry logic.
3033//
3034//
3035//    // Example sending a request using the DeleteUsagePlanRequest method.
3036//    req, resp := client.DeleteUsagePlanRequest(params)
3037//
3038//    err := req.Send()
3039//    if err == nil { // resp is now filled
3040//        fmt.Println(resp)
3041//    }
3042func (c *APIGateway) DeleteUsagePlanRequest(input *DeleteUsagePlanInput) (req *request.Request, output *DeleteUsagePlanOutput) {
3043	op := &request.Operation{
3044		Name:       opDeleteUsagePlan,
3045		HTTPMethod: "DELETE",
3046		HTTPPath:   "/usageplans/{usageplanId}",
3047	}
3048
3049	if input == nil {
3050		input = &DeleteUsagePlanInput{}
3051	}
3052
3053	output = &DeleteUsagePlanOutput{}
3054	req = c.newRequest(op, input, output)
3055	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
3056	return
3057}
3058
3059// DeleteUsagePlan API operation for Amazon API Gateway.
3060//
3061// Deletes a usage plan of a given plan Id.
3062//
3063// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
3064// with awserr.Error's Code and Message methods to get detailed information about
3065// the error.
3066//
3067// See the AWS API reference guide for Amazon API Gateway's
3068// API operation DeleteUsagePlan for usage and error information.
3069//
3070// Returned Error Codes:
3071//   * ErrCodeUnauthorizedException "UnauthorizedException"
3072//   The request is denied because the caller has insufficient permissions.
3073//
3074//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
3075//   The request has reached its throttling limit. Retry after the specified time
3076//   period.
3077//
3078//   * ErrCodeBadRequestException "BadRequestException"
3079//   The submitted request is not valid, for example, the input is incomplete
3080//   or incorrect. See the accompanying error message for details.
3081//
3082//   * ErrCodeNotFoundException "NotFoundException"
3083//   The requested resource is not found. Make sure that the request URI is correct.
3084//
3085func (c *APIGateway) DeleteUsagePlan(input *DeleteUsagePlanInput) (*DeleteUsagePlanOutput, error) {
3086	req, out := c.DeleteUsagePlanRequest(input)
3087	return out, req.Send()
3088}
3089
3090// DeleteUsagePlanWithContext is the same as DeleteUsagePlan with the addition of
3091// the ability to pass a context and additional request options.
3092//
3093// See DeleteUsagePlan for details on how to use this API operation.
3094//
3095// The context must be non-nil and will be used for request cancellation. If
3096// the context is nil a panic will occur. In the future the SDK may create
3097// sub-contexts for http.Requests. See https://golang.org/pkg/context/
3098// for more information on using Contexts.
3099func (c *APIGateway) DeleteUsagePlanWithContext(ctx aws.Context, input *DeleteUsagePlanInput, opts ...request.Option) (*DeleteUsagePlanOutput, error) {
3100	req, out := c.DeleteUsagePlanRequest(input)
3101	req.SetContext(ctx)
3102	req.ApplyOptions(opts...)
3103	return out, req.Send()
3104}
3105
3106const opDeleteUsagePlanKey = "DeleteUsagePlanKey"
3107
3108// DeleteUsagePlanKeyRequest generates a "aws/request.Request" representing the
3109// client's request for the DeleteUsagePlanKey operation. The "output" return
3110// value will be populated with the request's response once the request completes
3111// successfully.
3112//
3113// Use "Send" method on the returned Request to send the API call to the service.
3114// the "output" return value is not valid until after Send returns without error.
3115//
3116// See DeleteUsagePlanKey for more information on using the DeleteUsagePlanKey
3117// API call, and error handling.
3118//
3119// This method is useful when you want to inject custom logic or configuration
3120// into the SDK's request lifecycle. Such as custom headers, or retry logic.
3121//
3122//
3123//    // Example sending a request using the DeleteUsagePlanKeyRequest method.
3124//    req, resp := client.DeleteUsagePlanKeyRequest(params)
3125//
3126//    err := req.Send()
3127//    if err == nil { // resp is now filled
3128//        fmt.Println(resp)
3129//    }
3130func (c *APIGateway) DeleteUsagePlanKeyRequest(input *DeleteUsagePlanKeyInput) (req *request.Request, output *DeleteUsagePlanKeyOutput) {
3131	op := &request.Operation{
3132		Name:       opDeleteUsagePlanKey,
3133		HTTPMethod: "DELETE",
3134		HTTPPath:   "/usageplans/{usageplanId}/keys/{keyId}",
3135	}
3136
3137	if input == nil {
3138		input = &DeleteUsagePlanKeyInput{}
3139	}
3140
3141	output = &DeleteUsagePlanKeyOutput{}
3142	req = c.newRequest(op, input, output)
3143	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
3144	return
3145}
3146
3147// DeleteUsagePlanKey API operation for Amazon API Gateway.
3148//
3149// Deletes a usage plan key and remove the underlying API key from the associated
3150// usage plan.
3151//
3152// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
3153// with awserr.Error's Code and Message methods to get detailed information about
3154// the error.
3155//
3156// See the AWS API reference guide for Amazon API Gateway's
3157// API operation DeleteUsagePlanKey for usage and error information.
3158//
3159// Returned Error Codes:
3160//   * ErrCodeBadRequestException "BadRequestException"
3161//   The submitted request is not valid, for example, the input is incomplete
3162//   or incorrect. See the accompanying error message for details.
3163//
3164//   * ErrCodeConflictException "ConflictException"
3165//   The request configuration has conflicts. For details, see the accompanying
3166//   error message.
3167//
3168//   * ErrCodeUnauthorizedException "UnauthorizedException"
3169//   The request is denied because the caller has insufficient permissions.
3170//
3171//   * ErrCodeNotFoundException "NotFoundException"
3172//   The requested resource is not found. Make sure that the request URI is correct.
3173//
3174//   * ErrCodeTooManyRequestsException "TooManyRequestsException"
3175//   The request has reached its throttling limit. Retry after the specified time
3176//   period.
3177//
3178func (c *APIGateway) DeleteUsagePlanKey(input *DeleteUsagePlanKeyInput) (*DeleteUsagePlanKeyOutput, error) {
3179	req, out := c.DeleteUsagePlanKeyRequest(input)
3180	return out, req.Send()
3181}
3182
3183// DeleteUsagePlanKeyWithContext is the same as DeleteUsagePlanKey with the addition of
3184// the ability to pass a context and additional request options.
3185//
3186// See DeleteUsagePlanKey for details on how to use this API operation.
3187//
3188// The context must be non-nil and will be used for request cancellation. If
3189// the context is nil a panic will occur. In the future the SDK may create
3190// sub-contexts for http.Requests. See https://golang.org/pkg/context/
3191// for more information on using Contexts.
3192func (c *APIGateway) DeleteUsagePlanKeyWithContext(ctx aws.Context, input *DeleteUsagePlanKeyInput, opts ...request.Option) (*DeleteUsagePlanKeyOutput, error) {
3193	req, out := c.DeleteUsagePlanKeyRequest(input)
3194	req.SetContext(ctx)
3195	req.ApplyOptions(opts...)
3196	return out, req.Send()
3197}
3198
3199const opDeleteVpcLink = "DeleteVpcLink"
3200
3201// DeleteVpcLinkRequest generates a "aws/request.Request" representing the
3202// client's request for the DeleteVpcLink operation. The "output" return
3203// value will be populated with the request's response once the request completes
3204// successfully.
3205//
3206// Use "Send" method on the returned Request to send the API call to the service.
3207// the "output" return value is not valid until after Send returns without error.
3208//
3209// See DeleteVpcLink for more information on using the DeleteVpcLink
3210// API call, and error handling.
3211//
3212// This method is useful when you want to inject custom logic or configuration
3213// into the SDK's request lif