api.go

// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.

// Package datapipeline provides a client for AWS Data Pipeline.
package datapipeline

import (
	"sync"
	"time"

	"github.com/aws/aws-sdk-go/aws"
)

var oprw sync.Mutex

// ActivatePipelineRequest generates a request for the ActivatePipeline operation.
func (c *DataPipeline) ActivatePipelineRequest(input *ActivatePipelineInput) (req *aws.Request, output *ActivatePipelineOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opActivatePipeline == nil {
		opActivatePipeline = &aws.Operation{
			Name:       "ActivatePipeline",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &ActivatePipelineInput{}
	}

	req = c.newRequest(opActivatePipeline, input, output)
	output = &ActivatePipelineOutput{}
	req.Data = output
	return
}

// Validates the specified pipeline and starts processing pipeline tasks. If
// the pipeline does not pass validation, activation fails.
//
// If you need to pause the pipeline to investigate an issue with a component,
// such as a data source or script, call DeactivatePipeline.
//
// To activate a finished pipeline, modify the end date for the pipeline and
// then activate it.
func (c *DataPipeline) ActivatePipeline(input *ActivatePipelineInput) (*ActivatePipelineOutput, error) {
	req, out := c.ActivatePipelineRequest(input)
	err := req.Send()
	return out, err
}

var opActivatePipeline *aws.Operation

// AddTagsRequest generates a request for the AddTags operation.
func (c *DataPipeline) AddTagsRequest(input *AddTagsInput) (req *aws.Request, output *AddTagsOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opAddTags == nil {
		opAddTags = &aws.Operation{
			Name:       "AddTags",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &AddTagsInput{}
	}

	req = c.newRequest(opAddTags, input, output)
	output = &AddTagsOutput{}
	req.Data = output
	return
}

// Adds or modifies tags for the specified pipeline.
func (c *DataPipeline) AddTags(input *AddTagsInput) (*AddTagsOutput, error) {
	req, out := c.AddTagsRequest(input)
	err := req.Send()
	return out, err
}

var opAddTags *aws.Operation

// CreatePipelineRequest generates a request for the CreatePipeline operation.
func (c *DataPipeline) CreatePipelineRequest(input *CreatePipelineInput) (req *aws.Request, output *CreatePipelineOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opCreatePipeline == nil {
		opCreatePipeline = &aws.Operation{
			Name:       "CreatePipeline",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &CreatePipelineInput{}
	}

	req = c.newRequest(opCreatePipeline, input, output)
	output = &CreatePipelineOutput{}
	req.Data = output
	return
}

// Creates a new, empty pipeline. Use PutPipelineDefinition to populate the
// pipeline.
func (c *DataPipeline) CreatePipeline(input *CreatePipelineInput) (*CreatePipelineOutput, error) {
	req, out := c.CreatePipelineRequest(input)
	err := req.Send()
	return out, err
}

var opCreatePipeline *aws.Operation

// DeactivatePipelineRequest generates a request for the DeactivatePipeline operation.
func (c *DataPipeline) DeactivatePipelineRequest(input *DeactivatePipelineInput) (req *aws.Request, output *DeactivatePipelineOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDeactivatePipeline == nil {
		opDeactivatePipeline = &aws.Operation{
			Name:       "DeactivatePipeline",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &DeactivatePipelineInput{}
	}

	req = c.newRequest(opDeactivatePipeline, input, output)
	output = &DeactivatePipelineOutput{}
	req.Data = output
	return
}

// Deactivates the specified running pipeline. The pipeline is set to the DEACTIVATING
// state until the deactivation process completes.
//
// To resume a deactivated pipeline, use ActivatePipeline. By default, the
// pipeline resumes from the last completed execution. Optionally, you can specify
// the date and time to resume the pipeline.
func (c *DataPipeline) DeactivatePipeline(input *DeactivatePipelineInput) (*DeactivatePipelineOutput, error) {
	req, out := c.DeactivatePipelineRequest(input)
	err := req.Send()
	return out, err
}

var opDeactivatePipeline *aws.Operation

// DeletePipelineRequest generates a request for the DeletePipeline operation.
func (c *DataPipeline) DeletePipelineRequest(input *DeletePipelineInput) (req *aws.Request, output *DeletePipelineOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDeletePipeline == nil {
		opDeletePipeline = &aws.Operation{
			Name:       "DeletePipeline",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &DeletePipelineInput{}
	}

	req = c.newRequest(opDeletePipeline, input, output)
	output = &DeletePipelineOutput{}
	req.Data = output
	return
}

// Deletes a pipeline, its pipeline definition, and its run history. AWS Data
// Pipeline attempts to cancel instances associated with the pipeline that are
// currently being processed by task runners.
//
// Deleting a pipeline cannot be undone. You cannot query or restore a deleted
// pipeline. To temporarily pause a pipeline instead of deleting it, call SetStatus
// with the status set to PAUSE on individual components. Components that are
// paused by SetStatus can be resumed.
func (c *DataPipeline) DeletePipeline(input *DeletePipelineInput) (*DeletePipelineOutput, error) {
	req, out := c.DeletePipelineRequest(input)
	err := req.Send()
	return out, err
}

var opDeletePipeline *aws.Operation

// DescribeObjectsRequest generates a request for the DescribeObjects operation.
func (c *DataPipeline) DescribeObjectsRequest(input *DescribeObjectsInput) (req *aws.Request, output *DescribeObjectsOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDescribeObjects == nil {
		opDescribeObjects = &aws.Operation{
			Name:       "DescribeObjects",
			HTTPMethod: "POST",
			HTTPPath:   "/",
			Paginator: &aws.Paginator{
				InputTokens:     []string{"marker"},
				OutputTokens:    []string{"marker"},
				LimitToken:      "",
				TruncationToken: "hasMoreResults",
			},
		}
	}

	if input == nil {
		input = &DescribeObjectsInput{}
	}

	req = c.newRequest(opDescribeObjects, input, output)
	output = &DescribeObjectsOutput{}
	req.Data = output
	return
}

// Gets the object definitions for a set of objects associated with the pipeline.
// Object definitions are composed of a set of fields that define the properties
// of the object.
func (c *DataPipeline) DescribeObjects(input *DescribeObjectsInput) (*DescribeObjectsOutput, error) {
	req, out := c.DescribeObjectsRequest(input)
	err := req.Send()
	return out, err
}

func (c *DataPipeline) DescribeObjectsPages(input *DescribeObjectsInput, fn func(p *DescribeObjectsOutput, lastPage bool) (shouldContinue bool)) error {
	page, _ := c.DescribeObjectsRequest(input)
	return page.EachPage(func(p interface{}, lastPage bool) bool {
		return fn(p.(*DescribeObjectsOutput), lastPage)
	})
}

var opDescribeObjects *aws.Operation

// DescribePipelinesRequest generates a request for the DescribePipelines operation.
func (c *DataPipeline) DescribePipelinesRequest(input *DescribePipelinesInput) (req *aws.Request, output *DescribePipelinesOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDescribePipelines == nil {
		opDescribePipelines = &aws.Operation{
			Name:       "DescribePipelines",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &DescribePipelinesInput{}
	}

	req = c.newRequest(opDescribePipelines, input, output)
	output = &DescribePipelinesOutput{}
	req.Data = output
	return
}

// Retrieves metadata about one or more pipelines. The information retrieved
// includes the name of the pipeline, the pipeline identifier, its current state,
// and the user account that owns the pipeline. Using account credentials, you
// can retrieve metadata about pipelines that you or your IAM users have created.
// If you are using an IAM user account, you can retrieve metadata about only
// those pipelines for which you have read permissions.
//
// To retrieve the full pipeline definition instead of metadata about the pipeline,
// call GetPipelineDefinition.
func (c *DataPipeline) DescribePipelines(input *DescribePipelinesInput) (*DescribePipelinesOutput, error) {
	req, out := c.DescribePipelinesRequest(input)
	err := req.Send()
	return out, err
}

var opDescribePipelines *aws.Operation

// EvaluateExpressionRequest generates a request for the EvaluateExpression operation.
func (c *DataPipeline) EvaluateExpressionRequest(input *EvaluateExpressionInput) (req *aws.Request, output *EvaluateExpressionOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opEvaluateExpression == nil {
		opEvaluateExpression = &aws.Operation{
			Name:       "EvaluateExpression",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &EvaluateExpressionInput{}
	}

	req = c.newRequest(opEvaluateExpression, input, output)
	output = &EvaluateExpressionOutput{}
	req.Data = output
	return
}

// Task runners call EvaluateExpression to evaluate a string in the context
// of the specified object. For example, a task runner can evaluate SQL queries
// stored in Amazon S3.
func (c *DataPipeline) EvaluateExpression(input *EvaluateExpressionInput) (*EvaluateExpressionOutput, error) {
	req, out := c.EvaluateExpressionRequest(input)
	err := req.Send()
	return out, err
}

var opEvaluateExpression *aws.Operation

// GetPipelineDefinitionRequest generates a request for the GetPipelineDefinition operation.
func (c *DataPipeline) GetPipelineDefinitionRequest(input *GetPipelineDefinitionInput) (req *aws.Request, output *GetPipelineDefinitionOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opGetPipelineDefinition == nil {
		opGetPipelineDefinition = &aws.Operation{
			Name:       "GetPipelineDefinition",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &GetPipelineDefinitionInput{}
	}

	req = c.newRequest(opGetPipelineDefinition, input, output)
	output = &GetPipelineDefinitionOutput{}
	req.Data = output
	return
}

// Gets the definition of the specified pipeline. You can call GetPipelineDefinition
// to retrieve the pipeline definition that you provided using PutPipelineDefinition.
func (c *DataPipeline) GetPipelineDefinition(input *GetPipelineDefinitionInput) (*GetPipelineDefinitionOutput, error) {
	req, out := c.GetPipelineDefinitionRequest(input)
	err := req.Send()
	return out, err
}

var opGetPipelineDefinition *aws.Operation

// ListPipelinesRequest generates a request for the ListPipelines operation.
func (c *DataPipeline) ListPipelinesRequest(input *ListPipelinesInput) (req *aws.Request, output *ListPipelinesOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opListPipelines == nil {
		opListPipelines = &aws.Operation{
			Name:       "ListPipelines",
			HTTPMethod: "POST",
			HTTPPath:   "/",
			Paginator: &aws.Paginator{
				InputTokens:     []string{"marker"},
				OutputTokens:    []string{"marker"},
				LimitToken:      "",
				TruncationToken: "hasMoreResults",
			},
		}
	}

	if input == nil {
		input = &ListPipelinesInput{}
	}

	req = c.newRequest(opListPipelines, input, output)
	output = &ListPipelinesOutput{}
	req.Data = output
	return
}

// Lists the pipeline identifiers for all active pipelines that you have permission
// to access.
func (c *DataPipeline) ListPipelines(input *ListPipelinesInput) (*ListPipelinesOutput, error) {
	req, out := c.ListPipelinesRequest(input)
	err := req.Send()
	return out, err
}

func (c *DataPipeline) ListPipelinesPages(input *ListPipelinesInput, fn func(p *ListPipelinesOutput, lastPage bool) (shouldContinue bool)) error {
	page, _ := c.ListPipelinesRequest(input)
	return page.EachPage(func(p interface{}, lastPage bool) bool {
		return fn(p.(*ListPipelinesOutput), lastPage)
	})
}

var opListPipelines *aws.Operation

// PollForTaskRequest generates a request for the PollForTask operation.
func (c *DataPipeline) PollForTaskRequest(input *PollForTaskInput) (req *aws.Request, output *PollForTaskOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opPollForTask == nil {
		opPollForTask = &aws.Operation{
			Name:       "PollForTask",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &PollForTaskInput{}
	}

	req = c.newRequest(opPollForTask, input, output)
	output = &PollForTaskOutput{}
	req.Data = output
	return
}

// Task runners call PollForTask to receive a task to perform from AWS Data
// Pipeline. The task runner specifies which tasks it can perform by setting
// a value for the workerGroup parameter. The task returned can come from any
// of the pipelines that match the workerGroup value passed in by the task runner
// and that was launched using the IAM user credentials specified by the task
// runner.
//
// If tasks are ready in the work queue, PollForTask returns a response immediately.
// If no tasks are available in the queue, PollForTask uses long-polling and
// holds on to a poll connection for up to a 90 seconds, during which time the
// first newly scheduled task is handed to the task runner. To accomodate this,
// set the socket timeout in your task runner to 90 seconds. The task runner
// should not call PollForTask again on the same workerGroup until it receives
// a response, and this can take up to 90 seconds.
func (c *DataPipeline) PollForTask(input *PollForTaskInput) (*PollForTaskOutput, error) {
	req, out := c.PollForTaskRequest(input)
	err := req.Send()
	return out, err
}

var opPollForTask *aws.Operation

// PutPipelineDefinitionRequest generates a request for the PutPipelineDefinition operation.
func (c *DataPipeline) PutPipelineDefinitionRequest(input *PutPipelineDefinitionInput) (req *aws.Request, output *PutPipelineDefinitionOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opPutPipelineDefinition == nil {
		opPutPipelineDefinition = &aws.Operation{
			Name:       "PutPipelineDefinition",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &PutPipelineDefinitionInput{}
	}

	req = c.newRequest(opPutPipelineDefinition, input, output)
	output = &PutPipelineDefinitionOutput{}
	req.Data = output
	return
}

// Adds tasks, schedules, and preconditions to the specified pipeline. You can
// use PutPipelineDefinition to populate a new pipeline.
//
//  PutPipelineDefinition also validates the configuration as it adds it to
// the pipeline. Changes to the pipeline are saved unless one of the following
// three validation errors exists in the pipeline.
//
//  An object is missing a name or identifier field. A string or reference
// field is empty. The number of objects in the pipeline exceeds the maximum
// allowed objects. The pipeline is in a FINISHED state.   Pipeline object definitions
// are passed to the PutPipelineDefinition action and returned by the GetPipelineDefinition
// action.
func (c *DataPipeline) PutPipelineDefinition(input *PutPipelineDefinitionInput) (*PutPipelineDefinitionOutput, error) {
	req, out := c.PutPipelineDefinitionRequest(input)
	err := req.Send()
	return out, err
}

var opPutPipelineDefinition *aws.Operation

// QueryObjectsRequest generates a request for the QueryObjects operation.
func (c *DataPipeline) QueryObjectsRequest(input *QueryObjectsInput) (req *aws.Request, output *QueryObjectsOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opQueryObjects == nil {
		opQueryObjects = &aws.Operation{
			Name:       "QueryObjects",
			HTTPMethod: "POST",
			HTTPPath:   "/",
			Paginator: &aws.Paginator{
				InputTokens:     []string{"marker"},
				OutputTokens:    []string{"marker"},
				LimitToken:      "limit",
				TruncationToken: "hasMoreResults",
			},
		}
	}

	if input == nil {
		input = &QueryObjectsInput{}
	}

	req = c.newRequest(opQueryObjects, input, output)
	output = &QueryObjectsOutput{}
	req.Data = output
	return
}

// Queries the specified pipeline for the names of objects that match the specified
// set of conditions.
func (c *DataPipeline) QueryObjects(input *QueryObjectsInput) (*QueryObjectsOutput, error) {
	req, out := c.QueryObjectsRequest(input)
	err := req.Send()
	return out, err
}

func (c *DataPipeline) QueryObjectsPages(input *QueryObjectsInput, fn func(p *QueryObjectsOutput, lastPage bool) (shouldContinue bool)) error {
	page, _ := c.QueryObjectsRequest(input)
	return page.EachPage(func(p interface{}, lastPage bool) bool {
		return fn(p.(*QueryObjectsOutput), lastPage)
	})
}

var opQueryObjects *aws.Operation

// RemoveTagsRequest generates a request for the RemoveTags operation.
func (c *DataPipeline) RemoveTagsRequest(input *RemoveTagsInput) (req *aws.Request, output *RemoveTagsOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opRemoveTags == nil {
		opRemoveTags = &aws.Operation{
			Name:       "RemoveTags",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &RemoveTagsInput{}
	}

	req = c.newRequest(opRemoveTags, input, output)
	output = &RemoveTagsOutput{}
	req.Data = output
	return
}

// Removes existing tags from the specified pipeline.
func (c *DataPipeline) RemoveTags(input *RemoveTagsInput) (*RemoveTagsOutput, error) {
	req, out := c.RemoveTagsRequest(input)
	err := req.Send()
	return out, err
}

var opRemoveTags *aws.Operation

// ReportTaskProgressRequest generates a request for the ReportTaskProgress operation.
func (c *DataPipeline) ReportTaskProgressRequest(input *ReportTaskProgressInput) (req *aws.Request, output *ReportTaskProgressOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opReportTaskProgress == nil {
		opReportTaskProgress = &aws.Operation{
			Name:       "ReportTaskProgress",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &ReportTaskProgressInput{}
	}

	req = c.newRequest(opReportTaskProgress, input, output)
	output = &ReportTaskProgressOutput{}
	req.Data = output
	return
}

// Task runners call ReportTaskProgress when assigned a task to acknowledge
// that it has the task. If the web service does not receive this acknowledgement
// within 2 minutes, it assigns the task in a subsequent PollForTask call. After
// this initial acknowledgement, the task runner only needs to report progress
// every 15 minutes to maintain its ownership of the task. You can change this
// reporting time from 15 minutes by specifying a reportProgressTimeout field
// in your pipeline.
//
// If a task runner does not report its status after 5 minutes, AWS Data Pipeline
// assumes that the task runner is unable to process the task and reassigns
// the task in a subsequent response to PollForTask. Task runners should call
// ReportTaskProgress every 60 seconds.
func (c *DataPipeline) ReportTaskProgress(input *ReportTaskProgressInput) (*ReportTaskProgressOutput, error) {
	req, out := c.ReportTaskProgressRequest(input)
	err := req.Send()
	return out, err
}

var opReportTaskProgress *aws.Operation

// ReportTaskRunnerHeartbeatRequest generates a request for the ReportTaskRunnerHeartbeat operation.
func (c *DataPipeline) ReportTaskRunnerHeartbeatRequest(input *ReportTaskRunnerHeartbeatInput) (req *aws.Request, output *ReportTaskRunnerHeartbeatOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opReportTaskRunnerHeartbeat == nil {
		opReportTaskRunnerHeartbeat = &aws.Operation{
			Name:       "ReportTaskRunnerHeartbeat",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &ReportTaskRunnerHeartbeatInput{}
	}

	req = c.newRequest(opReportTaskRunnerHeartbeat, input, output)
	output = &ReportTaskRunnerHeartbeatOutput{}
	req.Data = output
	return
}

// Task runners call ReportTaskRunnerHeartbeat every 15 minutes to indicate
// that they are operational. If the AWS Data Pipeline Task Runner is launched
// on a resource managed by AWS Data Pipeline, the web service can use this
// call to detect when the task runner application has failed and restart a
// new instance.
func (c *DataPipeline) ReportTaskRunnerHeartbeat(input *ReportTaskRunnerHeartbeatInput) (*ReportTaskRunnerHeartbeatOutput, error) {
	req, out := c.ReportTaskRunnerHeartbeatRequest(input)
	err := req.Send()
	return out, err
}

var opReportTaskRunnerHeartbeat *aws.Operation

// SetStatusRequest generates a request for the SetStatus operation.
func (c *DataPipeline) SetStatusRequest(input *SetStatusInput) (req *aws.Request, output *SetStatusOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opSetStatus == nil {
		opSetStatus = &aws.Operation{
			Name:       "SetStatus",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &SetStatusInput{}
	}

	req = c.newRequest(opSetStatus, input, output)
	output = &SetStatusOutput{}
	req.Data = output
	return
}

// Requests that the status of the specified physical or logical pipeline objects
// be updated in the specified pipeline. This update might not occur immediately,
// but is eventually consistent. The status that can be set depends on the type
// of object (for example, DataNode or Activity). You cannot perform this operation
// on FINISHED pipelines and attempting to do so returns InvalidRequestException.
func (c *DataPipeline) SetStatus(input *SetStatusInput) (*SetStatusOutput, error) {
	req, out := c.SetStatusRequest(input)
	err := req.Send()
	return out, err
}

var opSetStatus *aws.Operation

// SetTaskStatusRequest generates a request for the SetTaskStatus operation.
func (c *DataPipeline) SetTaskStatusRequest(input *SetTaskStatusInput) (req *aws.Request, output *SetTaskStatusOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opSetTaskStatus == nil {
		opSetTaskStatus = &aws.Operation{
			Name:       "SetTaskStatus",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &SetTaskStatusInput{}
	}

	req = c.newRequest(opSetTaskStatus, input, output)
	output = &SetTaskStatusOutput{}
	req.Data = output
	return
}

// Task runners call SetTaskStatus to notify AWS Data Pipeline that a task is
// completed and provide information about the final status. A task runner makes
// this call regardless of whether the task was sucessful. A task runner does
// not need to call SetTaskStatus for tasks that are canceled by the web service
// during a call to ReportTaskProgress.
func (c *DataPipeline) SetTaskStatus(input *SetTaskStatusInput) (*SetTaskStatusOutput, error) {
	req, out := c.SetTaskStatusRequest(input)
	err := req.Send()
	return out, err
}

var opSetTaskStatus *aws.Operation

// ValidatePipelineDefinitionRequest generates a request for the ValidatePipelineDefinition operation.
func (c *DataPipeline) ValidatePipelineDefinitionRequest(input *ValidatePipelineDefinitionInput) (req *aws.Request, output *ValidatePipelineDefinitionOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opValidatePipelineDefinition == nil {
		opValidatePipelineDefinition = &aws.Operation{
			Name:       "ValidatePipelineDefinition",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &ValidatePipelineDefinitionInput{}
	}

	req = c.newRequest(opValidatePipelineDefinition, input, output)
	output = &ValidatePipelineDefinitionOutput{}
	req.Data = output
	return
}

// Validates the specified pipeline definition to ensure that it is well formed
// and can be run without error.
func (c *DataPipeline) ValidatePipelineDefinition(input *ValidatePipelineDefinitionInput) (*ValidatePipelineDefinitionOutput, error) {
	req, out := c.ValidatePipelineDefinitionRequest(input)
	err := req.Send()
	return out, err
}

var opValidatePipelineDefinition *aws.Operation

// Contains the parameters for ActivatePipeline.
type ActivatePipelineInput struct {
	// A list of parameter values to pass to the pipeline at activation.
	ParameterValues []*ParameterValue `locationName:"parameterValues" type:"list"`

	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	// The date and time to resume the pipeline. By default, the pipeline resumes
	// from the last completed execution.
	StartTimestamp *time.Time `locationName:"startTimestamp" type:"timestamp" timestampFormat:"unix"`

	metadataActivatePipelineInput `json:"-" xml:"-"`
}

type metadataActivatePipelineInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of ActivatePipeline.
type ActivatePipelineOutput struct {
	metadataActivatePipelineOutput `json:"-" xml:"-"`
}

type metadataActivatePipelineOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for AddTags.
type AddTagsInput struct {
	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	// The tags to add, as key/value pairs.
	Tags []*Tag `locationName:"tags" type:"list" required:"true"`

	metadataAddTagsInput `json:"-" xml:"-"`
}

type metadataAddTagsInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of AddTags.
type AddTagsOutput struct {
	metadataAddTagsOutput `json:"-" xml:"-"`
}

type metadataAddTagsOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for CreatePipeline.
type CreatePipelineInput struct {
	// The description for the pipeline.
	Description *string `locationName:"description" type:"string"`

	// The name for the pipeline. You can use the same name for multiple pipelines
	// associated with your AWS account, because AWS Data Pipeline assigns each
	// pipeline a unique pipeline identifier.
	Name *string `locationName:"name" type:"string" required:"true"`

	// A list of tags to associate with the pipeline at creation. Tags let you control
	// access to pipelines. For more information, see Controlling User Access to
	// Pipelines (http://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-control-access.html)
	// in the AWS Data Pipeline Developer Guide.
	Tags []*Tag `locationName:"tags" type:"list"`

	// A unique identifier. This identifier is not the same as the pipeline identifier
	// assigned by AWS Data Pipeline. You are responsible for defining the format
	// and ensuring the uniqueness of this identifier. You use this parameter to
	// ensure idempotency during repeated calls to CreatePipeline. For example,
	// if the first call to CreatePipeline does not succeed, you can pass in the
	// same unique identifier and pipeline name combination on a subsequent call
	// to CreatePipeline. CreatePipeline ensures that if a pipeline already exists
	// with the same name and unique identifier, a new pipeline is not created.
	// Instead, you'll receive the pipeline identifier from the previous attempt.
	// The uniqueness of the name and unique identifier combination is scoped to
	// the AWS account or IAM user credentials.
	UniqueID *string `locationName:"uniqueId" type:"string" required:"true"`

	metadataCreatePipelineInput `json:"-" xml:"-"`
}

type metadataCreatePipelineInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of CreatePipeline.
type CreatePipelineOutput struct {
	// The ID that AWS Data Pipeline assigns the newly created pipeline. For example,
	// df-06372391ZG65EXAMPLE.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	metadataCreatePipelineOutput `json:"-" xml:"-"`
}

type metadataCreatePipelineOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for DeactivatePipeline.
type DeactivatePipelineInput struct {
	// Indicates whether to cancel any running objects. The default is true, which
	// sets the state of any running objects to CANCELED. If this value is false,
	// the pipeline is deactivated after all running objects finish.
	CancelActive *bool `locationName:"cancelActive" type:"boolean"`

	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	metadataDeactivatePipelineInput `json:"-" xml:"-"`
}

type metadataDeactivatePipelineInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of DeactivatePipeline.
type DeactivatePipelineOutput struct {
	metadataDeactivatePipelineOutput `json:"-" xml:"-"`
}

type metadataDeactivatePipelineOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for DeletePipeline.
type DeletePipelineInput struct {
	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	metadataDeletePipelineInput `json:"-" xml:"-"`
}

type metadataDeletePipelineInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type DeletePipelineOutput struct {
	metadataDeletePipelineOutput `json:"-" xml:"-"`
}

type metadataDeletePipelineOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for DescribeObjects.
type DescribeObjectsInput struct {
	// Indicates whether any expressions in the object should be evaluated when
	// the object descriptions are returned.
	EvaluateExpressions *bool `locationName:"evaluateExpressions" type:"boolean"`

	// The starting point for the results to be returned. For the first call, this
	// value should be empty. As long as there are more results, continue to call
	// DescribeObjects with the marker value from the previous call to retrieve
	// the next set of results.
	Marker *string `locationName:"marker" type:"string"`

	// The IDs of the pipeline objects that contain the definitions to be described.
	// You can pass as many as 25 identifiers in a single call to DescribeObjects.
	ObjectIDs []*string `locationName:"objectIds" type:"list" required:"true"`

	// The ID of the pipeline that contains the object definitions.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	metadataDescribeObjectsInput `json:"-" xml:"-"`
}

type metadataDescribeObjectsInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of DescribeObjects.
type DescribeObjectsOutput struct {
	// Indicates whether there are more results to return.
	HasMoreResults *bool `locationName:"hasMoreResults" type:"boolean"`

	// The starting point for the next page of results. To view the next page of
	// results, call DescribeObjects again with this marker value. If the value
	// is null, there are no more results.
	Marker *string `locationName:"marker" type:"string"`

	// An array of object definitions.
	PipelineObjects []*PipelineObject `locationName:"pipelineObjects" type:"list" required:"true"`

	metadataDescribeObjectsOutput `json:"-" xml:"-"`
}

type metadataDescribeObjectsOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for DescribePipelines.
type DescribePipelinesInput struct {
	// The IDs of the pipelines to describe. You can pass as many as 25 identifiers
	// in a single call. To obtain pipeline IDs, call ListPipelines.
	PipelineIDs []*string `locationName:"pipelineIds" type:"list" required:"true"`

	metadataDescribePipelinesInput `json:"-" xml:"-"`
}

type metadataDescribePipelinesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of DescribePipelines.
type DescribePipelinesOutput struct {
	// An array of descriptions for the specified pipelines.
	PipelineDescriptionList []*PipelineDescription `locationName:"pipelineDescriptionList" type:"list" required:"true"`

	metadataDescribePipelinesOutput `json:"-" xml:"-"`
}

type metadataDescribePipelinesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for EvaluateExpression.
type EvaluateExpressionInput struct {
	// The expression to evaluate.
	Expression *string `locationName:"expression" type:"string" required:"true"`

	// The ID of the object.
	ObjectID *string `locationName:"objectId" type:"string" required:"true"`

	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	metadataEvaluateExpressionInput `json:"-" xml:"-"`
}

type metadataEvaluateExpressionInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of EvaluateExpression.
type EvaluateExpressionOutput struct {
	// The evaluated expression.
	EvaluatedExpression *string `locationName:"evaluatedExpression" type:"string" required:"true"`

	metadataEvaluateExpressionOutput `json:"-" xml:"-"`
}

type metadataEvaluateExpressionOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// A key-value pair that describes a property of a pipeline object. The value
// is specified as either a string value (StringValue) or a reference to another
// object (RefValue) but not as both.
type Field struct {
	// The field identifier.
	Key *string `locationName:"key" type:"string" required:"true"`

	// The field value, expressed as the identifier of another object.
	RefValue *string `locationName:"refValue" type:"string"`

	// The field value, expressed as a String.
	StringValue *string `locationName:"stringValue" type:"string"`

	metadataField `json:"-" xml:"-"`
}

type metadataField struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for GetPipelineDefinition.
type GetPipelineDefinitionInput struct {
	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	// The version of the pipeline definition to retrieve. Set this parameter to
	// latest (default) to use the last definition saved to the pipeline or active
	// to use the last definition that was activated.
	Version *string `locationName:"version" type:"string"`

	metadataGetPipelineDefinitionInput `json:"-" xml:"-"`
}

type metadataGetPipelineDefinitionInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of GetPipelineDefinition.
type GetPipelineDefinitionOutput struct {
	// The parameter objects used in the pipeline definition.
	ParameterObjects []*ParameterObject `locationName:"parameterObjects" type:"list"`

	// The parameter values used in the pipeline definition.
	ParameterValues []*ParameterValue `locationName:"parameterValues" type:"list"`

	// The objects defined in the pipeline.
	PipelineObjects []*PipelineObject `locationName:"pipelineObjects" type:"list"`

	metadataGetPipelineDefinitionOutput `json:"-" xml:"-"`
}

type metadataGetPipelineDefinitionOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Identity information for the EC2 instance that is hosting the task runner.
// You can get this value by calling a metadata URI from the EC2 instance. For
// more information, see Instance Metadata (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html)
// in the Amazon Elastic Compute Cloud User Guide. Passing in this value proves
// that your task runner is running on an EC2 instance, and ensures the proper
// AWS Data Pipeline service charges are applied to your pipeline.
type InstanceIdentity struct {
	// A description of an EC2 instance that is generated when the instance is launched
	// and exposed to the instance via the instance metadata service in the form
	// of a JSON representation of an object.
	Document *string `locationName:"document" type:"string"`

	// A signature which can be used to verify the accuracy and authenticity of
	// the information provided in the instance identity document.
	Signature *string `locationName:"signature" type:"string"`

	metadataInstanceIdentity `json:"-" xml:"-"`
}

type metadataInstanceIdentity struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for ListPipelines.
type ListPipelinesInput struct {
	// The starting point for the results to be returned. For the first call, this
	// value should be empty. As long as there are more results, continue to call
	// ListPipelines with the marker value from the previous call to retrieve the
	// next set of results.
	Marker *string `locationName:"marker" type:"string"`

	metadataListPipelinesInput `json:"-" xml:"-"`
}

type metadataListPipelinesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of ListPipelines.
type ListPipelinesOutput struct {
	// Indicates whether there are more results that can be obtained by a subsequent
	// call.
	HasMoreResults *bool `locationName:"hasMoreResults" type:"boolean"`

	// The starting point for the next page of results. To view the next page of
	// results, call ListPipelinesOutput again with this marker value. If the value
	// is null, there are no more results.
	Marker *string `locationName:"marker" type:"string"`

	// The pipeline identifiers. If you require additional information about the
	// pipelines, you can use these identifiers to call DescribePipelines and GetPipelineDefinition.
	PipelineIDList []*PipelineIDName `locationName:"pipelineIdList" type:"list" required:"true"`

	metadataListPipelinesOutput `json:"-" xml:"-"`
}

type metadataListPipelinesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains a logical operation for comparing the value of a field with a specified
// value.
type Operator struct {
	// The logical operation to be performed: equal (EQ), equal reference (REF_EQ),
	// less than or equal (LE), greater than or equal (GE), or between (BETWEEN).
	// Equal reference (REF_EQ) can be used only with reference fields. The other
	// comparison types can be used only with String fields. The comparison types
	// you can use apply only to certain object fields, as detailed below.
	//
	//  The comparison operators EQ and REF_EQ act on the following fields:
	//
	//  name @sphere parent @componentParent @instanceParent @status @scheduledStartTime
	// @scheduledEndTime @actualStartTime @actualEndTime   The comparison operators
	// GE, LE, and BETWEEN act on the following fields:
	//
	//  @scheduledStartTime @scheduledEndTime @actualStartTime @actualEndTime
	// Note that fields beginning with the at sign (@) are read-only and set by
	// the web service. When you name fields, you should choose names containing
	// only alpha-numeric values, as symbols may be reserved by AWS Data Pipeline.
	// User-defined fields that you add to a pipeline should prefix their name with
	// the string "my".
	Type *string `locationName:"type" type:"string"`

	// The value that the actual field value will be compared with.
	Values []*string `locationName:"values" type:"list"`

	metadataOperator `json:"-" xml:"-"`
}

type metadataOperator struct {
	SDKShapeTraits bool `type:"structure"`
}

// The attributes allowed or specified with a parameter object.
type ParameterAttribute struct {
	// The field identifier.
	Key *string `locationName:"key" type:"string" required:"true"`

	// The field value, expressed as a String.
	StringValue *string `locationName:"stringValue" type:"string" required:"true"`

	metadataParameterAttribute `json:"-" xml:"-"`
}

type metadataParameterAttribute struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information about a parameter object.
type ParameterObject struct {
	// The attributes of the parameter object.
	Attributes []*ParameterAttribute `locationName:"attributes" type:"list" required:"true"`

	// The ID of the parameter object.
	ID *string `locationName:"id" type:"string" required:"true"`

	metadataParameterObject `json:"-" xml:"-"`
}

type metadataParameterObject struct {
	SDKShapeTraits bool `type:"structure"`
}

// A value or list of parameter values.
type ParameterValue struct {
	// The ID of the parameter value.
	ID *string `locationName:"id" type:"string" required:"true"`

	// The field value, expressed as a String.
	StringValue *string `locationName:"stringValue" type:"string" required:"true"`

	metadataParameterValue `json:"-" xml:"-"`
}

type metadataParameterValue struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains pipeline metadata.
type PipelineDescription struct {
	// Description of the pipeline.
	Description *string `locationName:"description" type:"string"`

	// A list of read-only fields that contain metadata about the pipeline: @userId,
	// @accountId, and @pipelineState.
	Fields []*Field `locationName:"fields" type:"list" required:"true"`

	// The name of the pipeline.
	Name *string `locationName:"name" type:"string" required:"true"`

	// The pipeline identifier that was assigned by AWS Data Pipeline. This is a
	// string of the form df-297EG78HU43EEXAMPLE.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	// A list of tags to associated with a pipeline. Tags let you control access
	// to pipelines. For more information, see Controlling User Access to Pipelines
	// (http://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-control-access.html)
	// in the AWS Data Pipeline Developer Guide.
	Tags []*Tag `locationName:"tags" type:"list"`

	metadataPipelineDescription `json:"-" xml:"-"`
}

type metadataPipelineDescription struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the name and identifier of a pipeline.
type PipelineIDName struct {
	// The ID of the pipeline that was assigned by AWS Data Pipeline. This is a
	// string of the form df-297EG78HU43EEXAMPLE.
	ID *string `locationName:"id" type:"string"`

	// The name of the pipeline.
	Name *string `locationName:"name" type:"string"`

	metadataPipelineIDName `json:"-" xml:"-"`
}

type metadataPipelineIDName struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information about a pipeline object. This can be a logical, physical,
// or physical attempt pipeline object. The complete set of components of a
// pipeline defines the pipeline.
type PipelineObject struct {
	// Key-value pairs that define the properties of the object.
	Fields []*Field `locationName:"fields" type:"list" required:"true"`

	// The ID of the object.
	ID *string `locationName:"id" type:"string" required:"true"`

	// The name of the object.
	Name *string `locationName:"name" type:"string" required:"true"`

	metadataPipelineObject `json:"-" xml:"-"`
}

type metadataPipelineObject struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for PollForTask.
type PollForTaskInput struct {
	// The public DNS name of the calling task runner.
	Hostname *string `locationName:"hostname" type:"string"`

	// Identity information for the EC2 instance that is hosting the task runner.
	// You can get this value from the instance using http://169.254.169.254/latest/meta-data/instance-id.
	// For more information, see Instance Metadata (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html)
	// in the Amazon Elastic Compute Cloud User Guide. Passing in this value proves
	// that your task runner is running on an EC2 instance, and ensures the proper
	// AWS Data Pipeline service charges are applied to your pipeline.
	InstanceIdentity *InstanceIdentity `locationName:"instanceIdentity" type:"structure"`

	// The type of task the task runner is configured to accept and process. The
	// worker group is set as a field on objects in the pipeline when they are created.
	// You can only specify a single value for workerGroup in the call to PollForTask.
	// There are no wildcard values permitted in workerGroup; the string must be
	// an exact, case-sensitive, match.
	WorkerGroup *string `locationName:"workerGroup" type:"string" required:"true"`

	metadataPollForTaskInput `json:"-" xml:"-"`
}

type metadataPollForTaskInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of PollForTask.
type PollForTaskOutput struct {
	// The information needed to complete the task that is being assigned to the
	// task runner. One of the fields returned in this object is taskId, which contains
	// an identifier for the task being assigned. The calling task runner uses taskId
	// in subsequent calls to ReportTaskProgress and SetTaskStatus.
	TaskObject *TaskObject `locationName:"taskObject" type:"structure"`

	metadataPollForTaskOutput `json:"-" xml:"-"`
}

type metadataPollForTaskOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for PutPipelineDefinition.
type PutPipelineDefinitionInput struct {
	// The parameter objects used with the pipeline.
	ParameterObjects []*ParameterObject `locationName:"parameterObjects" type:"list"`

	// The parameter values used with the pipeline.
	ParameterValues []*ParameterValue `locationName:"parameterValues" type:"list"`

	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	// The objects that define the pipeline. These objects overwrite the existing
	// pipeline definition.
	PipelineObjects []*PipelineObject `locationName:"pipelineObjects" type:"list" required:"true"`

	metadataPutPipelineDefinitionInput `json:"-" xml:"-"`
}

type metadataPutPipelineDefinitionInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of PutPipelineDefinition.
type PutPipelineDefinitionOutput struct {
	// Indicates whether there were validation errors, and the pipeline definition
	// is stored but cannot be activated until you correct the pipeline and call
	// PutPipelineDefinition to commit the corrected pipeline.
	Errored *bool `locationName:"errored" type:"boolean" required:"true"`

	// The validation errors that are associated with the objects defined in pipelineObjects.
	ValidationErrors []*ValidationError `locationName:"validationErrors" type:"list"`

	// The validation warnings that are associated with the objects defined in pipelineObjects.
	ValidationWarnings []*ValidationWarning `locationName:"validationWarnings" type:"list"`

	metadataPutPipelineDefinitionOutput `json:"-" xml:"-"`
}

type metadataPutPipelineDefinitionOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Defines the query to run against an object.
type Query struct {
	// List of selectors that define the query. An object must satisfy all of the
	// selectors to match the query.
	Selectors []*Selector `locationName:"selectors" type:"list"`

	metadataQuery `json:"-" xml:"-"`
}

type metadataQuery struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for QueryObjects.
type QueryObjectsInput struct {
	// The maximum number of object names that QueryObjects will return in a single
	// call. The default value is 100.
	Limit *int64 `locationName:"limit" type:"integer"`

	// The starting point for the results to be returned. For the first call, this
	// value should be empty. As long as there are more results, continue to call
	// QueryObjects with the marker value from the previous call to retrieve the
	// next set of results.
	Marker *string `locationName:"marker" type:"string"`

	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	// The query that defines the objects to be returned. The Query object can contain
	// a maximum of ten selectors. The conditions in the query are limited to top-level
	// String fields in the object. These filters can be applied to components,
	// instances, and attempts.
	Query *Query `locationName:"query" type:"structure"`

	// Indicates whether the query applies to components or instances. The possible
	// values are: COMPONENT, INSTANCE, and ATTEMPT.
	Sphere *string `locationName:"sphere" type:"string" required:"true"`

	metadataQueryObjectsInput `json:"-" xml:"-"`
}

type metadataQueryObjectsInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of QueryObjects.
type QueryObjectsOutput struct {
	// Indicates whether there are more results that can be obtained by a subsequent
	// call.
	HasMoreResults *bool `locationName:"hasMoreResults" type:"boolean"`

	// The identifiers that match the query selectors.
	IDs []*string `locationName:"ids" type:"list"`

	// The starting point for the next page of results. To view the next page of
	// results, call QueryObjects again with this marker value. If the value is
	// null, there are no more results.
	Marker *string `locationName:"marker" type:"string"`

	metadataQueryObjectsOutput `json:"-" xml:"-"`
}

type metadataQueryObjectsOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for RemoveTags.
type RemoveTagsInput struct {
	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	// The keys of the tags to remove.
	TagKeys []*string `locationName:"tagKeys" type:"list" required:"true"`

	metadataRemoveTagsInput `json:"-" xml:"-"`
}

type metadataRemoveTagsInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of RemoveTags.
type RemoveTagsOutput struct {
	metadataRemoveTagsOutput `json:"-" xml:"-"`
}

type metadataRemoveTagsOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for ReportTaskProgress.
type ReportTaskProgressInput struct {
	// Key-value pairs that define the properties of the ReportTaskProgressInput
	// object.
	Fields []*Field `locationName:"fields" type:"list"`

	// The ID of the task assigned to the task runner. This value is provided in
	// the response for PollForTask.
	TaskID *string `locationName:"taskId" type:"string" required:"true"`

	metadataReportTaskProgressInput `json:"-" xml:"-"`
}

type metadataReportTaskProgressInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of ReportTaskProgress.
type ReportTaskProgressOutput struct {
	// If true, the calling task runner should cancel processing of the task. The
	// task runner does not need to call SetTaskStatus for canceled tasks.
	Canceled *bool `locationName:"canceled" type:"boolean" required:"true"`

	metadataReportTaskProgressOutput `json:"-" xml:"-"`
}

type metadataReportTaskProgressOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for ReportTaskRunnerHeartbeat.
type ReportTaskRunnerHeartbeatInput struct {
	// The public DNS name of the task runner.
	Hostname *string `locationName:"hostname" type:"string"`

	// The ID of the task runner. This value should be unique across your AWS account.
	// In the case of AWS Data Pipeline Task Runner launched on a resource managed
	// by AWS Data Pipeline, the web service provides a unique identifier when it
	// launches the application. If you have written a custom task runner, you should
	// assign a unique identifier for the task runner.
	TaskRunnerID *string `locationName:"taskrunnerId" type:"string" required:"true"`

	// The type of task the task runner is configured to accept and process. The
	// worker group is set as a field on objects in the pipeline when they are created.
	// You can only specify a single value for workerGroup. There are no wildcard
	// values permitted in workerGroup; the string must be an exact, case-sensitive,
	// match.
	WorkerGroup *string `locationName:"workerGroup" type:"string"`

	metadataReportTaskRunnerHeartbeatInput `json:"-" xml:"-"`
}

type metadataReportTaskRunnerHeartbeatInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of ReportTaskRunnerHeartbeat.
type ReportTaskRunnerHeartbeatOutput struct {
	// Indicates whether the calling task runner should terminate.
	Terminate *bool `locationName:"terminate" type:"boolean" required:"true"`

	metadataReportTaskRunnerHeartbeatOutput `json:"-" xml:"-"`
}

type metadataReportTaskRunnerHeartbeatOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// A comparision that is used to determine whether a query should return this
// object.
type Selector struct {
	// The name of the field that the operator will be applied to. The field name
	// is the "key" portion of the field definition in the pipeline definition syntax
	// that is used by the AWS Data Pipeline API. If the field is not set on the
	// object, the condition fails.
	FieldName *string `locationName:"fieldName" type:"string"`

	// Contains a logical operation for comparing the value of a field with a specified
	// value.
	Operator *Operator `locationName:"operator" type:"structure"`

	metadataSelector `json:"-" xml:"-"`
}

type metadataSelector struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for SetStatus.
type SetStatusInput struct {
	// The IDs of the objects. The corresponding objects can be either physical
	// or components, but not a mix of both types.
	ObjectIDs []*string `locationName:"objectIds" type:"list" required:"true"`

	// The ID of the pipeline that contains the objects.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	// The status to be set on all the objects specified in objectIds. For components,
	// use PAUSE or RESUME. For instances, use TRY_CANCEL, RERUN, or MARK_FINISHED.
	Status *string `locationName:"status" type:"string" required:"true"`

	metadataSetStatusInput `json:"-" xml:"-"`
}

type metadataSetStatusInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type SetStatusOutput struct {
	metadataSetStatusOutput `json:"-" xml:"-"`
}

type metadataSetStatusOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for SetTaskStatus.
type SetTaskStatusInput struct {
	// If an error occurred during the task, this value specifies the error code.
	// This value is set on the physical attempt object. It is used to display error
	// information to the user. It should not start with string "Service_" which
	// is reserved by the system.
	ErrorID *string `locationName:"errorId" type:"string"`

	// If an error occurred during the task, this value specifies a text description
	// of the error. This value is set on the physical attempt object. It is used
	// to display error information to the user. The web service does not parse
	// this value.
	ErrorMessage *string `locationName:"errorMessage" type:"string"`

	// If an error occurred during the task, this value specifies the stack trace
	// associated with the error. This value is set on the physical attempt object.
	// It is used to display error information to the user. The web service does
	// not parse this value.
	ErrorStackTrace *string `locationName:"errorStackTrace" type:"string"`

	// The ID of the task assigned to the task runner. This value is provided in
	// the response for PollForTask.
	TaskID *string `locationName:"taskId" type:"string" required:"true"`

	// If FINISHED, the task successfully completed. If FAILED, the task ended unsuccessfully.
	// Preconditions use false.
	TaskStatus *string `locationName:"taskStatus" type:"string" required:"true"`

	metadataSetTaskStatusInput `json:"-" xml:"-"`
}

type metadataSetTaskStatusInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of SetTaskStatus.
type SetTaskStatusOutput struct {
	metadataSetTaskStatusOutput `json:"-" xml:"-"`
}

type metadataSetTaskStatusOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Tags are key/value pairs defined by a user and associated with a pipeline
// to control access. AWS Data Pipeline allows you to associate ten tags per
// pipeline. For more information, see Controlling User Access to Pipelines
// (http://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-control-access.html)
// in the AWS Data Pipeline Developer Guide.
type Tag struct {
	// The key name of a tag defined by a user. For more information, see Controlling
	// User Access to Pipelines (http://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-control-access.html)
	// in the AWS Data Pipeline Developer Guide.
	Key *string `locationName:"key" type:"string" required:"true"`

	// The optional value portion of a tag defined by a user. For more information,
	// see Controlling User Access to Pipelines (http://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-control-access.html)
	// in the AWS Data Pipeline Developer Guide.
	Value *string `locationName:"value" type:"string" required:"true"`

	metadataTag `json:"-" xml:"-"`
}

type metadataTag struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information about a pipeline task that is assigned to a task runner.
type TaskObject struct {
	// The ID of the pipeline task attempt object. AWS Data Pipeline uses this value
	// to track how many times a task is attempted.
	AttemptID *string `locationName:"attemptId" type:"string"`

	// Connection information for the location where the task runner will publish
	// the output of the task.
	Objects map[string]*PipelineObject `locationName:"objects" type:"map"`

	// The ID of the pipeline that provided the task.
	PipelineID *string `locationName:"pipelineId" type:"string"`

	// An internal identifier for the task. This ID is passed to the SetTaskStatus
	// and ReportTaskProgress actions.
	TaskID *string `locationName:"taskId" type:"string"`

	metadataTaskObject `json:"-" xml:"-"`
}

type metadataTaskObject struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the parameters for ValidatePipelineDefinition.
type ValidatePipelineDefinitionInput struct {
	// The parameter objects used with the pipeline.
	ParameterObjects []*ParameterObject `locationName:"parameterObjects" type:"list"`

	// The parameter values used with the pipeline.
	ParameterValues []*ParameterValue `locationName:"parameterValues" type:"list"`

	// The ID of the pipeline.
	PipelineID *string `locationName:"pipelineId" type:"string" required:"true"`

	// The objects that define the pipeline changes to validate against the pipeline.
	PipelineObjects []*PipelineObject `locationName:"pipelineObjects" type:"list" required:"true"`

	metadataValidatePipelineDefinitionInput `json:"-" xml:"-"`
}

type metadataValidatePipelineDefinitionInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the output of ValidatePipelineDefinition.
type ValidatePipelineDefinitionOutput struct {
	// Indicates whether there were validation errors.
	Errored *bool `locationName:"errored" type:"boolean" required:"true"`

	// Any validation errors that were found.
	ValidationErrors []*ValidationError `locationName:"validationErrors" type:"list"`

	// Any validation warnings that were found.
	ValidationWarnings []*ValidationWarning `locationName:"validationWarnings" type:"list"`

	metadataValidatePipelineDefinitionOutput `json:"-" xml:"-"`
}

type metadataValidatePipelineDefinitionOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Defines a validation error. Validation errors prevent pipeline activation.
// The set of validation errors that can be returned are defined by AWS Data
// Pipeline.
type ValidationError struct {
	// A description of the validation error.
	Errors []*string `locationName:"errors" type:"list"`

	// The identifier of the object that contains the validation error.
	ID *string `locationName:"id" type:"string"`

	metadataValidationError `json:"-" xml:"-"`
}

type metadataValidationError struct {
	SDKShapeTraits bool `type:"structure"`
}

// Defines a validation warning. Validation warnings do not prevent pipeline
// activation. The set of validation warnings that can be returned are defined
// by AWS Data Pipeline.
type ValidationWarning struct {
	// The identifier of the object that contains the validation warning.
	ID *string `locationName:"id" type:"string"`

	// A description of the validation warning.
	Warnings []*string `locationName:"warnings" type:"list"`

	metadataValidationWarning `json:"-" xml:"-"`
}

type metadataValidationWarning struct {
	SDKShapeTraits bool `type:"structure"`
}