1// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
2
3package codepipeline
4
5import (
6	"fmt"
7	"time"
8
9	"github.com/aws/aws-sdk-go/aws"
10	"github.com/aws/aws-sdk-go/aws/awsutil"
11	"github.com/aws/aws-sdk-go/aws/request"
12	"github.com/aws/aws-sdk-go/private/protocol"
13	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
14)
15
16const opAcknowledgeJob = "AcknowledgeJob"
17
18// AcknowledgeJobRequest generates a "aws/request.Request" representing the
19// client's request for the AcknowledgeJob operation. The "output" return
20// value will be populated with the request's response once the request completes
21// successfully.
22//
23// Use "Send" method on the returned Request to send the API call to the service.
24// the "output" return value is not valid until after Send returns without error.
25//
26// See AcknowledgeJob for more information on using the AcknowledgeJob
27// API call, and error handling.
28//
29// This method is useful when you want to inject custom logic or configuration
30// into the SDK's request lifecycle. Such as custom headers, or retry logic.
31//
32//
33//    // Example sending a request using the AcknowledgeJobRequest method.
34//    req, resp := client.AcknowledgeJobRequest(params)
35//
36//    err := req.Send()
37//    if err == nil { // resp is now filled
38//        fmt.Println(resp)
39//    }
40//
41// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/AcknowledgeJob
42func (c *CodePipeline) AcknowledgeJobRequest(input *AcknowledgeJobInput) (req *request.Request, output *AcknowledgeJobOutput) {
43	op := &request.Operation{
44		Name:       opAcknowledgeJob,
45		HTTPMethod: "POST",
46		HTTPPath:   "/",
47	}
48
49	if input == nil {
50		input = &AcknowledgeJobInput{}
51	}
52
53	output = &AcknowledgeJobOutput{}
54	req = c.newRequest(op, input, output)
55	return
56}
57
58// AcknowledgeJob API operation for AWS CodePipeline.
59//
60// Returns information about a specified job and whether that job has been received
61// by the job worker. Used for custom actions only.
62//
63// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
64// with awserr.Error's Code and Message methods to get detailed information about
65// the error.
66//
67// See the AWS API reference guide for AWS CodePipeline's
68// API operation AcknowledgeJob for usage and error information.
69//
70// Returned Error Codes:
71//   * ErrCodeValidationException "ValidationException"
72//   The validation was specified in an invalid format.
73//
74//   * ErrCodeInvalidNonceException "InvalidNonceException"
75//   The nonce was specified in an invalid format.
76//
77//   * ErrCodeJobNotFoundException "JobNotFoundException"
78//   The job was specified in an invalid format or cannot be found.
79//
80// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/AcknowledgeJob
81func (c *CodePipeline) AcknowledgeJob(input *AcknowledgeJobInput) (*AcknowledgeJobOutput, error) {
82	req, out := c.AcknowledgeJobRequest(input)
83	return out, req.Send()
84}
85
86// AcknowledgeJobWithContext is the same as AcknowledgeJob with the addition of
87// the ability to pass a context and additional request options.
88//
89// See AcknowledgeJob for details on how to use this API operation.
90//
91// The context must be non-nil and will be used for request cancellation. If
92// the context is nil a panic will occur. In the future the SDK may create
93// sub-contexts for http.Requests. See https://golang.org/pkg/context/
94// for more information on using Contexts.
95func (c *CodePipeline) AcknowledgeJobWithContext(ctx aws.Context, input *AcknowledgeJobInput, opts ...request.Option) (*AcknowledgeJobOutput, error) {
96	req, out := c.AcknowledgeJobRequest(input)
97	req.SetContext(ctx)
98	req.ApplyOptions(opts...)
99	return out, req.Send()
100}
101
102const opAcknowledgeThirdPartyJob = "AcknowledgeThirdPartyJob"
103
104// AcknowledgeThirdPartyJobRequest generates a "aws/request.Request" representing the
105// client's request for the AcknowledgeThirdPartyJob operation. The "output" return
106// value will be populated with the request's response once the request completes
107// successfully.
108//
109// Use "Send" method on the returned Request to send the API call to the service.
110// the "output" return value is not valid until after Send returns without error.
111//
112// See AcknowledgeThirdPartyJob for more information on using the AcknowledgeThirdPartyJob
113// API call, and error handling.
114//
115// This method is useful when you want to inject custom logic or configuration
116// into the SDK's request lifecycle. Such as custom headers, or retry logic.
117//
118//
119//    // Example sending a request using the AcknowledgeThirdPartyJobRequest method.
120//    req, resp := client.AcknowledgeThirdPartyJobRequest(params)
121//
122//    err := req.Send()
123//    if err == nil { // resp is now filled
124//        fmt.Println(resp)
125//    }
126//
127// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/AcknowledgeThirdPartyJob
128func (c *CodePipeline) AcknowledgeThirdPartyJobRequest(input *AcknowledgeThirdPartyJobInput) (req *request.Request, output *AcknowledgeThirdPartyJobOutput) {
129	op := &request.Operation{
130		Name:       opAcknowledgeThirdPartyJob,
131		HTTPMethod: "POST",
132		HTTPPath:   "/",
133	}
134
135	if input == nil {
136		input = &AcknowledgeThirdPartyJobInput{}
137	}
138
139	output = &AcknowledgeThirdPartyJobOutput{}
140	req = c.newRequest(op, input, output)
141	return
142}
143
144// AcknowledgeThirdPartyJob API operation for AWS CodePipeline.
145//
146// Confirms a job worker has received the specified job. Used for partner actions
147// only.
148//
149// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
150// with awserr.Error's Code and Message methods to get detailed information about
151// the error.
152//
153// See the AWS API reference guide for AWS CodePipeline's
154// API operation AcknowledgeThirdPartyJob for usage and error information.
155//
156// Returned Error Codes:
157//   * ErrCodeValidationException "ValidationException"
158//   The validation was specified in an invalid format.
159//
160//   * ErrCodeInvalidNonceException "InvalidNonceException"
161//   The nonce was specified in an invalid format.
162//
163//   * ErrCodeJobNotFoundException "JobNotFoundException"
164//   The job was specified in an invalid format or cannot be found.
165//
166//   * ErrCodeInvalidClientTokenException "InvalidClientTokenException"
167//   The client token was specified in an invalid format
168//
169// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/AcknowledgeThirdPartyJob
170func (c *CodePipeline) AcknowledgeThirdPartyJob(input *AcknowledgeThirdPartyJobInput) (*AcknowledgeThirdPartyJobOutput, error) {
171	req, out := c.AcknowledgeThirdPartyJobRequest(input)
172	return out, req.Send()
173}
174
175// AcknowledgeThirdPartyJobWithContext is the same as AcknowledgeThirdPartyJob with the addition of
176// the ability to pass a context and additional request options.
177//
178// See AcknowledgeThirdPartyJob for details on how to use this API operation.
179//
180// The context must be non-nil and will be used for request cancellation. If
181// the context is nil a panic will occur. In the future the SDK may create
182// sub-contexts for http.Requests. See https://golang.org/pkg/context/
183// for more information on using Contexts.
184func (c *CodePipeline) AcknowledgeThirdPartyJobWithContext(ctx aws.Context, input *AcknowledgeThirdPartyJobInput, opts ...request.Option) (*AcknowledgeThirdPartyJobOutput, error) {
185	req, out := c.AcknowledgeThirdPartyJobRequest(input)
186	req.SetContext(ctx)
187	req.ApplyOptions(opts...)
188	return out, req.Send()
189}
190
191const opCreateCustomActionType = "CreateCustomActionType"
192
193// CreateCustomActionTypeRequest generates a "aws/request.Request" representing the
194// client's request for the CreateCustomActionType operation. The "output" return
195// value will be populated with the request's response once the request completes
196// successfully.
197//
198// Use "Send" method on the returned Request to send the API call to the service.
199// the "output" return value is not valid until after Send returns without error.
200//
201// See CreateCustomActionType for more information on using the CreateCustomActionType
202// API call, and error handling.
203//
204// This method is useful when you want to inject custom logic or configuration
205// into the SDK's request lifecycle. Such as custom headers, or retry logic.
206//
207//
208//    // Example sending a request using the CreateCustomActionTypeRequest method.
209//    req, resp := client.CreateCustomActionTypeRequest(params)
210//
211//    err := req.Send()
212//    if err == nil { // resp is now filled
213//        fmt.Println(resp)
214//    }
215//
216// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/CreateCustomActionType
217func (c *CodePipeline) CreateCustomActionTypeRequest(input *CreateCustomActionTypeInput) (req *request.Request, output *CreateCustomActionTypeOutput) {
218	op := &request.Operation{
219		Name:       opCreateCustomActionType,
220		HTTPMethod: "POST",
221		HTTPPath:   "/",
222	}
223
224	if input == nil {
225		input = &CreateCustomActionTypeInput{}
226	}
227
228	output = &CreateCustomActionTypeOutput{}
229	req = c.newRequest(op, input, output)
230	return
231}
232
233// CreateCustomActionType API operation for AWS CodePipeline.
234//
235// Creates a new custom action that can be used in all pipelines associated
236// with the AWS account. Only used for custom actions.
237//
238// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
239// with awserr.Error's Code and Message methods to get detailed information about
240// the error.
241//
242// See the AWS API reference guide for AWS CodePipeline's
243// API operation CreateCustomActionType for usage and error information.
244//
245// Returned Error Codes:
246//   * ErrCodeValidationException "ValidationException"
247//   The validation was specified in an invalid format.
248//
249//   * ErrCodeLimitExceededException "LimitExceededException"
250//   The number of pipelines associated with the AWS account has exceeded the
251//   limit allowed for the account.
252//
253//   * ErrCodeTooManyTagsException "TooManyTagsException"
254//   The tags limit for a resource has been exceeded.
255//
256//   * ErrCodeInvalidTagsException "InvalidTagsException"
257//   The specified resource tags are invalid.
258//
259//   * ErrCodeConcurrentModificationException "ConcurrentModificationException"
260//   Unable to modify the tag due to a simultaneous update request.
261//
262// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/CreateCustomActionType
263func (c *CodePipeline) CreateCustomActionType(input *CreateCustomActionTypeInput) (*CreateCustomActionTypeOutput, error) {
264	req, out := c.CreateCustomActionTypeRequest(input)
265	return out, req.Send()
266}
267
268// CreateCustomActionTypeWithContext is the same as CreateCustomActionType with the addition of
269// the ability to pass a context and additional request options.
270//
271// See CreateCustomActionType for details on how to use this API operation.
272//
273// The context must be non-nil and will be used for request cancellation. If
274// the context is nil a panic will occur. In the future the SDK may create
275// sub-contexts for http.Requests. See https://golang.org/pkg/context/
276// for more information on using Contexts.
277func (c *CodePipeline) CreateCustomActionTypeWithContext(ctx aws.Context, input *CreateCustomActionTypeInput, opts ...request.Option) (*CreateCustomActionTypeOutput, error) {
278	req, out := c.CreateCustomActionTypeRequest(input)
279	req.SetContext(ctx)
280	req.ApplyOptions(opts...)
281	return out, req.Send()
282}
283
284const opCreatePipeline = "CreatePipeline"
285
286// CreatePipelineRequest generates a "aws/request.Request" representing the
287// client's request for the CreatePipeline operation. The "output" return
288// value will be populated with the request's response once the request completes
289// successfully.
290//
291// Use "Send" method on the returned Request to send the API call to the service.
292// the "output" return value is not valid until after Send returns without error.
293//
294// See CreatePipeline for more information on using the CreatePipeline
295// API call, and error handling.
296//
297// This method is useful when you want to inject custom logic or configuration
298// into the SDK's request lifecycle. Such as custom headers, or retry logic.
299//
300//
301//    // Example sending a request using the CreatePipelineRequest method.
302//    req, resp := client.CreatePipelineRequest(params)
303//
304//    err := req.Send()
305//    if err == nil { // resp is now filled
306//        fmt.Println(resp)
307//    }
308//
309// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/CreatePipeline
310func (c *CodePipeline) CreatePipelineRequest(input *CreatePipelineInput) (req *request.Request, output *CreatePipelineOutput) {
311	op := &request.Operation{
312		Name:       opCreatePipeline,
313		HTTPMethod: "POST",
314		HTTPPath:   "/",
315	}
316
317	if input == nil {
318		input = &CreatePipelineInput{}
319	}
320
321	output = &CreatePipelineOutput{}
322	req = c.newRequest(op, input, output)
323	return
324}
325
326// CreatePipeline API operation for AWS CodePipeline.
327//
328// Creates a pipeline.
329//
330// In the pipeline structure, you must include either artifactStore or artifactStores
331// in your pipeline, but you cannot use both. If you create a cross-region action
332// in your pipeline, you must use artifactStores.
333//
334// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
335// with awserr.Error's Code and Message methods to get detailed information about
336// the error.
337//
338// See the AWS API reference guide for AWS CodePipeline's
339// API operation CreatePipeline for usage and error information.
340//
341// Returned Error Codes:
342//   * ErrCodeValidationException "ValidationException"
343//   The validation was specified in an invalid format.
344//
345//   * ErrCodePipelineNameInUseException "PipelineNameInUseException"
346//   The specified pipeline name is already in use.
347//
348//   * ErrCodeInvalidStageDeclarationException "InvalidStageDeclarationException"
349//   The stage declaration was specified in an invalid format.
350//
351//   * ErrCodeInvalidActionDeclarationException "InvalidActionDeclarationException"
352//   The action declaration was specified in an invalid format.
353//
354//   * ErrCodeInvalidBlockerDeclarationException "InvalidBlockerDeclarationException"
355//   Reserved for future use.
356//
357//   * ErrCodeInvalidStructureException "InvalidStructureException"
358//   The structure was specified in an invalid format.
359//
360//   * ErrCodeLimitExceededException "LimitExceededException"
361//   The number of pipelines associated with the AWS account has exceeded the
362//   limit allowed for the account.
363//
364//   * ErrCodeTooManyTagsException "TooManyTagsException"
365//   The tags limit for a resource has been exceeded.
366//
367//   * ErrCodeInvalidTagsException "InvalidTagsException"
368//   The specified resource tags are invalid.
369//
370//   * ErrCodeConcurrentModificationException "ConcurrentModificationException"
371//   Unable to modify the tag due to a simultaneous update request.
372//
373// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/CreatePipeline
374func (c *CodePipeline) CreatePipeline(input *CreatePipelineInput) (*CreatePipelineOutput, error) {
375	req, out := c.CreatePipelineRequest(input)
376	return out, req.Send()
377}
378
379// CreatePipelineWithContext is the same as CreatePipeline with the addition of
380// the ability to pass a context and additional request options.
381//
382// See CreatePipeline for details on how to use this API operation.
383//
384// The context must be non-nil and will be used for request cancellation. If
385// the context is nil a panic will occur. In the future the SDK may create
386// sub-contexts for http.Requests. See https://golang.org/pkg/context/
387// for more information on using Contexts.
388func (c *CodePipeline) CreatePipelineWithContext(ctx aws.Context, input *CreatePipelineInput, opts ...request.Option) (*CreatePipelineOutput, error) {
389	req, out := c.CreatePipelineRequest(input)
390	req.SetContext(ctx)
391	req.ApplyOptions(opts...)
392	return out, req.Send()
393}
394
395const opDeleteCustomActionType = "DeleteCustomActionType"
396
397// DeleteCustomActionTypeRequest generates a "aws/request.Request" representing the
398// client's request for the DeleteCustomActionType operation. The "output" return
399// value will be populated with the request's response once the request completes
400// successfully.
401//
402// Use "Send" method on the returned Request to send the API call to the service.
403// the "output" return value is not valid until after Send returns without error.
404//
405// See DeleteCustomActionType for more information on using the DeleteCustomActionType
406// API call, and error handling.
407//
408// This method is useful when you want to inject custom logic or configuration
409// into the SDK's request lifecycle. Such as custom headers, or retry logic.
410//
411//
412//    // Example sending a request using the DeleteCustomActionTypeRequest method.
413//    req, resp := client.DeleteCustomActionTypeRequest(params)
414//
415//    err := req.Send()
416//    if err == nil { // resp is now filled
417//        fmt.Println(resp)
418//    }
419//
420// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DeleteCustomActionType
421func (c *CodePipeline) DeleteCustomActionTypeRequest(input *DeleteCustomActionTypeInput) (req *request.Request, output *DeleteCustomActionTypeOutput) {
422	op := &request.Operation{
423		Name:       opDeleteCustomActionType,
424		HTTPMethod: "POST",
425		HTTPPath:   "/",
426	}
427
428	if input == nil {
429		input = &DeleteCustomActionTypeInput{}
430	}
431
432	output = &DeleteCustomActionTypeOutput{}
433	req = c.newRequest(op, input, output)
434	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
435	return
436}
437
438// DeleteCustomActionType API operation for AWS CodePipeline.
439//
440// Marks a custom action as deleted. PollForJobs for the custom action fails
441// after the action is marked for deletion. Used for custom actions only.
442//
443// To re-create a custom action after it has been deleted you must use a string
444// in the version field that has never been used before. This string can be
445// an incremented version number, for example. To restore a deleted custom action,
446// use a JSON file that is identical to the deleted action, including the original
447// string in the version field.
448//
449// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
450// with awserr.Error's Code and Message methods to get detailed information about
451// the error.
452//
453// See the AWS API reference guide for AWS CodePipeline's
454// API operation DeleteCustomActionType for usage and error information.
455//
456// Returned Error Codes:
457//   * ErrCodeValidationException "ValidationException"
458//   The validation was specified in an invalid format.
459//
460//   * ErrCodeConcurrentModificationException "ConcurrentModificationException"
461//   Unable to modify the tag due to a simultaneous update request.
462//
463// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DeleteCustomActionType
464func (c *CodePipeline) DeleteCustomActionType(input *DeleteCustomActionTypeInput) (*DeleteCustomActionTypeOutput, error) {
465	req, out := c.DeleteCustomActionTypeRequest(input)
466	return out, req.Send()
467}
468
469// DeleteCustomActionTypeWithContext is the same as DeleteCustomActionType with the addition of
470// the ability to pass a context and additional request options.
471//
472// See DeleteCustomActionType 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 *CodePipeline) DeleteCustomActionTypeWithContext(ctx aws.Context, input *DeleteCustomActionTypeInput, opts ...request.Option) (*DeleteCustomActionTypeOutput, error) {
479	req, out := c.DeleteCustomActionTypeRequest(input)
480	req.SetContext(ctx)
481	req.ApplyOptions(opts...)
482	return out, req.Send()
483}
484
485const opDeletePipeline = "DeletePipeline"
486
487// DeletePipelineRequest generates a "aws/request.Request" representing the
488// client's request for the DeletePipeline 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 DeletePipeline for more information on using the DeletePipeline
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 DeletePipelineRequest method.
503//    req, resp := client.DeletePipelineRequest(params)
504//
505//    err := req.Send()
506//    if err == nil { // resp is now filled
507//        fmt.Println(resp)
508//    }
509//
510// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DeletePipeline
511func (c *CodePipeline) DeletePipelineRequest(input *DeletePipelineInput) (req *request.Request, output *DeletePipelineOutput) {
512	op := &request.Operation{
513		Name:       opDeletePipeline,
514		HTTPMethod: "POST",
515		HTTPPath:   "/",
516	}
517
518	if input == nil {
519		input = &DeletePipelineInput{}
520	}
521
522	output = &DeletePipelineOutput{}
523	req = c.newRequest(op, input, output)
524	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
525	return
526}
527
528// DeletePipeline API operation for AWS CodePipeline.
529//
530// Deletes the specified pipeline.
531//
532// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
533// with awserr.Error's Code and Message methods to get detailed information about
534// the error.
535//
536// See the AWS API reference guide for AWS CodePipeline's
537// API operation DeletePipeline for usage and error information.
538//
539// Returned Error Codes:
540//   * ErrCodeValidationException "ValidationException"
541//   The validation was specified in an invalid format.
542//
543//   * ErrCodeConcurrentModificationException "ConcurrentModificationException"
544//   Unable to modify the tag due to a simultaneous update request.
545//
546// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DeletePipeline
547func (c *CodePipeline) DeletePipeline(input *DeletePipelineInput) (*DeletePipelineOutput, error) {
548	req, out := c.DeletePipelineRequest(input)
549	return out, req.Send()
550}
551
552// DeletePipelineWithContext is the same as DeletePipeline with the addition of
553// the ability to pass a context and additional request options.
554//
555// See DeletePipeline for details on how to use this API operation.
556//
557// The context must be non-nil and will be used for request cancellation. If
558// the context is nil a panic will occur. In the future the SDK may create
559// sub-contexts for http.Requests. See https://golang.org/pkg/context/
560// for more information on using Contexts.
561func (c *CodePipeline) DeletePipelineWithContext(ctx aws.Context, input *DeletePipelineInput, opts ...request.Option) (*DeletePipelineOutput, error) {
562	req, out := c.DeletePipelineRequest(input)
563	req.SetContext(ctx)
564	req.ApplyOptions(opts...)
565	return out, req.Send()
566}
567
568const opDeleteWebhook = "DeleteWebhook"
569
570// DeleteWebhookRequest generates a "aws/request.Request" representing the
571// client's request for the DeleteWebhook operation. The "output" return
572// value will be populated with the request's response once the request completes
573// successfully.
574//
575// Use "Send" method on the returned Request to send the API call to the service.
576// the "output" return value is not valid until after Send returns without error.
577//
578// See DeleteWebhook for more information on using the DeleteWebhook
579// API call, and error handling.
580//
581// This method is useful when you want to inject custom logic or configuration
582// into the SDK's request lifecycle. Such as custom headers, or retry logic.
583//
584//
585//    // Example sending a request using the DeleteWebhookRequest method.
586//    req, resp := client.DeleteWebhookRequest(params)
587//
588//    err := req.Send()
589//    if err == nil { // resp is now filled
590//        fmt.Println(resp)
591//    }
592//
593// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DeleteWebhook
594func (c *CodePipeline) DeleteWebhookRequest(input *DeleteWebhookInput) (req *request.Request, output *DeleteWebhookOutput) {
595	op := &request.Operation{
596		Name:       opDeleteWebhook,
597		HTTPMethod: "POST",
598		HTTPPath:   "/",
599	}
600
601	if input == nil {
602		input = &DeleteWebhookInput{}
603	}
604
605	output = &DeleteWebhookOutput{}
606	req = c.newRequest(op, input, output)
607	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
608	return
609}
610
611// DeleteWebhook API operation for AWS CodePipeline.
612//
613// Deletes a previously created webhook by name. Deleting the webhook stops
614// AWS CodePipeline from starting a pipeline every time an external event occurs.
615// The API returns successfully when trying to delete a webhook that is already
616// deleted. If a deleted webhook is re-created by calling PutWebhook with the
617// same name, it will have a different URL.
618//
619// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
620// with awserr.Error's Code and Message methods to get detailed information about
621// the error.
622//
623// See the AWS API reference guide for AWS CodePipeline's
624// API operation DeleteWebhook for usage and error information.
625//
626// Returned Error Codes:
627//   * ErrCodeValidationException "ValidationException"
628//   The validation was specified in an invalid format.
629//
630//   * ErrCodeConcurrentModificationException "ConcurrentModificationException"
631//   Unable to modify the tag due to a simultaneous update request.
632//
633// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DeleteWebhook
634func (c *CodePipeline) DeleteWebhook(input *DeleteWebhookInput) (*DeleteWebhookOutput, error) {
635	req, out := c.DeleteWebhookRequest(input)
636	return out, req.Send()
637}
638
639// DeleteWebhookWithContext is the same as DeleteWebhook with the addition of
640// the ability to pass a context and additional request options.
641//
642// See DeleteWebhook for details on how to use this API operation.
643//
644// The context must be non-nil and will be used for request cancellation. If
645// the context is nil a panic will occur. In the future the SDK may create
646// sub-contexts for http.Requests. See https://golang.org/pkg/context/
647// for more information on using Contexts.
648func (c *CodePipeline) DeleteWebhookWithContext(ctx aws.Context, input *DeleteWebhookInput, opts ...request.Option) (*DeleteWebhookOutput, error) {
649	req, out := c.DeleteWebhookRequest(input)
650	req.SetContext(ctx)
651	req.ApplyOptions(opts...)
652	return out, req.Send()
653}
654
655const opDeregisterWebhookWithThirdParty = "DeregisterWebhookWithThirdParty"
656
657// DeregisterWebhookWithThirdPartyRequest generates a "aws/request.Request" representing the
658// client's request for the DeregisterWebhookWithThirdParty operation. The "output" return
659// value will be populated with the request's response once the request completes
660// successfully.
661//
662// Use "Send" method on the returned Request to send the API call to the service.
663// the "output" return value is not valid until after Send returns without error.
664//
665// See DeregisterWebhookWithThirdParty for more information on using the DeregisterWebhookWithThirdParty
666// API call, and error handling.
667//
668// This method is useful when you want to inject custom logic or configuration
669// into the SDK's request lifecycle. Such as custom headers, or retry logic.
670//
671//
672//    // Example sending a request using the DeregisterWebhookWithThirdPartyRequest method.
673//    req, resp := client.DeregisterWebhookWithThirdPartyRequest(params)
674//
675//    err := req.Send()
676//    if err == nil { // resp is now filled
677//        fmt.Println(resp)
678//    }
679//
680// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DeregisterWebhookWithThirdParty
681func (c *CodePipeline) DeregisterWebhookWithThirdPartyRequest(input *DeregisterWebhookWithThirdPartyInput) (req *request.Request, output *DeregisterWebhookWithThirdPartyOutput) {
682	op := &request.Operation{
683		Name:       opDeregisterWebhookWithThirdParty,
684		HTTPMethod: "POST",
685		HTTPPath:   "/",
686	}
687
688	if input == nil {
689		input = &DeregisterWebhookWithThirdPartyInput{}
690	}
691
692	output = &DeregisterWebhookWithThirdPartyOutput{}
693	req = c.newRequest(op, input, output)
694	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
695	return
696}
697
698// DeregisterWebhookWithThirdParty API operation for AWS CodePipeline.
699//
700// Removes the connection between the webhook that was created by CodePipeline
701// and the external tool with events to be detected. Currently supported only
702// for webhooks that target an action type of GitHub.
703//
704// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
705// with awserr.Error's Code and Message methods to get detailed information about
706// the error.
707//
708// See the AWS API reference guide for AWS CodePipeline's
709// API operation DeregisterWebhookWithThirdParty for usage and error information.
710//
711// Returned Error Codes:
712//   * ErrCodeValidationException "ValidationException"
713//   The validation was specified in an invalid format.
714//
715//   * ErrCodeWebhookNotFoundException "WebhookNotFoundException"
716//   The specified webhook was entered in an invalid format or cannot be found.
717//
718// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DeregisterWebhookWithThirdParty
719func (c *CodePipeline) DeregisterWebhookWithThirdParty(input *DeregisterWebhookWithThirdPartyInput) (*DeregisterWebhookWithThirdPartyOutput, error) {
720	req, out := c.DeregisterWebhookWithThirdPartyRequest(input)
721	return out, req.Send()
722}
723
724// DeregisterWebhookWithThirdPartyWithContext is the same as DeregisterWebhookWithThirdParty with the addition of
725// the ability to pass a context and additional request options.
726//
727// See DeregisterWebhookWithThirdParty for details on how to use this API operation.
728//
729// The context must be non-nil and will be used for request cancellation. If
730// the context is nil a panic will occur. In the future the SDK may create
731// sub-contexts for http.Requests. See https://golang.org/pkg/context/
732// for more information on using Contexts.
733func (c *CodePipeline) DeregisterWebhookWithThirdPartyWithContext(ctx aws.Context, input *DeregisterWebhookWithThirdPartyInput, opts ...request.Option) (*DeregisterWebhookWithThirdPartyOutput, error) {
734	req, out := c.DeregisterWebhookWithThirdPartyRequest(input)
735	req.SetContext(ctx)
736	req.ApplyOptions(opts...)
737	return out, req.Send()
738}
739
740const opDisableStageTransition = "DisableStageTransition"
741
742// DisableStageTransitionRequest generates a "aws/request.Request" representing the
743// client's request for the DisableStageTransition operation. The "output" return
744// value will be populated with the request's response once the request completes
745// successfully.
746//
747// Use "Send" method on the returned Request to send the API call to the service.
748// the "output" return value is not valid until after Send returns without error.
749//
750// See DisableStageTransition for more information on using the DisableStageTransition
751// API call, and error handling.
752//
753// This method is useful when you want to inject custom logic or configuration
754// into the SDK's request lifecycle. Such as custom headers, or retry logic.
755//
756//
757//    // Example sending a request using the DisableStageTransitionRequest method.
758//    req, resp := client.DisableStageTransitionRequest(params)
759//
760//    err := req.Send()
761//    if err == nil { // resp is now filled
762//        fmt.Println(resp)
763//    }
764//
765// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DisableStageTransition
766func (c *CodePipeline) DisableStageTransitionRequest(input *DisableStageTransitionInput) (req *request.Request, output *DisableStageTransitionOutput) {
767	op := &request.Operation{
768		Name:       opDisableStageTransition,
769		HTTPMethod: "POST",
770		HTTPPath:   "/",
771	}
772
773	if input == nil {
774		input = &DisableStageTransitionInput{}
775	}
776
777	output = &DisableStageTransitionOutput{}
778	req = c.newRequest(op, input, output)
779	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
780	return
781}
782
783// DisableStageTransition API operation for AWS CodePipeline.
784//
785// Prevents artifacts in a pipeline from transitioning to the next stage in
786// the pipeline.
787//
788// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
789// with awserr.Error's Code and Message methods to get detailed information about
790// the error.
791//
792// See the AWS API reference guide for AWS CodePipeline's
793// API operation DisableStageTransition for usage and error information.
794//
795// Returned Error Codes:
796//   * ErrCodeValidationException "ValidationException"
797//   The validation was specified in an invalid format.
798//
799//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
800//   The pipeline was specified in an invalid format or cannot be found.
801//
802//   * ErrCodeStageNotFoundException "StageNotFoundException"
803//   The stage was specified in an invalid format or cannot be found.
804//
805// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/DisableStageTransition
806func (c *CodePipeline) DisableStageTransition(input *DisableStageTransitionInput) (*DisableStageTransitionOutput, error) {
807	req, out := c.DisableStageTransitionRequest(input)
808	return out, req.Send()
809}
810
811// DisableStageTransitionWithContext is the same as DisableStageTransition with the addition of
812// the ability to pass a context and additional request options.
813//
814// See DisableStageTransition for details on how to use this API operation.
815//
816// The context must be non-nil and will be used for request cancellation. If
817// the context is nil a panic will occur. In the future the SDK may create
818// sub-contexts for http.Requests. See https://golang.org/pkg/context/
819// for more information on using Contexts.
820func (c *CodePipeline) DisableStageTransitionWithContext(ctx aws.Context, input *DisableStageTransitionInput, opts ...request.Option) (*DisableStageTransitionOutput, error) {
821	req, out := c.DisableStageTransitionRequest(input)
822	req.SetContext(ctx)
823	req.ApplyOptions(opts...)
824	return out, req.Send()
825}
826
827const opEnableStageTransition = "EnableStageTransition"
828
829// EnableStageTransitionRequest generates a "aws/request.Request" representing the
830// client's request for the EnableStageTransition operation. The "output" return
831// value will be populated with the request's response once the request completes
832// successfully.
833//
834// Use "Send" method on the returned Request to send the API call to the service.
835// the "output" return value is not valid until after Send returns without error.
836//
837// See EnableStageTransition for more information on using the EnableStageTransition
838// API call, and error handling.
839//
840// This method is useful when you want to inject custom logic or configuration
841// into the SDK's request lifecycle. Such as custom headers, or retry logic.
842//
843//
844//    // Example sending a request using the EnableStageTransitionRequest method.
845//    req, resp := client.EnableStageTransitionRequest(params)
846//
847//    err := req.Send()
848//    if err == nil { // resp is now filled
849//        fmt.Println(resp)
850//    }
851//
852// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/EnableStageTransition
853func (c *CodePipeline) EnableStageTransitionRequest(input *EnableStageTransitionInput) (req *request.Request, output *EnableStageTransitionOutput) {
854	op := &request.Operation{
855		Name:       opEnableStageTransition,
856		HTTPMethod: "POST",
857		HTTPPath:   "/",
858	}
859
860	if input == nil {
861		input = &EnableStageTransitionInput{}
862	}
863
864	output = &EnableStageTransitionOutput{}
865	req = c.newRequest(op, input, output)
866	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
867	return
868}
869
870// EnableStageTransition API operation for AWS CodePipeline.
871//
872// Enables artifacts in a pipeline to transition to a stage in a pipeline.
873//
874// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
875// with awserr.Error's Code and Message methods to get detailed information about
876// the error.
877//
878// See the AWS API reference guide for AWS CodePipeline's
879// API operation EnableStageTransition for usage and error information.
880//
881// Returned Error Codes:
882//   * ErrCodeValidationException "ValidationException"
883//   The validation was specified in an invalid format.
884//
885//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
886//   The pipeline was specified in an invalid format or cannot be found.
887//
888//   * ErrCodeStageNotFoundException "StageNotFoundException"
889//   The stage was specified in an invalid format or cannot be found.
890//
891// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/EnableStageTransition
892func (c *CodePipeline) EnableStageTransition(input *EnableStageTransitionInput) (*EnableStageTransitionOutput, error) {
893	req, out := c.EnableStageTransitionRequest(input)
894	return out, req.Send()
895}
896
897// EnableStageTransitionWithContext is the same as EnableStageTransition with the addition of
898// the ability to pass a context and additional request options.
899//
900// See EnableStageTransition for details on how to use this API operation.
901//
902// The context must be non-nil and will be used for request cancellation. If
903// the context is nil a panic will occur. In the future the SDK may create
904// sub-contexts for http.Requests. See https://golang.org/pkg/context/
905// for more information on using Contexts.
906func (c *CodePipeline) EnableStageTransitionWithContext(ctx aws.Context, input *EnableStageTransitionInput, opts ...request.Option) (*EnableStageTransitionOutput, error) {
907	req, out := c.EnableStageTransitionRequest(input)
908	req.SetContext(ctx)
909	req.ApplyOptions(opts...)
910	return out, req.Send()
911}
912
913const opGetJobDetails = "GetJobDetails"
914
915// GetJobDetailsRequest generates a "aws/request.Request" representing the
916// client's request for the GetJobDetails operation. The "output" return
917// value will be populated with the request's response once the request completes
918// successfully.
919//
920// Use "Send" method on the returned Request to send the API call to the service.
921// the "output" return value is not valid until after Send returns without error.
922//
923// See GetJobDetails for more information on using the GetJobDetails
924// API call, and error handling.
925//
926// This method is useful when you want to inject custom logic or configuration
927// into the SDK's request lifecycle. Such as custom headers, or retry logic.
928//
929//
930//    // Example sending a request using the GetJobDetailsRequest method.
931//    req, resp := client.GetJobDetailsRequest(params)
932//
933//    err := req.Send()
934//    if err == nil { // resp is now filled
935//        fmt.Println(resp)
936//    }
937//
938// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetJobDetails
939func (c *CodePipeline) GetJobDetailsRequest(input *GetJobDetailsInput) (req *request.Request, output *GetJobDetailsOutput) {
940	op := &request.Operation{
941		Name:       opGetJobDetails,
942		HTTPMethod: "POST",
943		HTTPPath:   "/",
944	}
945
946	if input == nil {
947		input = &GetJobDetailsInput{}
948	}
949
950	output = &GetJobDetailsOutput{}
951	req = c.newRequest(op, input, output)
952	return
953}
954
955// GetJobDetails API operation for AWS CodePipeline.
956//
957// Returns information about a job. Used for custom actions only.
958//
959// When this API is called, AWS CodePipeline returns temporary credentials for
960// the Amazon S3 bucket used to store artifacts for the pipeline, if the action
961// requires access to that Amazon S3 bucket for input or output artifacts. This
962// API also returns any secret values defined for the action.
963//
964// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
965// with awserr.Error's Code and Message methods to get detailed information about
966// the error.
967//
968// See the AWS API reference guide for AWS CodePipeline's
969// API operation GetJobDetails for usage and error information.
970//
971// Returned Error Codes:
972//   * ErrCodeValidationException "ValidationException"
973//   The validation was specified in an invalid format.
974//
975//   * ErrCodeJobNotFoundException "JobNotFoundException"
976//   The job was specified in an invalid format or cannot be found.
977//
978// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetJobDetails
979func (c *CodePipeline) GetJobDetails(input *GetJobDetailsInput) (*GetJobDetailsOutput, error) {
980	req, out := c.GetJobDetailsRequest(input)
981	return out, req.Send()
982}
983
984// GetJobDetailsWithContext is the same as GetJobDetails with the addition of
985// the ability to pass a context and additional request options.
986//
987// See GetJobDetails for details on how to use this API operation.
988//
989// The context must be non-nil and will be used for request cancellation. If
990// the context is nil a panic will occur. In the future the SDK may create
991// sub-contexts for http.Requests. See https://golang.org/pkg/context/
992// for more information on using Contexts.
993func (c *CodePipeline) GetJobDetailsWithContext(ctx aws.Context, input *GetJobDetailsInput, opts ...request.Option) (*GetJobDetailsOutput, error) {
994	req, out := c.GetJobDetailsRequest(input)
995	req.SetContext(ctx)
996	req.ApplyOptions(opts...)
997	return out, req.Send()
998}
999
1000const opGetPipeline = "GetPipeline"
1001
1002// GetPipelineRequest generates a "aws/request.Request" representing the
1003// client's request for the GetPipeline operation. The "output" return
1004// value will be populated with the request's response once the request completes
1005// successfully.
1006//
1007// Use "Send" method on the returned Request to send the API call to the service.
1008// the "output" return value is not valid until after Send returns without error.
1009//
1010// See GetPipeline for more information on using the GetPipeline
1011// API call, and error handling.
1012//
1013// This method is useful when you want to inject custom logic or configuration
1014// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1015//
1016//
1017//    // Example sending a request using the GetPipelineRequest method.
1018//    req, resp := client.GetPipelineRequest(params)
1019//
1020//    err := req.Send()
1021//    if err == nil { // resp is now filled
1022//        fmt.Println(resp)
1023//    }
1024//
1025// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetPipeline
1026func (c *CodePipeline) GetPipelineRequest(input *GetPipelineInput) (req *request.Request, output *GetPipelineOutput) {
1027	op := &request.Operation{
1028		Name:       opGetPipeline,
1029		HTTPMethod: "POST",
1030		HTTPPath:   "/",
1031	}
1032
1033	if input == nil {
1034		input = &GetPipelineInput{}
1035	}
1036
1037	output = &GetPipelineOutput{}
1038	req = c.newRequest(op, input, output)
1039	return
1040}
1041
1042// GetPipeline API operation for AWS CodePipeline.
1043//
1044// Returns the metadata, structure, stages, and actions of a pipeline. Can be
1045// used to return the entire structure of a pipeline in JSON format, which can
1046// then be modified and used to update the pipeline structure with UpdatePipeline.
1047//
1048// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1049// with awserr.Error's Code and Message methods to get detailed information about
1050// the error.
1051//
1052// See the AWS API reference guide for AWS CodePipeline's
1053// API operation GetPipeline for usage and error information.
1054//
1055// Returned Error Codes:
1056//   * ErrCodeValidationException "ValidationException"
1057//   The validation was specified in an invalid format.
1058//
1059//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
1060//   The pipeline was specified in an invalid format or cannot be found.
1061//
1062//   * ErrCodePipelineVersionNotFoundException "PipelineVersionNotFoundException"
1063//   The pipeline version was specified in an invalid format or cannot be found.
1064//
1065// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetPipeline
1066func (c *CodePipeline) GetPipeline(input *GetPipelineInput) (*GetPipelineOutput, error) {
1067	req, out := c.GetPipelineRequest(input)
1068	return out, req.Send()
1069}
1070
1071// GetPipelineWithContext is the same as GetPipeline with the addition of
1072// the ability to pass a context and additional request options.
1073//
1074// See GetPipeline for details on how to use this API operation.
1075//
1076// The context must be non-nil and will be used for request cancellation. If
1077// the context is nil a panic will occur. In the future the SDK may create
1078// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1079// for more information on using Contexts.
1080func (c *CodePipeline) GetPipelineWithContext(ctx aws.Context, input *GetPipelineInput, opts ...request.Option) (*GetPipelineOutput, error) {
1081	req, out := c.GetPipelineRequest(input)
1082	req.SetContext(ctx)
1083	req.ApplyOptions(opts...)
1084	return out, req.Send()
1085}
1086
1087const opGetPipelineExecution = "GetPipelineExecution"
1088
1089// GetPipelineExecutionRequest generates a "aws/request.Request" representing the
1090// client's request for the GetPipelineExecution operation. The "output" return
1091// value will be populated with the request's response once the request completes
1092// successfully.
1093//
1094// Use "Send" method on the returned Request to send the API call to the service.
1095// the "output" return value is not valid until after Send returns without error.
1096//
1097// See GetPipelineExecution for more information on using the GetPipelineExecution
1098// API call, and error handling.
1099//
1100// This method is useful when you want to inject custom logic or configuration
1101// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1102//
1103//
1104//    // Example sending a request using the GetPipelineExecutionRequest method.
1105//    req, resp := client.GetPipelineExecutionRequest(params)
1106//
1107//    err := req.Send()
1108//    if err == nil { // resp is now filled
1109//        fmt.Println(resp)
1110//    }
1111//
1112// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetPipelineExecution
1113func (c *CodePipeline) GetPipelineExecutionRequest(input *GetPipelineExecutionInput) (req *request.Request, output *GetPipelineExecutionOutput) {
1114	op := &request.Operation{
1115		Name:       opGetPipelineExecution,
1116		HTTPMethod: "POST",
1117		HTTPPath:   "/",
1118	}
1119
1120	if input == nil {
1121		input = &GetPipelineExecutionInput{}
1122	}
1123
1124	output = &GetPipelineExecutionOutput{}
1125	req = c.newRequest(op, input, output)
1126	return
1127}
1128
1129// GetPipelineExecution API operation for AWS CodePipeline.
1130//
1131// Returns information about an execution of a pipeline, including details about
1132// artifacts, the pipeline execution ID, and the name, version, and status of
1133// the pipeline.
1134//
1135// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1136// with awserr.Error's Code and Message methods to get detailed information about
1137// the error.
1138//
1139// See the AWS API reference guide for AWS CodePipeline's
1140// API operation GetPipelineExecution for usage and error information.
1141//
1142// Returned Error Codes:
1143//   * ErrCodeValidationException "ValidationException"
1144//   The validation was specified in an invalid format.
1145//
1146//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
1147//   The pipeline was specified in an invalid format or cannot be found.
1148//
1149//   * ErrCodePipelineExecutionNotFoundException "PipelineExecutionNotFoundException"
1150//   The pipeline execution was specified in an invalid format or cannot be found,
1151//   or an execution ID does not belong to the specified pipeline.
1152//
1153// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetPipelineExecution
1154func (c *CodePipeline) GetPipelineExecution(input *GetPipelineExecutionInput) (*GetPipelineExecutionOutput, error) {
1155	req, out := c.GetPipelineExecutionRequest(input)
1156	return out, req.Send()
1157}
1158
1159// GetPipelineExecutionWithContext is the same as GetPipelineExecution with the addition of
1160// the ability to pass a context and additional request options.
1161//
1162// See GetPipelineExecution for details on how to use this API operation.
1163//
1164// The context must be non-nil and will be used for request cancellation. If
1165// the context is nil a panic will occur. In the future the SDK may create
1166// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1167// for more information on using Contexts.
1168func (c *CodePipeline) GetPipelineExecutionWithContext(ctx aws.Context, input *GetPipelineExecutionInput, opts ...request.Option) (*GetPipelineExecutionOutput, error) {
1169	req, out := c.GetPipelineExecutionRequest(input)
1170	req.SetContext(ctx)
1171	req.ApplyOptions(opts...)
1172	return out, req.Send()
1173}
1174
1175const opGetPipelineState = "GetPipelineState"
1176
1177// GetPipelineStateRequest generates a "aws/request.Request" representing the
1178// client's request for the GetPipelineState operation. The "output" return
1179// value will be populated with the request's response once the request completes
1180// successfully.
1181//
1182// Use "Send" method on the returned Request to send the API call to the service.
1183// the "output" return value is not valid until after Send returns without error.
1184//
1185// See GetPipelineState for more information on using the GetPipelineState
1186// API call, and error handling.
1187//
1188// This method is useful when you want to inject custom logic or configuration
1189// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1190//
1191//
1192//    // Example sending a request using the GetPipelineStateRequest method.
1193//    req, resp := client.GetPipelineStateRequest(params)
1194//
1195//    err := req.Send()
1196//    if err == nil { // resp is now filled
1197//        fmt.Println(resp)
1198//    }
1199//
1200// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetPipelineState
1201func (c *CodePipeline) GetPipelineStateRequest(input *GetPipelineStateInput) (req *request.Request, output *GetPipelineStateOutput) {
1202	op := &request.Operation{
1203		Name:       opGetPipelineState,
1204		HTTPMethod: "POST",
1205		HTTPPath:   "/",
1206	}
1207
1208	if input == nil {
1209		input = &GetPipelineStateInput{}
1210	}
1211
1212	output = &GetPipelineStateOutput{}
1213	req = c.newRequest(op, input, output)
1214	return
1215}
1216
1217// GetPipelineState API operation for AWS CodePipeline.
1218//
1219// Returns information about the state of a pipeline, including the stages and
1220// actions.
1221//
1222// Values returned in the revisionId and revisionUrl fields indicate the source
1223// revision information, such as the commit ID, for the current state.
1224//
1225// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1226// with awserr.Error's Code and Message methods to get detailed information about
1227// the error.
1228//
1229// See the AWS API reference guide for AWS CodePipeline's
1230// API operation GetPipelineState for usage and error information.
1231//
1232// Returned Error Codes:
1233//   * ErrCodeValidationException "ValidationException"
1234//   The validation was specified in an invalid format.
1235//
1236//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
1237//   The pipeline was specified in an invalid format or cannot be found.
1238//
1239// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetPipelineState
1240func (c *CodePipeline) GetPipelineState(input *GetPipelineStateInput) (*GetPipelineStateOutput, error) {
1241	req, out := c.GetPipelineStateRequest(input)
1242	return out, req.Send()
1243}
1244
1245// GetPipelineStateWithContext is the same as GetPipelineState with the addition of
1246// the ability to pass a context and additional request options.
1247//
1248// See GetPipelineState for details on how to use this API operation.
1249//
1250// The context must be non-nil and will be used for request cancellation. If
1251// the context is nil a panic will occur. In the future the SDK may create
1252// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1253// for more information on using Contexts.
1254func (c *CodePipeline) GetPipelineStateWithContext(ctx aws.Context, input *GetPipelineStateInput, opts ...request.Option) (*GetPipelineStateOutput, error) {
1255	req, out := c.GetPipelineStateRequest(input)
1256	req.SetContext(ctx)
1257	req.ApplyOptions(opts...)
1258	return out, req.Send()
1259}
1260
1261const opGetThirdPartyJobDetails = "GetThirdPartyJobDetails"
1262
1263// GetThirdPartyJobDetailsRequest generates a "aws/request.Request" representing the
1264// client's request for the GetThirdPartyJobDetails operation. The "output" return
1265// value will be populated with the request's response once the request completes
1266// successfully.
1267//
1268// Use "Send" method on the returned Request to send the API call to the service.
1269// the "output" return value is not valid until after Send returns without error.
1270//
1271// See GetThirdPartyJobDetails for more information on using the GetThirdPartyJobDetails
1272// API call, and error handling.
1273//
1274// This method is useful when you want to inject custom logic or configuration
1275// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1276//
1277//
1278//    // Example sending a request using the GetThirdPartyJobDetailsRequest method.
1279//    req, resp := client.GetThirdPartyJobDetailsRequest(params)
1280//
1281//    err := req.Send()
1282//    if err == nil { // resp is now filled
1283//        fmt.Println(resp)
1284//    }
1285//
1286// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetThirdPartyJobDetails
1287func (c *CodePipeline) GetThirdPartyJobDetailsRequest(input *GetThirdPartyJobDetailsInput) (req *request.Request, output *GetThirdPartyJobDetailsOutput) {
1288	op := &request.Operation{
1289		Name:       opGetThirdPartyJobDetails,
1290		HTTPMethod: "POST",
1291		HTTPPath:   "/",
1292	}
1293
1294	if input == nil {
1295		input = &GetThirdPartyJobDetailsInput{}
1296	}
1297
1298	output = &GetThirdPartyJobDetailsOutput{}
1299	req = c.newRequest(op, input, output)
1300	return
1301}
1302
1303// GetThirdPartyJobDetails API operation for AWS CodePipeline.
1304//
1305// Requests the details of a job for a third party action. Used for partner
1306// actions only.
1307//
1308// When this API is called, AWS CodePipeline returns temporary credentials for
1309// the Amazon S3 bucket used to store artifacts for the pipeline, if the action
1310// requires access to that Amazon S3 bucket for input or output artifacts. This
1311// API also returns any secret values defined for the action.
1312//
1313// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1314// with awserr.Error's Code and Message methods to get detailed information about
1315// the error.
1316//
1317// See the AWS API reference guide for AWS CodePipeline's
1318// API operation GetThirdPartyJobDetails for usage and error information.
1319//
1320// Returned Error Codes:
1321//   * ErrCodeJobNotFoundException "JobNotFoundException"
1322//   The job was specified in an invalid format or cannot be found.
1323//
1324//   * ErrCodeValidationException "ValidationException"
1325//   The validation was specified in an invalid format.
1326//
1327//   * ErrCodeInvalidClientTokenException "InvalidClientTokenException"
1328//   The client token was specified in an invalid format
1329//
1330//   * ErrCodeInvalidJobException "InvalidJobException"
1331//   The job was specified in an invalid format or cannot be found.
1332//
1333// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/GetThirdPartyJobDetails
1334func (c *CodePipeline) GetThirdPartyJobDetails(input *GetThirdPartyJobDetailsInput) (*GetThirdPartyJobDetailsOutput, error) {
1335	req, out := c.GetThirdPartyJobDetailsRequest(input)
1336	return out, req.Send()
1337}
1338
1339// GetThirdPartyJobDetailsWithContext is the same as GetThirdPartyJobDetails with the addition of
1340// the ability to pass a context and additional request options.
1341//
1342// See GetThirdPartyJobDetails for details on how to use this API operation.
1343//
1344// The context must be non-nil and will be used for request cancellation. If
1345// the context is nil a panic will occur. In the future the SDK may create
1346// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1347// for more information on using Contexts.
1348func (c *CodePipeline) GetThirdPartyJobDetailsWithContext(ctx aws.Context, input *GetThirdPartyJobDetailsInput, opts ...request.Option) (*GetThirdPartyJobDetailsOutput, error) {
1349	req, out := c.GetThirdPartyJobDetailsRequest(input)
1350	req.SetContext(ctx)
1351	req.ApplyOptions(opts...)
1352	return out, req.Send()
1353}
1354
1355const opListActionExecutions = "ListActionExecutions"
1356
1357// ListActionExecutionsRequest generates a "aws/request.Request" representing the
1358// client's request for the ListActionExecutions operation. The "output" return
1359// value will be populated with the request's response once the request completes
1360// successfully.
1361//
1362// Use "Send" method on the returned Request to send the API call to the service.
1363// the "output" return value is not valid until after Send returns without error.
1364//
1365// See ListActionExecutions for more information on using the ListActionExecutions
1366// API call, and error handling.
1367//
1368// This method is useful when you want to inject custom logic or configuration
1369// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1370//
1371//
1372//    // Example sending a request using the ListActionExecutionsRequest method.
1373//    req, resp := client.ListActionExecutionsRequest(params)
1374//
1375//    err := req.Send()
1376//    if err == nil { // resp is now filled
1377//        fmt.Println(resp)
1378//    }
1379//
1380// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListActionExecutions
1381func (c *CodePipeline) ListActionExecutionsRequest(input *ListActionExecutionsInput) (req *request.Request, output *ListActionExecutionsOutput) {
1382	op := &request.Operation{
1383		Name:       opListActionExecutions,
1384		HTTPMethod: "POST",
1385		HTTPPath:   "/",
1386		Paginator: &request.Paginator{
1387			InputTokens:     []string{"nextToken"},
1388			OutputTokens:    []string{"nextToken"},
1389			LimitToken:      "maxResults",
1390			TruncationToken: "",
1391		},
1392	}
1393
1394	if input == nil {
1395		input = &ListActionExecutionsInput{}
1396	}
1397
1398	output = &ListActionExecutionsOutput{}
1399	req = c.newRequest(op, input, output)
1400	return
1401}
1402
1403// ListActionExecutions API operation for AWS CodePipeline.
1404//
1405// Lists the action executions that have occurred in a pipeline.
1406//
1407// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1408// with awserr.Error's Code and Message methods to get detailed information about
1409// the error.
1410//
1411// See the AWS API reference guide for AWS CodePipeline's
1412// API operation ListActionExecutions for usage and error information.
1413//
1414// Returned Error Codes:
1415//   * ErrCodeValidationException "ValidationException"
1416//   The validation was specified in an invalid format.
1417//
1418//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
1419//   The pipeline was specified in an invalid format or cannot be found.
1420//
1421//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
1422//   The next token was specified in an invalid format. Make sure that the next
1423//   token you provide is the token returned by a previous call.
1424//
1425//   * ErrCodePipelineExecutionNotFoundException "PipelineExecutionNotFoundException"
1426//   The pipeline execution was specified in an invalid format or cannot be found,
1427//   or an execution ID does not belong to the specified pipeline.
1428//
1429// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListActionExecutions
1430func (c *CodePipeline) ListActionExecutions(input *ListActionExecutionsInput) (*ListActionExecutionsOutput, error) {
1431	req, out := c.ListActionExecutionsRequest(input)
1432	return out, req.Send()
1433}
1434
1435// ListActionExecutionsWithContext is the same as ListActionExecutions with the addition of
1436// the ability to pass a context and additional request options.
1437//
1438// See ListActionExecutions for details on how to use this API operation.
1439//
1440// The context must be non-nil and will be used for request cancellation. If
1441// the context is nil a panic will occur. In the future the SDK may create
1442// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1443// for more information on using Contexts.
1444func (c *CodePipeline) ListActionExecutionsWithContext(ctx aws.Context, input *ListActionExecutionsInput, opts ...request.Option) (*ListActionExecutionsOutput, error) {
1445	req, out := c.ListActionExecutionsRequest(input)
1446	req.SetContext(ctx)
1447	req.ApplyOptions(opts...)
1448	return out, req.Send()
1449}
1450
1451// ListActionExecutionsPages iterates over the pages of a ListActionExecutions operation,
1452// calling the "fn" function with the response data for each page. To stop
1453// iterating, return false from the fn function.
1454//
1455// See ListActionExecutions method for more information on how to use this operation.
1456//
1457// Note: This operation can generate multiple requests to a service.
1458//
1459//    // Example iterating over at most 3 pages of a ListActionExecutions operation.
1460//    pageNum := 0
1461//    err := client.ListActionExecutionsPages(params,
1462//        func(page *codepipeline.ListActionExecutionsOutput, lastPage bool) bool {
1463//            pageNum++
1464//            fmt.Println(page)
1465//            return pageNum <= 3
1466//        })
1467//
1468func (c *CodePipeline) ListActionExecutionsPages(input *ListActionExecutionsInput, fn func(*ListActionExecutionsOutput, bool) bool) error {
1469	return c.ListActionExecutionsPagesWithContext(aws.BackgroundContext(), input, fn)
1470}
1471
1472// ListActionExecutionsPagesWithContext same as ListActionExecutionsPages except
1473// it takes a Context and allows setting request options on the pages.
1474//
1475// The context must be non-nil and will be used for request cancellation. If
1476// the context is nil a panic will occur. In the future the SDK may create
1477// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1478// for more information on using Contexts.
1479func (c *CodePipeline) ListActionExecutionsPagesWithContext(ctx aws.Context, input *ListActionExecutionsInput, fn func(*ListActionExecutionsOutput, bool) bool, opts ...request.Option) error {
1480	p := request.Pagination{
1481		NewRequest: func() (*request.Request, error) {
1482			var inCpy *ListActionExecutionsInput
1483			if input != nil {
1484				tmp := *input
1485				inCpy = &tmp
1486			}
1487			req, _ := c.ListActionExecutionsRequest(inCpy)
1488			req.SetContext(ctx)
1489			req.ApplyOptions(opts...)
1490			return req, nil
1491		},
1492	}
1493
1494	for p.Next() {
1495		if !fn(p.Page().(*ListActionExecutionsOutput), !p.HasNextPage()) {
1496			break
1497		}
1498	}
1499
1500	return p.Err()
1501}
1502
1503const opListActionTypes = "ListActionTypes"
1504
1505// ListActionTypesRequest generates a "aws/request.Request" representing the
1506// client's request for the ListActionTypes operation. The "output" return
1507// value will be populated with the request's response once the request completes
1508// successfully.
1509//
1510// Use "Send" method on the returned Request to send the API call to the service.
1511// the "output" return value is not valid until after Send returns without error.
1512//
1513// See ListActionTypes for more information on using the ListActionTypes
1514// API call, and error handling.
1515//
1516// This method is useful when you want to inject custom logic or configuration
1517// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1518//
1519//
1520//    // Example sending a request using the ListActionTypesRequest method.
1521//    req, resp := client.ListActionTypesRequest(params)
1522//
1523//    err := req.Send()
1524//    if err == nil { // resp is now filled
1525//        fmt.Println(resp)
1526//    }
1527//
1528// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListActionTypes
1529func (c *CodePipeline) ListActionTypesRequest(input *ListActionTypesInput) (req *request.Request, output *ListActionTypesOutput) {
1530	op := &request.Operation{
1531		Name:       opListActionTypes,
1532		HTTPMethod: "POST",
1533		HTTPPath:   "/",
1534		Paginator: &request.Paginator{
1535			InputTokens:     []string{"nextToken"},
1536			OutputTokens:    []string{"nextToken"},
1537			LimitToken:      "",
1538			TruncationToken: "",
1539		},
1540	}
1541
1542	if input == nil {
1543		input = &ListActionTypesInput{}
1544	}
1545
1546	output = &ListActionTypesOutput{}
1547	req = c.newRequest(op, input, output)
1548	return
1549}
1550
1551// ListActionTypes API operation for AWS CodePipeline.
1552//
1553// Gets a summary of all AWS CodePipeline action types associated with your
1554// account.
1555//
1556// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1557// with awserr.Error's Code and Message methods to get detailed information about
1558// the error.
1559//
1560// See the AWS API reference guide for AWS CodePipeline's
1561// API operation ListActionTypes for usage and error information.
1562//
1563// Returned Error Codes:
1564//   * ErrCodeValidationException "ValidationException"
1565//   The validation was specified in an invalid format.
1566//
1567//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
1568//   The next token was specified in an invalid format. Make sure that the next
1569//   token you provide is the token returned by a previous call.
1570//
1571// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListActionTypes
1572func (c *CodePipeline) ListActionTypes(input *ListActionTypesInput) (*ListActionTypesOutput, error) {
1573	req, out := c.ListActionTypesRequest(input)
1574	return out, req.Send()
1575}
1576
1577// ListActionTypesWithContext is the same as ListActionTypes with the addition of
1578// the ability to pass a context and additional request options.
1579//
1580// See ListActionTypes for details on how to use this API operation.
1581//
1582// The context must be non-nil and will be used for request cancellation. If
1583// the context is nil a panic will occur. In the future the SDK may create
1584// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1585// for more information on using Contexts.
1586func (c *CodePipeline) ListActionTypesWithContext(ctx aws.Context, input *ListActionTypesInput, opts ...request.Option) (*ListActionTypesOutput, error) {
1587	req, out := c.ListActionTypesRequest(input)
1588	req.SetContext(ctx)
1589	req.ApplyOptions(opts...)
1590	return out, req.Send()
1591}
1592
1593// ListActionTypesPages iterates over the pages of a ListActionTypes operation,
1594// calling the "fn" function with the response data for each page. To stop
1595// iterating, return false from the fn function.
1596//
1597// See ListActionTypes method for more information on how to use this operation.
1598//
1599// Note: This operation can generate multiple requests to a service.
1600//
1601//    // Example iterating over at most 3 pages of a ListActionTypes operation.
1602//    pageNum := 0
1603//    err := client.ListActionTypesPages(params,
1604//        func(page *codepipeline.ListActionTypesOutput, lastPage bool) bool {
1605//            pageNum++
1606//            fmt.Println(page)
1607//            return pageNum <= 3
1608//        })
1609//
1610func (c *CodePipeline) ListActionTypesPages(input *ListActionTypesInput, fn func(*ListActionTypesOutput, bool) bool) error {
1611	return c.ListActionTypesPagesWithContext(aws.BackgroundContext(), input, fn)
1612}
1613
1614// ListActionTypesPagesWithContext same as ListActionTypesPages except
1615// it takes a Context and allows setting request options on the pages.
1616//
1617// The context must be non-nil and will be used for request cancellation. If
1618// the context is nil a panic will occur. In the future the SDK may create
1619// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1620// for more information on using Contexts.
1621func (c *CodePipeline) ListActionTypesPagesWithContext(ctx aws.Context, input *ListActionTypesInput, fn func(*ListActionTypesOutput, bool) bool, opts ...request.Option) error {
1622	p := request.Pagination{
1623		NewRequest: func() (*request.Request, error) {
1624			var inCpy *ListActionTypesInput
1625			if input != nil {
1626				tmp := *input
1627				inCpy = &tmp
1628			}
1629			req, _ := c.ListActionTypesRequest(inCpy)
1630			req.SetContext(ctx)
1631			req.ApplyOptions(opts...)
1632			return req, nil
1633		},
1634	}
1635
1636	for p.Next() {
1637		if !fn(p.Page().(*ListActionTypesOutput), !p.HasNextPage()) {
1638			break
1639		}
1640	}
1641
1642	return p.Err()
1643}
1644
1645const opListPipelineExecutions = "ListPipelineExecutions"
1646
1647// ListPipelineExecutionsRequest generates a "aws/request.Request" representing the
1648// client's request for the ListPipelineExecutions operation. The "output" return
1649// value will be populated with the request's response once the request completes
1650// successfully.
1651//
1652// Use "Send" method on the returned Request to send the API call to the service.
1653// the "output" return value is not valid until after Send returns without error.
1654//
1655// See ListPipelineExecutions for more information on using the ListPipelineExecutions
1656// API call, and error handling.
1657//
1658// This method is useful when you want to inject custom logic or configuration
1659// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1660//
1661//
1662//    // Example sending a request using the ListPipelineExecutionsRequest method.
1663//    req, resp := client.ListPipelineExecutionsRequest(params)
1664//
1665//    err := req.Send()
1666//    if err == nil { // resp is now filled
1667//        fmt.Println(resp)
1668//    }
1669//
1670// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListPipelineExecutions
1671func (c *CodePipeline) ListPipelineExecutionsRequest(input *ListPipelineExecutionsInput) (req *request.Request, output *ListPipelineExecutionsOutput) {
1672	op := &request.Operation{
1673		Name:       opListPipelineExecutions,
1674		HTTPMethod: "POST",
1675		HTTPPath:   "/",
1676		Paginator: &request.Paginator{
1677			InputTokens:     []string{"nextToken"},
1678			OutputTokens:    []string{"nextToken"},
1679			LimitToken:      "maxResults",
1680			TruncationToken: "",
1681		},
1682	}
1683
1684	if input == nil {
1685		input = &ListPipelineExecutionsInput{}
1686	}
1687
1688	output = &ListPipelineExecutionsOutput{}
1689	req = c.newRequest(op, input, output)
1690	return
1691}
1692
1693// ListPipelineExecutions API operation for AWS CodePipeline.
1694//
1695// Gets a summary of the most recent executions for a pipeline.
1696//
1697// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1698// with awserr.Error's Code and Message methods to get detailed information about
1699// the error.
1700//
1701// See the AWS API reference guide for AWS CodePipeline's
1702// API operation ListPipelineExecutions for usage and error information.
1703//
1704// Returned Error Codes:
1705//   * ErrCodeValidationException "ValidationException"
1706//   The validation was specified in an invalid format.
1707//
1708//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
1709//   The pipeline was specified in an invalid format or cannot be found.
1710//
1711//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
1712//   The next token was specified in an invalid format. Make sure that the next
1713//   token you provide is the token returned by a previous call.
1714//
1715// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListPipelineExecutions
1716func (c *CodePipeline) ListPipelineExecutions(input *ListPipelineExecutionsInput) (*ListPipelineExecutionsOutput, error) {
1717	req, out := c.ListPipelineExecutionsRequest(input)
1718	return out, req.Send()
1719}
1720
1721// ListPipelineExecutionsWithContext is the same as ListPipelineExecutions with the addition of
1722// the ability to pass a context and additional request options.
1723//
1724// See ListPipelineExecutions for details on how to use this API operation.
1725//
1726// The context must be non-nil and will be used for request cancellation. If
1727// the context is nil a panic will occur. In the future the SDK may create
1728// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1729// for more information on using Contexts.
1730func (c *CodePipeline) ListPipelineExecutionsWithContext(ctx aws.Context, input *ListPipelineExecutionsInput, opts ...request.Option) (*ListPipelineExecutionsOutput, error) {
1731	req, out := c.ListPipelineExecutionsRequest(input)
1732	req.SetContext(ctx)
1733	req.ApplyOptions(opts...)
1734	return out, req.Send()
1735}
1736
1737// ListPipelineExecutionsPages iterates over the pages of a ListPipelineExecutions operation,
1738// calling the "fn" function with the response data for each page. To stop
1739// iterating, return false from the fn function.
1740//
1741// See ListPipelineExecutions method for more information on how to use this operation.
1742//
1743// Note: This operation can generate multiple requests to a service.
1744//
1745//    // Example iterating over at most 3 pages of a ListPipelineExecutions operation.
1746//    pageNum := 0
1747//    err := client.ListPipelineExecutionsPages(params,
1748//        func(page *codepipeline.ListPipelineExecutionsOutput, lastPage bool) bool {
1749//            pageNum++
1750//            fmt.Println(page)
1751//            return pageNum <= 3
1752//        })
1753//
1754func (c *CodePipeline) ListPipelineExecutionsPages(input *ListPipelineExecutionsInput, fn func(*ListPipelineExecutionsOutput, bool) bool) error {
1755	return c.ListPipelineExecutionsPagesWithContext(aws.BackgroundContext(), input, fn)
1756}
1757
1758// ListPipelineExecutionsPagesWithContext same as ListPipelineExecutionsPages except
1759// it takes a Context and allows setting request options on the pages.
1760//
1761// The context must be non-nil and will be used for request cancellation. If
1762// the context is nil a panic will occur. In the future the SDK may create
1763// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1764// for more information on using Contexts.
1765func (c *CodePipeline) ListPipelineExecutionsPagesWithContext(ctx aws.Context, input *ListPipelineExecutionsInput, fn func(*ListPipelineExecutionsOutput, bool) bool, opts ...request.Option) error {
1766	p := request.Pagination{
1767		NewRequest: func() (*request.Request, error) {
1768			var inCpy *ListPipelineExecutionsInput
1769			if input != nil {
1770				tmp := *input
1771				inCpy = &tmp
1772			}
1773			req, _ := c.ListPipelineExecutionsRequest(inCpy)
1774			req.SetContext(ctx)
1775			req.ApplyOptions(opts...)
1776			return req, nil
1777		},
1778	}
1779
1780	for p.Next() {
1781		if !fn(p.Page().(*ListPipelineExecutionsOutput), !p.HasNextPage()) {
1782			break
1783		}
1784	}
1785
1786	return p.Err()
1787}
1788
1789const opListPipelines = "ListPipelines"
1790
1791// ListPipelinesRequest generates a "aws/request.Request" representing the
1792// client's request for the ListPipelines operation. The "output" return
1793// value will be populated with the request's response once the request completes
1794// successfully.
1795//
1796// Use "Send" method on the returned Request to send the API call to the service.
1797// the "output" return value is not valid until after Send returns without error.
1798//
1799// See ListPipelines for more information on using the ListPipelines
1800// API call, and error handling.
1801//
1802// This method is useful when you want to inject custom logic or configuration
1803// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1804//
1805//
1806//    // Example sending a request using the ListPipelinesRequest method.
1807//    req, resp := client.ListPipelinesRequest(params)
1808//
1809//    err := req.Send()
1810//    if err == nil { // resp is now filled
1811//        fmt.Println(resp)
1812//    }
1813//
1814// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListPipelines
1815func (c *CodePipeline) ListPipelinesRequest(input *ListPipelinesInput) (req *request.Request, output *ListPipelinesOutput) {
1816	op := &request.Operation{
1817		Name:       opListPipelines,
1818		HTTPMethod: "POST",
1819		HTTPPath:   "/",
1820		Paginator: &request.Paginator{
1821			InputTokens:     []string{"nextToken"},
1822			OutputTokens:    []string{"nextToken"},
1823			LimitToken:      "",
1824			TruncationToken: "",
1825		},
1826	}
1827
1828	if input == nil {
1829		input = &ListPipelinesInput{}
1830	}
1831
1832	output = &ListPipelinesOutput{}
1833	req = c.newRequest(op, input, output)
1834	return
1835}
1836
1837// ListPipelines API operation for AWS CodePipeline.
1838//
1839// Gets a summary of all of the pipelines associated with your account.
1840//
1841// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1842// with awserr.Error's Code and Message methods to get detailed information about
1843// the error.
1844//
1845// See the AWS API reference guide for AWS CodePipeline's
1846// API operation ListPipelines for usage and error information.
1847//
1848// Returned Error Codes:
1849//   * ErrCodeValidationException "ValidationException"
1850//   The validation was specified in an invalid format.
1851//
1852//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
1853//   The next token was specified in an invalid format. Make sure that the next
1854//   token you provide is the token returned by a previous call.
1855//
1856// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListPipelines
1857func (c *CodePipeline) ListPipelines(input *ListPipelinesInput) (*ListPipelinesOutput, error) {
1858	req, out := c.ListPipelinesRequest(input)
1859	return out, req.Send()
1860}
1861
1862// ListPipelinesWithContext is the same as ListPipelines with the addition of
1863// the ability to pass a context and additional request options.
1864//
1865// See ListPipelines for details on how to use this API operation.
1866//
1867// The context must be non-nil and will be used for request cancellation. If
1868// the context is nil a panic will occur. In the future the SDK may create
1869// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1870// for more information on using Contexts.
1871func (c *CodePipeline) ListPipelinesWithContext(ctx aws.Context, input *ListPipelinesInput, opts ...request.Option) (*ListPipelinesOutput, error) {
1872	req, out := c.ListPipelinesRequest(input)
1873	req.SetContext(ctx)
1874	req.ApplyOptions(opts...)
1875	return out, req.Send()
1876}
1877
1878// ListPipelinesPages iterates over the pages of a ListPipelines operation,
1879// calling the "fn" function with the response data for each page. To stop
1880// iterating, return false from the fn function.
1881//
1882// See ListPipelines method for more information on how to use this operation.
1883//
1884// Note: This operation can generate multiple requests to a service.
1885//
1886//    // Example iterating over at most 3 pages of a ListPipelines operation.
1887//    pageNum := 0
1888//    err := client.ListPipelinesPages(params,
1889//        func(page *codepipeline.ListPipelinesOutput, lastPage bool) bool {
1890//            pageNum++
1891//            fmt.Println(page)
1892//            return pageNum <= 3
1893//        })
1894//
1895func (c *CodePipeline) ListPipelinesPages(input *ListPipelinesInput, fn func(*ListPipelinesOutput, bool) bool) error {
1896	return c.ListPipelinesPagesWithContext(aws.BackgroundContext(), input, fn)
1897}
1898
1899// ListPipelinesPagesWithContext same as ListPipelinesPages except
1900// it takes a Context and allows setting request options on the pages.
1901//
1902// The context must be non-nil and will be used for request cancellation. If
1903// the context is nil a panic will occur. In the future the SDK may create
1904// sub-contexts for http.Requests. See https://golang.org/pkg/context/
1905// for more information on using Contexts.
1906func (c *CodePipeline) ListPipelinesPagesWithContext(ctx aws.Context, input *ListPipelinesInput, fn func(*ListPipelinesOutput, bool) bool, opts ...request.Option) error {
1907	p := request.Pagination{
1908		NewRequest: func() (*request.Request, error) {
1909			var inCpy *ListPipelinesInput
1910			if input != nil {
1911				tmp := *input
1912				inCpy = &tmp
1913			}
1914			req, _ := c.ListPipelinesRequest(inCpy)
1915			req.SetContext(ctx)
1916			req.ApplyOptions(opts...)
1917			return req, nil
1918		},
1919	}
1920
1921	for p.Next() {
1922		if !fn(p.Page().(*ListPipelinesOutput), !p.HasNextPage()) {
1923			break
1924		}
1925	}
1926
1927	return p.Err()
1928}
1929
1930const opListTagsForResource = "ListTagsForResource"
1931
1932// ListTagsForResourceRequest generates a "aws/request.Request" representing the
1933// client's request for the ListTagsForResource operation. The "output" return
1934// value will be populated with the request's response once the request completes
1935// successfully.
1936//
1937// Use "Send" method on the returned Request to send the API call to the service.
1938// the "output" return value is not valid until after Send returns without error.
1939//
1940// See ListTagsForResource for more information on using the ListTagsForResource
1941// API call, and error handling.
1942//
1943// This method is useful when you want to inject custom logic or configuration
1944// into the SDK's request lifecycle. Such as custom headers, or retry logic.
1945//
1946//
1947//    // Example sending a request using the ListTagsForResourceRequest method.
1948//    req, resp := client.ListTagsForResourceRequest(params)
1949//
1950//    err := req.Send()
1951//    if err == nil { // resp is now filled
1952//        fmt.Println(resp)
1953//    }
1954//
1955// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListTagsForResource
1956func (c *CodePipeline) ListTagsForResourceRequest(input *ListTagsForResourceInput) (req *request.Request, output *ListTagsForResourceOutput) {
1957	op := &request.Operation{
1958		Name:       opListTagsForResource,
1959		HTTPMethod: "POST",
1960		HTTPPath:   "/",
1961		Paginator: &request.Paginator{
1962			InputTokens:     []string{"nextToken"},
1963			OutputTokens:    []string{"nextToken"},
1964			LimitToken:      "maxResults",
1965			TruncationToken: "",
1966		},
1967	}
1968
1969	if input == nil {
1970		input = &ListTagsForResourceInput{}
1971	}
1972
1973	output = &ListTagsForResourceOutput{}
1974	req = c.newRequest(op, input, output)
1975	return
1976}
1977
1978// ListTagsForResource API operation for AWS CodePipeline.
1979//
1980// Gets the set of key-value pairs (metadata) that are used to manage the resource.
1981//
1982// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
1983// with awserr.Error's Code and Message methods to get detailed information about
1984// the error.
1985//
1986// See the AWS API reference guide for AWS CodePipeline's
1987// API operation ListTagsForResource for usage and error information.
1988//
1989// Returned Error Codes:
1990//   * ErrCodeValidationException "ValidationException"
1991//   The validation was specified in an invalid format.
1992//
1993//   * ErrCodeResourceNotFoundException "ResourceNotFoundException"
1994//   The resource was specified in an invalid format.
1995//
1996//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
1997//   The next token was specified in an invalid format. Make sure that the next
1998//   token you provide is the token returned by a previous call.
1999//
2000//   * ErrCodeInvalidArnException "InvalidArnException"
2001//   The specified resource ARN is invalid.
2002//
2003// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListTagsForResource
2004func (c *CodePipeline) ListTagsForResource(input *ListTagsForResourceInput) (*ListTagsForResourceOutput, error) {
2005	req, out := c.ListTagsForResourceRequest(input)
2006	return out, req.Send()
2007}
2008
2009// ListTagsForResourceWithContext is the same as ListTagsForResource with the addition of
2010// the ability to pass a context and additional request options.
2011//
2012// See ListTagsForResource 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 *CodePipeline) ListTagsForResourceWithContext(ctx aws.Context, input *ListTagsForResourceInput, opts ...request.Option) (*ListTagsForResourceOutput, error) {
2019	req, out := c.ListTagsForResourceRequest(input)
2020	req.SetContext(ctx)
2021	req.ApplyOptions(opts...)
2022	return out, req.Send()
2023}
2024
2025// ListTagsForResourcePages iterates over the pages of a ListTagsForResource operation,
2026// calling the "fn" function with the response data for each page. To stop
2027// iterating, return false from the fn function.
2028//
2029// See ListTagsForResource method for more information on how to use this operation.
2030//
2031// Note: This operation can generate multiple requests to a service.
2032//
2033//    // Example iterating over at most 3 pages of a ListTagsForResource operation.
2034//    pageNum := 0
2035//    err := client.ListTagsForResourcePages(params,
2036//        func(page *codepipeline.ListTagsForResourceOutput, lastPage bool) bool {
2037//            pageNum++
2038//            fmt.Println(page)
2039//            return pageNum <= 3
2040//        })
2041//
2042func (c *CodePipeline) ListTagsForResourcePages(input *ListTagsForResourceInput, fn func(*ListTagsForResourceOutput, bool) bool) error {
2043	return c.ListTagsForResourcePagesWithContext(aws.BackgroundContext(), input, fn)
2044}
2045
2046// ListTagsForResourcePagesWithContext same as ListTagsForResourcePages except
2047// it takes a Context and allows setting request options on the pages.
2048//
2049// The context must be non-nil and will be used for request cancellation. If
2050// the context is nil a panic will occur. In the future the SDK may create
2051// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2052// for more information on using Contexts.
2053func (c *CodePipeline) ListTagsForResourcePagesWithContext(ctx aws.Context, input *ListTagsForResourceInput, fn func(*ListTagsForResourceOutput, bool) bool, opts ...request.Option) error {
2054	p := request.Pagination{
2055		NewRequest: func() (*request.Request, error) {
2056			var inCpy *ListTagsForResourceInput
2057			if input != nil {
2058				tmp := *input
2059				inCpy = &tmp
2060			}
2061			req, _ := c.ListTagsForResourceRequest(inCpy)
2062			req.SetContext(ctx)
2063			req.ApplyOptions(opts...)
2064			return req, nil
2065		},
2066	}
2067
2068	for p.Next() {
2069		if !fn(p.Page().(*ListTagsForResourceOutput), !p.HasNextPage()) {
2070			break
2071		}
2072	}
2073
2074	return p.Err()
2075}
2076
2077const opListWebhooks = "ListWebhooks"
2078
2079// ListWebhooksRequest generates a "aws/request.Request" representing the
2080// client's request for the ListWebhooks operation. The "output" return
2081// value will be populated with the request's response once the request completes
2082// successfully.
2083//
2084// Use "Send" method on the returned Request to send the API call to the service.
2085// the "output" return value is not valid until after Send returns without error.
2086//
2087// See ListWebhooks for more information on using the ListWebhooks
2088// API call, and error handling.
2089//
2090// This method is useful when you want to inject custom logic or configuration
2091// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2092//
2093//
2094//    // Example sending a request using the ListWebhooksRequest method.
2095//    req, resp := client.ListWebhooksRequest(params)
2096//
2097//    err := req.Send()
2098//    if err == nil { // resp is now filled
2099//        fmt.Println(resp)
2100//    }
2101//
2102// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListWebhooks
2103func (c *CodePipeline) ListWebhooksRequest(input *ListWebhooksInput) (req *request.Request, output *ListWebhooksOutput) {
2104	op := &request.Operation{
2105		Name:       opListWebhooks,
2106		HTTPMethod: "POST",
2107		HTTPPath:   "/",
2108		Paginator: &request.Paginator{
2109			InputTokens:     []string{"NextToken"},
2110			OutputTokens:    []string{"NextToken"},
2111			LimitToken:      "MaxResults",
2112			TruncationToken: "",
2113		},
2114	}
2115
2116	if input == nil {
2117		input = &ListWebhooksInput{}
2118	}
2119
2120	output = &ListWebhooksOutput{}
2121	req = c.newRequest(op, input, output)
2122	return
2123}
2124
2125// ListWebhooks API operation for AWS CodePipeline.
2126//
2127// Gets a listing of all the webhooks in this AWS Region for this account. The
2128// output lists all webhooks and includes the webhook URL and ARN and the configuration
2129// for each webhook.
2130//
2131// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2132// with awserr.Error's Code and Message methods to get detailed information about
2133// the error.
2134//
2135// See the AWS API reference guide for AWS CodePipeline's
2136// API operation ListWebhooks for usage and error information.
2137//
2138// Returned Error Codes:
2139//   * ErrCodeValidationException "ValidationException"
2140//   The validation was specified in an invalid format.
2141//
2142//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
2143//   The next token was specified in an invalid format. Make sure that the next
2144//   token you provide is the token returned by a previous call.
2145//
2146// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/ListWebhooks
2147func (c *CodePipeline) ListWebhooks(input *ListWebhooksInput) (*ListWebhooksOutput, error) {
2148	req, out := c.ListWebhooksRequest(input)
2149	return out, req.Send()
2150}
2151
2152// ListWebhooksWithContext is the same as ListWebhooks with the addition of
2153// the ability to pass a context and additional request options.
2154//
2155// See ListWebhooks for details on how to use this API operation.
2156//
2157// The context must be non-nil and will be used for request cancellation. If
2158// the context is nil a panic will occur. In the future the SDK may create
2159// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2160// for more information on using Contexts.
2161func (c *CodePipeline) ListWebhooksWithContext(ctx aws.Context, input *ListWebhooksInput, opts ...request.Option) (*ListWebhooksOutput, error) {
2162	req, out := c.ListWebhooksRequest(input)
2163	req.SetContext(ctx)
2164	req.ApplyOptions(opts...)
2165	return out, req.Send()
2166}
2167
2168// ListWebhooksPages iterates over the pages of a ListWebhooks operation,
2169// calling the "fn" function with the response data for each page. To stop
2170// iterating, return false from the fn function.
2171//
2172// See ListWebhooks method for more information on how to use this operation.
2173//
2174// Note: This operation can generate multiple requests to a service.
2175//
2176//    // Example iterating over at most 3 pages of a ListWebhooks operation.
2177//    pageNum := 0
2178//    err := client.ListWebhooksPages(params,
2179//        func(page *codepipeline.ListWebhooksOutput, lastPage bool) bool {
2180//            pageNum++
2181//            fmt.Println(page)
2182//            return pageNum <= 3
2183//        })
2184//
2185func (c *CodePipeline) ListWebhooksPages(input *ListWebhooksInput, fn func(*ListWebhooksOutput, bool) bool) error {
2186	return c.ListWebhooksPagesWithContext(aws.BackgroundContext(), input, fn)
2187}
2188
2189// ListWebhooksPagesWithContext same as ListWebhooksPages except
2190// it takes a Context and allows setting request options on the pages.
2191//
2192// The context must be non-nil and will be used for request cancellation. If
2193// the context is nil a panic will occur. In the future the SDK may create
2194// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2195// for more information on using Contexts.
2196func (c *CodePipeline) ListWebhooksPagesWithContext(ctx aws.Context, input *ListWebhooksInput, fn func(*ListWebhooksOutput, bool) bool, opts ...request.Option) error {
2197	p := request.Pagination{
2198		NewRequest: func() (*request.Request, error) {
2199			var inCpy *ListWebhooksInput
2200			if input != nil {
2201				tmp := *input
2202				inCpy = &tmp
2203			}
2204			req, _ := c.ListWebhooksRequest(inCpy)
2205			req.SetContext(ctx)
2206			req.ApplyOptions(opts...)
2207			return req, nil
2208		},
2209	}
2210
2211	for p.Next() {
2212		if !fn(p.Page().(*ListWebhooksOutput), !p.HasNextPage()) {
2213			break
2214		}
2215	}
2216
2217	return p.Err()
2218}
2219
2220const opPollForJobs = "PollForJobs"
2221
2222// PollForJobsRequest generates a "aws/request.Request" representing the
2223// client's request for the PollForJobs operation. The "output" return
2224// value will be populated with the request's response once the request completes
2225// successfully.
2226//
2227// Use "Send" method on the returned Request to send the API call to the service.
2228// the "output" return value is not valid until after Send returns without error.
2229//
2230// See PollForJobs for more information on using the PollForJobs
2231// API call, and error handling.
2232//
2233// This method is useful when you want to inject custom logic or configuration
2234// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2235//
2236//
2237//    // Example sending a request using the PollForJobsRequest method.
2238//    req, resp := client.PollForJobsRequest(params)
2239//
2240//    err := req.Send()
2241//    if err == nil { // resp is now filled
2242//        fmt.Println(resp)
2243//    }
2244//
2245// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PollForJobs
2246func (c *CodePipeline) PollForJobsRequest(input *PollForJobsInput) (req *request.Request, output *PollForJobsOutput) {
2247	op := &request.Operation{
2248		Name:       opPollForJobs,
2249		HTTPMethod: "POST",
2250		HTTPPath:   "/",
2251	}
2252
2253	if input == nil {
2254		input = &PollForJobsInput{}
2255	}
2256
2257	output = &PollForJobsOutput{}
2258	req = c.newRequest(op, input, output)
2259	return
2260}
2261
2262// PollForJobs API operation for AWS CodePipeline.
2263//
2264// Returns information about any jobs for AWS CodePipeline to act on. PollForJobs
2265// is valid only for action types with "Custom" in the owner field. If the action
2266// type contains "AWS" or "ThirdParty" in the owner field, the PollForJobs action
2267// returns an error.
2268//
2269// When this API is called, AWS CodePipeline returns temporary credentials for
2270// the Amazon S3 bucket used to store artifacts for the pipeline, if the action
2271// requires access to that Amazon S3 bucket for input or output artifacts. This
2272// API also returns any secret values defined for the action.
2273//
2274// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2275// with awserr.Error's Code and Message methods to get detailed information about
2276// the error.
2277//
2278// See the AWS API reference guide for AWS CodePipeline's
2279// API operation PollForJobs for usage and error information.
2280//
2281// Returned Error Codes:
2282//   * ErrCodeValidationException "ValidationException"
2283//   The validation was specified in an invalid format.
2284//
2285//   * ErrCodeActionTypeNotFoundException "ActionTypeNotFoundException"
2286//   The specified action type cannot be found.
2287//
2288// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PollForJobs
2289func (c *CodePipeline) PollForJobs(input *PollForJobsInput) (*PollForJobsOutput, error) {
2290	req, out := c.PollForJobsRequest(input)
2291	return out, req.Send()
2292}
2293
2294// PollForJobsWithContext is the same as PollForJobs with the addition of
2295// the ability to pass a context and additional request options.
2296//
2297// See PollForJobs for details on how to use this API operation.
2298//
2299// The context must be non-nil and will be used for request cancellation. If
2300// the context is nil a panic will occur. In the future the SDK may create
2301// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2302// for more information on using Contexts.
2303func (c *CodePipeline) PollForJobsWithContext(ctx aws.Context, input *PollForJobsInput, opts ...request.Option) (*PollForJobsOutput, error) {
2304	req, out := c.PollForJobsRequest(input)
2305	req.SetContext(ctx)
2306	req.ApplyOptions(opts...)
2307	return out, req.Send()
2308}
2309
2310const opPollForThirdPartyJobs = "PollForThirdPartyJobs"
2311
2312// PollForThirdPartyJobsRequest generates a "aws/request.Request" representing the
2313// client's request for the PollForThirdPartyJobs operation. The "output" return
2314// value will be populated with the request's response once the request completes
2315// successfully.
2316//
2317// Use "Send" method on the returned Request to send the API call to the service.
2318// the "output" return value is not valid until after Send returns without error.
2319//
2320// See PollForThirdPartyJobs for more information on using the PollForThirdPartyJobs
2321// API call, and error handling.
2322//
2323// This method is useful when you want to inject custom logic or configuration
2324// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2325//
2326//
2327//    // Example sending a request using the PollForThirdPartyJobsRequest method.
2328//    req, resp := client.PollForThirdPartyJobsRequest(params)
2329//
2330//    err := req.Send()
2331//    if err == nil { // resp is now filled
2332//        fmt.Println(resp)
2333//    }
2334//
2335// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PollForThirdPartyJobs
2336func (c *CodePipeline) PollForThirdPartyJobsRequest(input *PollForThirdPartyJobsInput) (req *request.Request, output *PollForThirdPartyJobsOutput) {
2337	op := &request.Operation{
2338		Name:       opPollForThirdPartyJobs,
2339		HTTPMethod: "POST",
2340		HTTPPath:   "/",
2341	}
2342
2343	if input == nil {
2344		input = &PollForThirdPartyJobsInput{}
2345	}
2346
2347	output = &PollForThirdPartyJobsOutput{}
2348	req = c.newRequest(op, input, output)
2349	return
2350}
2351
2352// PollForThirdPartyJobs API operation for AWS CodePipeline.
2353//
2354// Determines whether there are any third party jobs for a job worker to act
2355// on. Used for partner actions only.
2356//
2357// When this API is called, AWS CodePipeline returns temporary credentials for
2358// the Amazon S3 bucket used to store artifacts for the pipeline, if the action
2359// requires access to that Amazon S3 bucket for input or output artifacts.
2360//
2361// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2362// with awserr.Error's Code and Message methods to get detailed information about
2363// the error.
2364//
2365// See the AWS API reference guide for AWS CodePipeline's
2366// API operation PollForThirdPartyJobs for usage and error information.
2367//
2368// Returned Error Codes:
2369//   * ErrCodeActionTypeNotFoundException "ActionTypeNotFoundException"
2370//   The specified action type cannot be found.
2371//
2372//   * ErrCodeValidationException "ValidationException"
2373//   The validation was specified in an invalid format.
2374//
2375// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PollForThirdPartyJobs
2376func (c *CodePipeline) PollForThirdPartyJobs(input *PollForThirdPartyJobsInput) (*PollForThirdPartyJobsOutput, error) {
2377	req, out := c.PollForThirdPartyJobsRequest(input)
2378	return out, req.Send()
2379}
2380
2381// PollForThirdPartyJobsWithContext is the same as PollForThirdPartyJobs with the addition of
2382// the ability to pass a context and additional request options.
2383//
2384// See PollForThirdPartyJobs for details on how to use this API operation.
2385//
2386// The context must be non-nil and will be used for request cancellation. If
2387// the context is nil a panic will occur. In the future the SDK may create
2388// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2389// for more information on using Contexts.
2390func (c *CodePipeline) PollForThirdPartyJobsWithContext(ctx aws.Context, input *PollForThirdPartyJobsInput, opts ...request.Option) (*PollForThirdPartyJobsOutput, error) {
2391	req, out := c.PollForThirdPartyJobsRequest(input)
2392	req.SetContext(ctx)
2393	req.ApplyOptions(opts...)
2394	return out, req.Send()
2395}
2396
2397const opPutActionRevision = "PutActionRevision"
2398
2399// PutActionRevisionRequest generates a "aws/request.Request" representing the
2400// client's request for the PutActionRevision operation. The "output" return
2401// value will be populated with the request's response once the request completes
2402// successfully.
2403//
2404// Use "Send" method on the returned Request to send the API call to the service.
2405// the "output" return value is not valid until after Send returns without error.
2406//
2407// See PutActionRevision for more information on using the PutActionRevision
2408// API call, and error handling.
2409//
2410// This method is useful when you want to inject custom logic or configuration
2411// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2412//
2413//
2414//    // Example sending a request using the PutActionRevisionRequest method.
2415//    req, resp := client.PutActionRevisionRequest(params)
2416//
2417//    err := req.Send()
2418//    if err == nil { // resp is now filled
2419//        fmt.Println(resp)
2420//    }
2421//
2422// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutActionRevision
2423func (c *CodePipeline) PutActionRevisionRequest(input *PutActionRevisionInput) (req *request.Request, output *PutActionRevisionOutput) {
2424	op := &request.Operation{
2425		Name:       opPutActionRevision,
2426		HTTPMethod: "POST",
2427		HTTPPath:   "/",
2428	}
2429
2430	if input == nil {
2431		input = &PutActionRevisionInput{}
2432	}
2433
2434	output = &PutActionRevisionOutput{}
2435	req = c.newRequest(op, input, output)
2436	return
2437}
2438
2439// PutActionRevision API operation for AWS CodePipeline.
2440//
2441// Provides information to AWS CodePipeline about new revisions to a source.
2442//
2443// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2444// with awserr.Error's Code and Message methods to get detailed information about
2445// the error.
2446//
2447// See the AWS API reference guide for AWS CodePipeline's
2448// API operation PutActionRevision for usage and error information.
2449//
2450// Returned Error Codes:
2451//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
2452//   The pipeline was specified in an invalid format or cannot be found.
2453//
2454//   * ErrCodeStageNotFoundException "StageNotFoundException"
2455//   The stage was specified in an invalid format or cannot be found.
2456//
2457//   * ErrCodeActionNotFoundException "ActionNotFoundException"
2458//   The specified action cannot be found.
2459//
2460//   * ErrCodeValidationException "ValidationException"
2461//   The validation was specified in an invalid format.
2462//
2463// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutActionRevision
2464func (c *CodePipeline) PutActionRevision(input *PutActionRevisionInput) (*PutActionRevisionOutput, error) {
2465	req, out := c.PutActionRevisionRequest(input)
2466	return out, req.Send()
2467}
2468
2469// PutActionRevisionWithContext is the same as PutActionRevision with the addition of
2470// the ability to pass a context and additional request options.
2471//
2472// See PutActionRevision for details on how to use this API operation.
2473//
2474// The context must be non-nil and will be used for request cancellation. If
2475// the context is nil a panic will occur. In the future the SDK may create
2476// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2477// for more information on using Contexts.
2478func (c *CodePipeline) PutActionRevisionWithContext(ctx aws.Context, input *PutActionRevisionInput, opts ...request.Option) (*PutActionRevisionOutput, error) {
2479	req, out := c.PutActionRevisionRequest(input)
2480	req.SetContext(ctx)
2481	req.ApplyOptions(opts...)
2482	return out, req.Send()
2483}
2484
2485const opPutApprovalResult = "PutApprovalResult"
2486
2487// PutApprovalResultRequest generates a "aws/request.Request" representing the
2488// client's request for the PutApprovalResult operation. The "output" return
2489// value will be populated with the request's response once the request completes
2490// successfully.
2491//
2492// Use "Send" method on the returned Request to send the API call to the service.
2493// the "output" return value is not valid until after Send returns without error.
2494//
2495// See PutApprovalResult for more information on using the PutApprovalResult
2496// API call, and error handling.
2497//
2498// This method is useful when you want to inject custom logic or configuration
2499// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2500//
2501//
2502//    // Example sending a request using the PutApprovalResultRequest method.
2503//    req, resp := client.PutApprovalResultRequest(params)
2504//
2505//    err := req.Send()
2506//    if err == nil { // resp is now filled
2507//        fmt.Println(resp)
2508//    }
2509//
2510// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutApprovalResult
2511func (c *CodePipeline) PutApprovalResultRequest(input *PutApprovalResultInput) (req *request.Request, output *PutApprovalResultOutput) {
2512	op := &request.Operation{
2513		Name:       opPutApprovalResult,
2514		HTTPMethod: "POST",
2515		HTTPPath:   "/",
2516	}
2517
2518	if input == nil {
2519		input = &PutApprovalResultInput{}
2520	}
2521
2522	output = &PutApprovalResultOutput{}
2523	req = c.newRequest(op, input, output)
2524	return
2525}
2526
2527// PutApprovalResult API operation for AWS CodePipeline.
2528//
2529// Provides the response to a manual approval request to AWS CodePipeline. Valid
2530// responses include Approved and Rejected.
2531//
2532// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2533// with awserr.Error's Code and Message methods to get detailed information about
2534// the error.
2535//
2536// See the AWS API reference guide for AWS CodePipeline's
2537// API operation PutApprovalResult for usage and error information.
2538//
2539// Returned Error Codes:
2540//   * ErrCodeInvalidApprovalTokenException "InvalidApprovalTokenException"
2541//   The approval request already received a response or has expired.
2542//
2543//   * ErrCodeApprovalAlreadyCompletedException "ApprovalAlreadyCompletedException"
2544//   The approval action has already been approved or rejected.
2545//
2546//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
2547//   The pipeline was specified in an invalid format or cannot be found.
2548//
2549//   * ErrCodeStageNotFoundException "StageNotFoundException"
2550//   The stage was specified in an invalid format or cannot be found.
2551//
2552//   * ErrCodeActionNotFoundException "ActionNotFoundException"
2553//   The specified action cannot be found.
2554//
2555//   * ErrCodeValidationException "ValidationException"
2556//   The validation was specified in an invalid format.
2557//
2558// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutApprovalResult
2559func (c *CodePipeline) PutApprovalResult(input *PutApprovalResultInput) (*PutApprovalResultOutput, error) {
2560	req, out := c.PutApprovalResultRequest(input)
2561	return out, req.Send()
2562}
2563
2564// PutApprovalResultWithContext is the same as PutApprovalResult with the addition of
2565// the ability to pass a context and additional request options.
2566//
2567// See PutApprovalResult for details on how to use this API operation.
2568//
2569// The context must be non-nil and will be used for request cancellation. If
2570// the context is nil a panic will occur. In the future the SDK may create
2571// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2572// for more information on using Contexts.
2573func (c *CodePipeline) PutApprovalResultWithContext(ctx aws.Context, input *PutApprovalResultInput, opts ...request.Option) (*PutApprovalResultOutput, error) {
2574	req, out := c.PutApprovalResultRequest(input)
2575	req.SetContext(ctx)
2576	req.ApplyOptions(opts...)
2577	return out, req.Send()
2578}
2579
2580const opPutJobFailureResult = "PutJobFailureResult"
2581
2582// PutJobFailureResultRequest generates a "aws/request.Request" representing the
2583// client's request for the PutJobFailureResult operation. The "output" return
2584// value will be populated with the request's response once the request completes
2585// successfully.
2586//
2587// Use "Send" method on the returned Request to send the API call to the service.
2588// the "output" return value is not valid until after Send returns without error.
2589//
2590// See PutJobFailureResult for more information on using the PutJobFailureResult
2591// API call, and error handling.
2592//
2593// This method is useful when you want to inject custom logic or configuration
2594// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2595//
2596//
2597//    // Example sending a request using the PutJobFailureResultRequest method.
2598//    req, resp := client.PutJobFailureResultRequest(params)
2599//
2600//    err := req.Send()
2601//    if err == nil { // resp is now filled
2602//        fmt.Println(resp)
2603//    }
2604//
2605// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutJobFailureResult
2606func (c *CodePipeline) PutJobFailureResultRequest(input *PutJobFailureResultInput) (req *request.Request, output *PutJobFailureResultOutput) {
2607	op := &request.Operation{
2608		Name:       opPutJobFailureResult,
2609		HTTPMethod: "POST",
2610		HTTPPath:   "/",
2611	}
2612
2613	if input == nil {
2614		input = &PutJobFailureResultInput{}
2615	}
2616
2617	output = &PutJobFailureResultOutput{}
2618	req = c.newRequest(op, input, output)
2619	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2620	return
2621}
2622
2623// PutJobFailureResult API operation for AWS CodePipeline.
2624//
2625// Represents the failure of a job as returned to the pipeline by a job worker.
2626// Used for custom actions only.
2627//
2628// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2629// with awserr.Error's Code and Message methods to get detailed information about
2630// the error.
2631//
2632// See the AWS API reference guide for AWS CodePipeline's
2633// API operation PutJobFailureResult for usage and error information.
2634//
2635// Returned Error Codes:
2636//   * ErrCodeValidationException "ValidationException"
2637//   The validation was specified in an invalid format.
2638//
2639//   * ErrCodeJobNotFoundException "JobNotFoundException"
2640//   The job was specified in an invalid format or cannot be found.
2641//
2642//   * ErrCodeInvalidJobStateException "InvalidJobStateException"
2643//   The job state was specified in an invalid format.
2644//
2645// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutJobFailureResult
2646func (c *CodePipeline) PutJobFailureResult(input *PutJobFailureResultInput) (*PutJobFailureResultOutput, error) {
2647	req, out := c.PutJobFailureResultRequest(input)
2648	return out, req.Send()
2649}
2650
2651// PutJobFailureResultWithContext is the same as PutJobFailureResult with the addition of
2652// the ability to pass a context and additional request options.
2653//
2654// See PutJobFailureResult for details on how to use this API operation.
2655//
2656// The context must be non-nil and will be used for request cancellation. If
2657// the context is nil a panic will occur. In the future the SDK may create
2658// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2659// for more information on using Contexts.
2660func (c *CodePipeline) PutJobFailureResultWithContext(ctx aws.Context, input *PutJobFailureResultInput, opts ...request.Option) (*PutJobFailureResultOutput, error) {
2661	req, out := c.PutJobFailureResultRequest(input)
2662	req.SetContext(ctx)
2663	req.ApplyOptions(opts...)
2664	return out, req.Send()
2665}
2666
2667const opPutJobSuccessResult = "PutJobSuccessResult"
2668
2669// PutJobSuccessResultRequest generates a "aws/request.Request" representing the
2670// client's request for the PutJobSuccessResult operation. The "output" return
2671// value will be populated with the request's response once the request completes
2672// successfully.
2673//
2674// Use "Send" method on the returned Request to send the API call to the service.
2675// the "output" return value is not valid until after Send returns without error.
2676//
2677// See PutJobSuccessResult for more information on using the PutJobSuccessResult
2678// API call, and error handling.
2679//
2680// This method is useful when you want to inject custom logic or configuration
2681// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2682//
2683//
2684//    // Example sending a request using the PutJobSuccessResultRequest method.
2685//    req, resp := client.PutJobSuccessResultRequest(params)
2686//
2687//    err := req.Send()
2688//    if err == nil { // resp is now filled
2689//        fmt.Println(resp)
2690//    }
2691//
2692// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutJobSuccessResult
2693func (c *CodePipeline) PutJobSuccessResultRequest(input *PutJobSuccessResultInput) (req *request.Request, output *PutJobSuccessResultOutput) {
2694	op := &request.Operation{
2695		Name:       opPutJobSuccessResult,
2696		HTTPMethod: "POST",
2697		HTTPPath:   "/",
2698	}
2699
2700	if input == nil {
2701		input = &PutJobSuccessResultInput{}
2702	}
2703
2704	output = &PutJobSuccessResultOutput{}
2705	req = c.newRequest(op, input, output)
2706	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2707	return
2708}
2709
2710// PutJobSuccessResult API operation for AWS CodePipeline.
2711//
2712// Represents the success of a job as returned to the pipeline by a job worker.
2713// Used for custom actions only.
2714//
2715// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2716// with awserr.Error's Code and Message methods to get detailed information about
2717// the error.
2718//
2719// See the AWS API reference guide for AWS CodePipeline's
2720// API operation PutJobSuccessResult for usage and error information.
2721//
2722// Returned Error Codes:
2723//   * ErrCodeValidationException "ValidationException"
2724//   The validation was specified in an invalid format.
2725//
2726//   * ErrCodeJobNotFoundException "JobNotFoundException"
2727//   The job was specified in an invalid format or cannot be found.
2728//
2729//   * ErrCodeInvalidJobStateException "InvalidJobStateException"
2730//   The job state was specified in an invalid format.
2731//
2732//   * ErrCodeOutputVariablesSizeExceededException "OutputVariablesSizeExceededException"
2733//   Exceeded the total size limit for all variables in the pipeline.
2734//
2735// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutJobSuccessResult
2736func (c *CodePipeline) PutJobSuccessResult(input *PutJobSuccessResultInput) (*PutJobSuccessResultOutput, error) {
2737	req, out := c.PutJobSuccessResultRequest(input)
2738	return out, req.Send()
2739}
2740
2741// PutJobSuccessResultWithContext is the same as PutJobSuccessResult with the addition of
2742// the ability to pass a context and additional request options.
2743//
2744// See PutJobSuccessResult for details on how to use this API operation.
2745//
2746// The context must be non-nil and will be used for request cancellation. If
2747// the context is nil a panic will occur. In the future the SDK may create
2748// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2749// for more information on using Contexts.
2750func (c *CodePipeline) PutJobSuccessResultWithContext(ctx aws.Context, input *PutJobSuccessResultInput, opts ...request.Option) (*PutJobSuccessResultOutput, error) {
2751	req, out := c.PutJobSuccessResultRequest(input)
2752	req.SetContext(ctx)
2753	req.ApplyOptions(opts...)
2754	return out, req.Send()
2755}
2756
2757const opPutThirdPartyJobFailureResult = "PutThirdPartyJobFailureResult"
2758
2759// PutThirdPartyJobFailureResultRequest generates a "aws/request.Request" representing the
2760// client's request for the PutThirdPartyJobFailureResult operation. The "output" return
2761// value will be populated with the request's response once the request completes
2762// successfully.
2763//
2764// Use "Send" method on the returned Request to send the API call to the service.
2765// the "output" return value is not valid until after Send returns without error.
2766//
2767// See PutThirdPartyJobFailureResult for more information on using the PutThirdPartyJobFailureResult
2768// API call, and error handling.
2769//
2770// This method is useful when you want to inject custom logic or configuration
2771// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2772//
2773//
2774//    // Example sending a request using the PutThirdPartyJobFailureResultRequest method.
2775//    req, resp := client.PutThirdPartyJobFailureResultRequest(params)
2776//
2777//    err := req.Send()
2778//    if err == nil { // resp is now filled
2779//        fmt.Println(resp)
2780//    }
2781//
2782// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutThirdPartyJobFailureResult
2783func (c *CodePipeline) PutThirdPartyJobFailureResultRequest(input *PutThirdPartyJobFailureResultInput) (req *request.Request, output *PutThirdPartyJobFailureResultOutput) {
2784	op := &request.Operation{
2785		Name:       opPutThirdPartyJobFailureResult,
2786		HTTPMethod: "POST",
2787		HTTPPath:   "/",
2788	}
2789
2790	if input == nil {
2791		input = &PutThirdPartyJobFailureResultInput{}
2792	}
2793
2794	output = &PutThirdPartyJobFailureResultOutput{}
2795	req = c.newRequest(op, input, output)
2796	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2797	return
2798}
2799
2800// PutThirdPartyJobFailureResult API operation for AWS CodePipeline.
2801//
2802// Represents the failure of a third party job as returned to the pipeline by
2803// a job worker. Used for partner actions only.
2804//
2805// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2806// with awserr.Error's Code and Message methods to get detailed information about
2807// the error.
2808//
2809// See the AWS API reference guide for AWS CodePipeline's
2810// API operation PutThirdPartyJobFailureResult for usage and error information.
2811//
2812// Returned Error Codes:
2813//   * ErrCodeValidationException "ValidationException"
2814//   The validation was specified in an invalid format.
2815//
2816//   * ErrCodeJobNotFoundException "JobNotFoundException"
2817//   The job was specified in an invalid format or cannot be found.
2818//
2819//   * ErrCodeInvalidJobStateException "InvalidJobStateException"
2820//   The job state was specified in an invalid format.
2821//
2822//   * ErrCodeInvalidClientTokenException "InvalidClientTokenException"
2823//   The client token was specified in an invalid format
2824//
2825// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutThirdPartyJobFailureResult
2826func (c *CodePipeline) PutThirdPartyJobFailureResult(input *PutThirdPartyJobFailureResultInput) (*PutThirdPartyJobFailureResultOutput, error) {
2827	req, out := c.PutThirdPartyJobFailureResultRequest(input)
2828	return out, req.Send()
2829}
2830
2831// PutThirdPartyJobFailureResultWithContext is the same as PutThirdPartyJobFailureResult with the addition of
2832// the ability to pass a context and additional request options.
2833//
2834// See PutThirdPartyJobFailureResult for details on how to use this API operation.
2835//
2836// The context must be non-nil and will be used for request cancellation. If
2837// the context is nil a panic will occur. In the future the SDK may create
2838// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2839// for more information on using Contexts.
2840func (c *CodePipeline) PutThirdPartyJobFailureResultWithContext(ctx aws.Context, input *PutThirdPartyJobFailureResultInput, opts ...request.Option) (*PutThirdPartyJobFailureResultOutput, error) {
2841	req, out := c.PutThirdPartyJobFailureResultRequest(input)
2842	req.SetContext(ctx)
2843	req.ApplyOptions(opts...)
2844	return out, req.Send()
2845}
2846
2847const opPutThirdPartyJobSuccessResult = "PutThirdPartyJobSuccessResult"
2848
2849// PutThirdPartyJobSuccessResultRequest generates a "aws/request.Request" representing the
2850// client's request for the PutThirdPartyJobSuccessResult operation. The "output" return
2851// value will be populated with the request's response once the request completes
2852// successfully.
2853//
2854// Use "Send" method on the returned Request to send the API call to the service.
2855// the "output" return value is not valid until after Send returns without error.
2856//
2857// See PutThirdPartyJobSuccessResult for more information on using the PutThirdPartyJobSuccessResult
2858// API call, and error handling.
2859//
2860// This method is useful when you want to inject custom logic or configuration
2861// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2862//
2863//
2864//    // Example sending a request using the PutThirdPartyJobSuccessResultRequest method.
2865//    req, resp := client.PutThirdPartyJobSuccessResultRequest(params)
2866//
2867//    err := req.Send()
2868//    if err == nil { // resp is now filled
2869//        fmt.Println(resp)
2870//    }
2871//
2872// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutThirdPartyJobSuccessResult
2873func (c *CodePipeline) PutThirdPartyJobSuccessResultRequest(input *PutThirdPartyJobSuccessResultInput) (req *request.Request, output *PutThirdPartyJobSuccessResultOutput) {
2874	op := &request.Operation{
2875		Name:       opPutThirdPartyJobSuccessResult,
2876		HTTPMethod: "POST",
2877		HTTPPath:   "/",
2878	}
2879
2880	if input == nil {
2881		input = &PutThirdPartyJobSuccessResultInput{}
2882	}
2883
2884	output = &PutThirdPartyJobSuccessResultOutput{}
2885	req = c.newRequest(op, input, output)
2886	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
2887	return
2888}
2889
2890// PutThirdPartyJobSuccessResult API operation for AWS CodePipeline.
2891//
2892// Represents the success of a third party job as returned to the pipeline by
2893// a job worker. Used for partner actions only.
2894//
2895// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2896// with awserr.Error's Code and Message methods to get detailed information about
2897// the error.
2898//
2899// See the AWS API reference guide for AWS CodePipeline's
2900// API operation PutThirdPartyJobSuccessResult for usage and error information.
2901//
2902// Returned Error Codes:
2903//   * ErrCodeValidationException "ValidationException"
2904//   The validation was specified in an invalid format.
2905//
2906//   * ErrCodeJobNotFoundException "JobNotFoundException"
2907//   The job was specified in an invalid format or cannot be found.
2908//
2909//   * ErrCodeInvalidJobStateException "InvalidJobStateException"
2910//   The job state was specified in an invalid format.
2911//
2912//   * ErrCodeInvalidClientTokenException "InvalidClientTokenException"
2913//   The client token was specified in an invalid format
2914//
2915// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutThirdPartyJobSuccessResult
2916func (c *CodePipeline) PutThirdPartyJobSuccessResult(input *PutThirdPartyJobSuccessResultInput) (*PutThirdPartyJobSuccessResultOutput, error) {
2917	req, out := c.PutThirdPartyJobSuccessResultRequest(input)
2918	return out, req.Send()
2919}
2920
2921// PutThirdPartyJobSuccessResultWithContext is the same as PutThirdPartyJobSuccessResult with the addition of
2922// the ability to pass a context and additional request options.
2923//
2924// See PutThirdPartyJobSuccessResult for details on how to use this API operation.
2925//
2926// The context must be non-nil and will be used for request cancellation. If
2927// the context is nil a panic will occur. In the future the SDK may create
2928// sub-contexts for http.Requests. See https://golang.org/pkg/context/
2929// for more information on using Contexts.
2930func (c *CodePipeline) PutThirdPartyJobSuccessResultWithContext(ctx aws.Context, input *PutThirdPartyJobSuccessResultInput, opts ...request.Option) (*PutThirdPartyJobSuccessResultOutput, error) {
2931	req, out := c.PutThirdPartyJobSuccessResultRequest(input)
2932	req.SetContext(ctx)
2933	req.ApplyOptions(opts...)
2934	return out, req.Send()
2935}
2936
2937const opPutWebhook = "PutWebhook"
2938
2939// PutWebhookRequest generates a "aws/request.Request" representing the
2940// client's request for the PutWebhook operation. The "output" return
2941// value will be populated with the request's response once the request completes
2942// successfully.
2943//
2944// Use "Send" method on the returned Request to send the API call to the service.
2945// the "output" return value is not valid until after Send returns without error.
2946//
2947// See PutWebhook for more information on using the PutWebhook
2948// API call, and error handling.
2949//
2950// This method is useful when you want to inject custom logic or configuration
2951// into the SDK's request lifecycle. Such as custom headers, or retry logic.
2952//
2953//
2954//    // Example sending a request using the PutWebhookRequest method.
2955//    req, resp := client.PutWebhookRequest(params)
2956//
2957//    err := req.Send()
2958//    if err == nil { // resp is now filled
2959//        fmt.Println(resp)
2960//    }
2961//
2962// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutWebhook
2963func (c *CodePipeline) PutWebhookRequest(input *PutWebhookInput) (req *request.Request, output *PutWebhookOutput) {
2964	op := &request.Operation{
2965		Name:       opPutWebhook,
2966		HTTPMethod: "POST",
2967		HTTPPath:   "/",
2968	}
2969
2970	if input == nil {
2971		input = &PutWebhookInput{}
2972	}
2973
2974	output = &PutWebhookOutput{}
2975	req = c.newRequest(op, input, output)
2976	return
2977}
2978
2979// PutWebhook API operation for AWS CodePipeline.
2980//
2981// Defines a webhook and returns a unique webhook URL generated by CodePipeline.
2982// This URL can be supplied to third party source hosting providers to call
2983// every time there's a code change. When CodePipeline receives a POST request
2984// on this URL, the pipeline defined in the webhook is started as long as the
2985// POST request satisfied the authentication and filtering requirements supplied
2986// when defining the webhook. RegisterWebhookWithThirdParty and DeregisterWebhookWithThirdParty
2987// APIs can be used to automatically configure supported third parties to call
2988// the generated webhook URL.
2989//
2990// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
2991// with awserr.Error's Code and Message methods to get detailed information about
2992// the error.
2993//
2994// See the AWS API reference guide for AWS CodePipeline's
2995// API operation PutWebhook for usage and error information.
2996//
2997// Returned Error Codes:
2998//   * ErrCodeValidationException "ValidationException"
2999//   The validation was specified in an invalid format.
3000//
3001//   * ErrCodeLimitExceededException "LimitExceededException"
3002//   The number of pipelines associated with the AWS account has exceeded the
3003//   limit allowed for the account.
3004//
3005//   * ErrCodeInvalidWebhookFilterPatternException "InvalidWebhookFilterPatternException"
3006//   The specified event filter rule is in an invalid format.
3007//
3008//   * ErrCodeInvalidWebhookAuthenticationParametersException "InvalidWebhookAuthenticationParametersException"
3009//   The specified authentication type is in an invalid format.
3010//
3011//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
3012//   The pipeline was specified in an invalid format or cannot be found.
3013//
3014//   * ErrCodeTooManyTagsException "TooManyTagsException"
3015//   The tags limit for a resource has been exceeded.
3016//
3017//   * ErrCodeInvalidTagsException "InvalidTagsException"
3018//   The specified resource tags are invalid.
3019//
3020//   * ErrCodeConcurrentModificationException "ConcurrentModificationException"
3021//   Unable to modify the tag due to a simultaneous update request.
3022//
3023// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/PutWebhook
3024func (c *CodePipeline) PutWebhook(input *PutWebhookInput) (*PutWebhookOutput, error) {
3025	req, out := c.PutWebhookRequest(input)
3026	return out, req.Send()
3027}
3028
3029// PutWebhookWithContext is the same as PutWebhook with the addition of
3030// the ability to pass a context and additional request options.
3031//
3032// See PutWebhook for details on how to use this API operation.
3033//
3034// The context must be non-nil and will be used for request cancellation. If
3035// the context is nil a panic will occur. In the future the SDK may create
3036// sub-contexts for http.Requests. See https://golang.org/pkg/context/
3037// for more information on using Contexts.
3038func (c *CodePipeline) PutWebhookWithContext(ctx aws.Context, input *PutWebhookInput, opts ...request.Option) (*PutWebhookOutput, error) {
3039	req, out := c.PutWebhookRequest(input)
3040	req.SetContext(ctx)
3041	req.ApplyOptions(opts...)
3042	return out, req.Send()
3043}
3044
3045const opRegisterWebhookWithThirdParty = "RegisterWebhookWithThirdParty"
3046
3047// RegisterWebhookWithThirdPartyRequest generates a "aws/request.Request" representing the
3048// client's request for the RegisterWebhookWithThirdParty operation. The "output" return
3049// value will be populated with the request's response once the request completes
3050// successfully.
3051//
3052// Use "Send" method on the returned Request to send the API call to the service.
3053// the "output" return value is not valid until after Send returns without error.
3054//
3055// See RegisterWebhookWithThirdParty for more information on using the RegisterWebhookWithThirdParty
3056// API call, and error handling.
3057//
3058// This method is useful when you want to inject custom logic or configuration
3059// into the SDK's request lifecycle. Such as custom headers, or retry logic.
3060//
3061//
3062//    // Example sending a request using the RegisterWebhookWithThirdPartyRequest method.
3063//    req, resp := client.RegisterWebhookWithThirdPartyRequest(params)
3064//
3065//    err := req.Send()
3066//    if err == nil { // resp is now filled
3067//        fmt.Println(resp)
3068//    }
3069//
3070// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/RegisterWebhookWithThirdParty
3071func (c *CodePipeline) RegisterWebhookWithThirdPartyRequest(input *RegisterWebhookWithThirdPartyInput) (req *request.Request, output *RegisterWebhookWithThirdPartyOutput) {
3072	op := &request.Operation{
3073		Name:       opRegisterWebhookWithThirdParty,
3074		HTTPMethod: "POST",
3075		HTTPPath:   "/",
3076	}
3077
3078	if input == nil {
3079		input = &RegisterWebhookWithThirdPartyInput{}
3080	}
3081
3082	output = &RegisterWebhookWithThirdPartyOutput{}
3083	req = c.newRequest(op, input, output)
3084	req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
3085	return
3086}
3087
3088// RegisterWebhookWithThirdParty API operation for AWS CodePipeline.
3089//
3090// Configures a connection between the webhook that was created and the external
3091// tool with events to be detected.
3092//
3093// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
3094// with awserr.Error's Code and Message methods to get detailed information about
3095// the error.
3096//
3097// See the AWS API reference guide for AWS CodePipeline's
3098// API operation RegisterWebhookWithThirdParty for usage and error information.
3099//
3100// Returned Error Codes:
3101//   * ErrCodeValidationException "ValidationException"
3102//   The validation was specified in an invalid format.
3103//
3104//   * ErrCodeWebhookNotFoundException "WebhookNotFoundException"
3105//   The specified webhook was entered in an invalid format or cannot be found.
3106//
3107// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/RegisterWebhookWithThirdParty
3108func (c *CodePipeline) RegisterWebhookWithThirdParty(input *RegisterWebhookWithThirdPartyInput) (*RegisterWebhookWithThirdPartyOutput, error) {
3109	req, out := c.RegisterWebhookWithThirdPartyRequest(input)
3110	return out, req.Send()
3111}
3112
3113// RegisterWebhookWithThirdPartyWithContext is the same as RegisterWebhookWithThirdParty with the addition of
3114// the ability to pass a context and additional request options.
3115//
3116// See RegisterWebhookWithThirdParty for details on how to use this API operation.
3117//
3118// The context must be non-nil and will be used for request cancellation. If
3119// the context is nil a panic will occur. In the future the SDK may create
3120// sub-contexts for http.Requests. See https://golang.org/pkg/context/
3121// for more information on using Contexts.
3122func (c *CodePipeline) RegisterWebhookWithThirdPartyWithContext(ctx aws.Context, input *RegisterWebhookWithThirdPartyInput, opts ...request.Option) (*RegisterWebhookWithThirdPartyOutput, error) {
3123	req, out := c.RegisterWebhookWithThirdPartyRequest(input)
3124	req.SetContext(ctx)
3125	req.ApplyOptions(opts...)
3126	return out, req.Send()
3127}
3128
3129const opRetryStageExecution = "RetryStageExecution"
3130
3131// RetryStageExecutionRequest generates a "aws/request.Request" representing the
3132// client's request for the RetryStageExecution operation. The "output" return
3133// value will be populated with the request's response once the request completes
3134// successfully.
3135//
3136// Use "Send" method on the returned Request to send the API call to the service.
3137// the "output" return value is not valid until after Send returns without error.
3138//
3139// See RetryStageExecution for more information on using the RetryStageExecution
3140// API call, and error handling.
3141//
3142// This method is useful when you want to inject custom logic or configuration
3143// into the SDK's request lifecycle. Such as custom headers, or retry logic.
3144//
3145//
3146//    // Example sending a request using the RetryStageExecutionRequest method.
3147//    req, resp := client.RetryStageExecutionRequest(params)
3148//
3149//    err := req.Send()
3150//    if err == nil { // resp is now filled
3151//        fmt.Println(resp)
3152//    }
3153//
3154// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/RetryStageExecution
3155func (c *CodePipeline) RetryStageExecutionRequest(input *RetryStageExecutionInput) (req *request.Request, output *RetryStageExecutionOutput) {
3156	op := &request.Operation{
3157		Name:       opRetryStageExecution,
3158		HTTPMethod: "POST",
3159		HTTPPath:   "/",
3160	}
3161
3162	if input == nil {
3163		input = &RetryStageExecutionInput{}
3164	}
3165
3166	output = &RetryStageExecutionOutput{}
3167	req = c.newRequest(op, input, output)
3168	return
3169}
3170
3171// RetryStageExecution API operation for AWS CodePipeline.
3172//
3173// Resumes the pipeline execution by retrying the last failed actions in a stage.
3174// You can retry a stage immediately if any of the actions in the stage fail.
3175// When you retry, all actions that are still in progress continue working,
3176// and failed actions are triggered again.
3177//
3178// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
3179// with awserr.Error's Code and Message methods to get detailed information about
3180// the error.
3181//
3182// See the AWS API reference guide for AWS CodePipeline's
3183// API operation RetryStageExecution for usage and error information.
3184//
3185// Returned Error Codes:
3186//   * ErrCodeValidationException "ValidationException"
3187//   The validation was specified in an invalid format.
3188//
3189//   * ErrCodePipelineNotFoundException "PipelineNotFoundException"
3190//   The pipeline was specified in an invalid format or cannot be found.
3191//
3192//   * ErrCodeStageNotFoundException "StageNotFoundException"
3193//   The stage was specified in an invalid format or cannot be found.
3194//
3195//   * ErrCodeStageNotRetryableException "StageNotRetryableException"
3196//   Unable to retry. The pipeline structure or stage state might have changed
3197//   while actions awaited retry, or the stage contains no failed actions.
3198//
3199//   * ErrCodeNotLatestPipelineExecutionException "NotLatestPipelineExecutionException"
3200//   The stage has failed in a later run of the pipeline and the pipelineExecutionId
3201//   associated with the request is out of date.
3202//
3203// See also, https://docs.aws.amazon.com/goto/WebAPI/codepipeline-2015-07-09/RetryStageExecution
3204func (c *CodePipeline) RetryStageExecution(input *RetryStageExecutionInput) (*RetryStageExecutionOutput, error) {
3205	req, out := c.RetryStageExecutionRequest(input)
3206	return out, req.Send()
3207}
3208
3209// RetryStageExecutionWithContext is the same as RetryStageExecution with the addition of
3210// the ability to pass a context and additional request options.
3211//
3212// See RetryStageExecution for details on how to use this API operation.
3213//
3214// The context must be non-nil and will be used for request cancellation. If
3215// the context is nil a panic will occur. In the future the SDK may create
3216// sub-contexts for http.Requests. See https://golang.org/pkg/context/
3217// for more information on using Contexts.
3218func (c *