codepipeline

package
v7.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 21, 2025 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CustomActionType

type CustomActionType struct {
	pulumi.CustomResourceState

	// The action ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The category of the custom action. Valid values: `Source`, `Build`, `Deploy`, `Test`, `Invoke`, `Approval`
	Category pulumi.StringOutput `pulumi:"category"`
	// The configuration properties for the custom action. Max 10 items.
	ConfigurationProperties CustomActionTypeConfigurationPropertyArrayOutput `pulumi:"configurationProperties"`
	InputArtifactDetails    CustomActionTypeInputArtifactDetailsOutput       `pulumi:"inputArtifactDetails"`
	OutputArtifactDetails   CustomActionTypeOutputArtifactDetailsOutput      `pulumi:"outputArtifactDetails"`
	// The creator of the action being called.
	Owner        pulumi.StringOutput `pulumi:"owner"`
	ProviderName pulumi.StringOutput `pulumi:"providerName"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region   pulumi.StringOutput               `pulumi:"region"`
	Settings CustomActionTypeSettingsPtrOutput `pulumi:"settings"`
	Tags     pulumi.StringMapOutput            `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	Version pulumi.StringOutput    `pulumi:"version"`
}

Provides a CodeDeploy CustomActionType

## Example Usage

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/codepipeline"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codepipeline.NewCustomActionType(ctx, "example", &codepipeline.CustomActionTypeArgs{
			Category: pulumi.String("Build"),
			InputArtifactDetails: &codepipeline.CustomActionTypeInputArtifactDetailsArgs{
				MaximumCount: pulumi.Int(1),
				MinimumCount: pulumi.Int(0),
			},
			OutputArtifactDetails: &codepipeline.CustomActionTypeOutputArtifactDetailsArgs{
				MaximumCount: pulumi.Int(1),
				MinimumCount: pulumi.Int(0),
			},
			ProviderName: pulumi.String("example"),
			Version:      pulumi.String("1"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import CodeDeploy CustomActionType using the `id`. For example:

```sh $ pulumi import aws:codepipeline/customActionType:CustomActionType example Build:pulumi:1 ```

func GetCustomActionType

func GetCustomActionType(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *CustomActionTypeState, opts ...pulumi.ResourceOption) (*CustomActionType, error)

GetCustomActionType gets an existing CustomActionType resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewCustomActionType

func NewCustomActionType(ctx *pulumi.Context,
	name string, args *CustomActionTypeArgs, opts ...pulumi.ResourceOption) (*CustomActionType, error)

NewCustomActionType registers a new resource with the given unique name, arguments, and options.

func (*CustomActionType) ElementType

func (*CustomActionType) ElementType() reflect.Type

func (*CustomActionType) ToCustomActionTypeOutput

func (i *CustomActionType) ToCustomActionTypeOutput() CustomActionTypeOutput

func (*CustomActionType) ToCustomActionTypeOutputWithContext

func (i *CustomActionType) ToCustomActionTypeOutputWithContext(ctx context.Context) CustomActionTypeOutput

type CustomActionTypeArgs

type CustomActionTypeArgs struct {
	// The category of the custom action. Valid values: `Source`, `Build`, `Deploy`, `Test`, `Invoke`, `Approval`
	Category pulumi.StringInput
	// The configuration properties for the custom action. Max 10 items.
	ConfigurationProperties CustomActionTypeConfigurationPropertyArrayInput
	InputArtifactDetails    CustomActionTypeInputArtifactDetailsInput
	OutputArtifactDetails   CustomActionTypeOutputArtifactDetailsInput
	ProviderName            pulumi.StringInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region   pulumi.StringPtrInput
	Settings CustomActionTypeSettingsPtrInput
	Tags     pulumi.StringMapInput
	Version  pulumi.StringInput
}

The set of arguments for constructing a CustomActionType resource.

func (CustomActionTypeArgs) ElementType

func (CustomActionTypeArgs) ElementType() reflect.Type

type CustomActionTypeArray

type CustomActionTypeArray []CustomActionTypeInput

func (CustomActionTypeArray) ElementType

func (CustomActionTypeArray) ElementType() reflect.Type

func (CustomActionTypeArray) ToCustomActionTypeArrayOutput

func (i CustomActionTypeArray) ToCustomActionTypeArrayOutput() CustomActionTypeArrayOutput

func (CustomActionTypeArray) ToCustomActionTypeArrayOutputWithContext

func (i CustomActionTypeArray) ToCustomActionTypeArrayOutputWithContext(ctx context.Context) CustomActionTypeArrayOutput

type CustomActionTypeArrayInput

type CustomActionTypeArrayInput interface {
	pulumi.Input

	ToCustomActionTypeArrayOutput() CustomActionTypeArrayOutput
	ToCustomActionTypeArrayOutputWithContext(context.Context) CustomActionTypeArrayOutput
}

CustomActionTypeArrayInput is an input type that accepts CustomActionTypeArray and CustomActionTypeArrayOutput values. You can construct a concrete instance of `CustomActionTypeArrayInput` via:

CustomActionTypeArray{ CustomActionTypeArgs{...} }

type CustomActionTypeArrayOutput

type CustomActionTypeArrayOutput struct{ *pulumi.OutputState }

func (CustomActionTypeArrayOutput) ElementType

func (CustomActionTypeArrayOutput) Index

func (CustomActionTypeArrayOutput) ToCustomActionTypeArrayOutput

func (o CustomActionTypeArrayOutput) ToCustomActionTypeArrayOutput() CustomActionTypeArrayOutput

func (CustomActionTypeArrayOutput) ToCustomActionTypeArrayOutputWithContext

func (o CustomActionTypeArrayOutput) ToCustomActionTypeArrayOutputWithContext(ctx context.Context) CustomActionTypeArrayOutput

type CustomActionTypeConfigurationProperty

type CustomActionTypeConfigurationProperty struct {
	// The description of the action configuration property.
	Description *string `pulumi:"description"`
	// Whether the configuration property is a key.
	Key bool `pulumi:"key"`
	// The name of the action configuration property.
	Name string `pulumi:"name"`
	// Indicates that the property will be used in conjunction with PollForJobs.
	Queryable *bool `pulumi:"queryable"`
	// Whether the configuration property is a required value.
	Required bool `pulumi:"required"`
	// Whether the configuration property is secret.
	Secret bool `pulumi:"secret"`
	// The type of the configuration property. Valid values: `String`, `Number`, `Boolean`
	Type *string `pulumi:"type"`
}

type CustomActionTypeConfigurationPropertyArgs

type CustomActionTypeConfigurationPropertyArgs struct {
	// The description of the action configuration property.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Whether the configuration property is a key.
	Key pulumi.BoolInput `pulumi:"key"`
	// The name of the action configuration property.
	Name pulumi.StringInput `pulumi:"name"`
	// Indicates that the property will be used in conjunction with PollForJobs.
	Queryable pulumi.BoolPtrInput `pulumi:"queryable"`
	// Whether the configuration property is a required value.
	Required pulumi.BoolInput `pulumi:"required"`
	// Whether the configuration property is secret.
	Secret pulumi.BoolInput `pulumi:"secret"`
	// The type of the configuration property. Valid values: `String`, `Number`, `Boolean`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (CustomActionTypeConfigurationPropertyArgs) ElementType

func (CustomActionTypeConfigurationPropertyArgs) ToCustomActionTypeConfigurationPropertyOutput

func (i CustomActionTypeConfigurationPropertyArgs) ToCustomActionTypeConfigurationPropertyOutput() CustomActionTypeConfigurationPropertyOutput

func (CustomActionTypeConfigurationPropertyArgs) ToCustomActionTypeConfigurationPropertyOutputWithContext

func (i CustomActionTypeConfigurationPropertyArgs) ToCustomActionTypeConfigurationPropertyOutputWithContext(ctx context.Context) CustomActionTypeConfigurationPropertyOutput

type CustomActionTypeConfigurationPropertyArray

type CustomActionTypeConfigurationPropertyArray []CustomActionTypeConfigurationPropertyInput

func (CustomActionTypeConfigurationPropertyArray) ElementType

func (CustomActionTypeConfigurationPropertyArray) ToCustomActionTypeConfigurationPropertyArrayOutput

func (i CustomActionTypeConfigurationPropertyArray) ToCustomActionTypeConfigurationPropertyArrayOutput() CustomActionTypeConfigurationPropertyArrayOutput

func (CustomActionTypeConfigurationPropertyArray) ToCustomActionTypeConfigurationPropertyArrayOutputWithContext

func (i CustomActionTypeConfigurationPropertyArray) ToCustomActionTypeConfigurationPropertyArrayOutputWithContext(ctx context.Context) CustomActionTypeConfigurationPropertyArrayOutput

type CustomActionTypeConfigurationPropertyArrayInput

type CustomActionTypeConfigurationPropertyArrayInput interface {
	pulumi.Input

	ToCustomActionTypeConfigurationPropertyArrayOutput() CustomActionTypeConfigurationPropertyArrayOutput
	ToCustomActionTypeConfigurationPropertyArrayOutputWithContext(context.Context) CustomActionTypeConfigurationPropertyArrayOutput
}

CustomActionTypeConfigurationPropertyArrayInput is an input type that accepts CustomActionTypeConfigurationPropertyArray and CustomActionTypeConfigurationPropertyArrayOutput values. You can construct a concrete instance of `CustomActionTypeConfigurationPropertyArrayInput` via:

CustomActionTypeConfigurationPropertyArray{ CustomActionTypeConfigurationPropertyArgs{...} }

type CustomActionTypeConfigurationPropertyArrayOutput

type CustomActionTypeConfigurationPropertyArrayOutput struct{ *pulumi.OutputState }

func (CustomActionTypeConfigurationPropertyArrayOutput) ElementType

func (CustomActionTypeConfigurationPropertyArrayOutput) Index

func (CustomActionTypeConfigurationPropertyArrayOutput) ToCustomActionTypeConfigurationPropertyArrayOutput

func (o CustomActionTypeConfigurationPropertyArrayOutput) ToCustomActionTypeConfigurationPropertyArrayOutput() CustomActionTypeConfigurationPropertyArrayOutput

func (CustomActionTypeConfigurationPropertyArrayOutput) ToCustomActionTypeConfigurationPropertyArrayOutputWithContext

func (o CustomActionTypeConfigurationPropertyArrayOutput) ToCustomActionTypeConfigurationPropertyArrayOutputWithContext(ctx context.Context) CustomActionTypeConfigurationPropertyArrayOutput

type CustomActionTypeConfigurationPropertyInput

type CustomActionTypeConfigurationPropertyInput interface {
	pulumi.Input

	ToCustomActionTypeConfigurationPropertyOutput() CustomActionTypeConfigurationPropertyOutput
	ToCustomActionTypeConfigurationPropertyOutputWithContext(context.Context) CustomActionTypeConfigurationPropertyOutput
}

CustomActionTypeConfigurationPropertyInput is an input type that accepts CustomActionTypeConfigurationPropertyArgs and CustomActionTypeConfigurationPropertyOutput values. You can construct a concrete instance of `CustomActionTypeConfigurationPropertyInput` via:

CustomActionTypeConfigurationPropertyArgs{...}

type CustomActionTypeConfigurationPropertyOutput

type CustomActionTypeConfigurationPropertyOutput struct{ *pulumi.OutputState }

func (CustomActionTypeConfigurationPropertyOutput) Description

The description of the action configuration property.

func (CustomActionTypeConfigurationPropertyOutput) ElementType

func (CustomActionTypeConfigurationPropertyOutput) Key

Whether the configuration property is a key.

func (CustomActionTypeConfigurationPropertyOutput) Name

The name of the action configuration property.

func (CustomActionTypeConfigurationPropertyOutput) Queryable

Indicates that the property will be used in conjunction with PollForJobs.

func (CustomActionTypeConfigurationPropertyOutput) Required

Whether the configuration property is a required value.

func (CustomActionTypeConfigurationPropertyOutput) Secret

Whether the configuration property is secret.

func (CustomActionTypeConfigurationPropertyOutput) ToCustomActionTypeConfigurationPropertyOutput

func (o CustomActionTypeConfigurationPropertyOutput) ToCustomActionTypeConfigurationPropertyOutput() CustomActionTypeConfigurationPropertyOutput

func (CustomActionTypeConfigurationPropertyOutput) ToCustomActionTypeConfigurationPropertyOutputWithContext

func (o CustomActionTypeConfigurationPropertyOutput) ToCustomActionTypeConfigurationPropertyOutputWithContext(ctx context.Context) CustomActionTypeConfigurationPropertyOutput

func (CustomActionTypeConfigurationPropertyOutput) Type

The type of the configuration property. Valid values: `String`, `Number`, `Boolean`

type CustomActionTypeInput

type CustomActionTypeInput interface {
	pulumi.Input

	ToCustomActionTypeOutput() CustomActionTypeOutput
	ToCustomActionTypeOutputWithContext(ctx context.Context) CustomActionTypeOutput
}

type CustomActionTypeInputArtifactDetails

type CustomActionTypeInputArtifactDetails struct {
	// The maximum number of artifacts allowed for the action type. Min: 0, Max: 5
	MaximumCount int `pulumi:"maximumCount"`
	// The minimum number of artifacts allowed for the action type. Min: 0, Max: 5
	MinimumCount int `pulumi:"minimumCount"`
}

type CustomActionTypeInputArtifactDetailsArgs

type CustomActionTypeInputArtifactDetailsArgs struct {
	// The maximum number of artifacts allowed for the action type. Min: 0, Max: 5
	MaximumCount pulumi.IntInput `pulumi:"maximumCount"`
	// The minimum number of artifacts allowed for the action type. Min: 0, Max: 5
	MinimumCount pulumi.IntInput `pulumi:"minimumCount"`
}

func (CustomActionTypeInputArtifactDetailsArgs) ElementType

func (CustomActionTypeInputArtifactDetailsArgs) ToCustomActionTypeInputArtifactDetailsOutput

func (i CustomActionTypeInputArtifactDetailsArgs) ToCustomActionTypeInputArtifactDetailsOutput() CustomActionTypeInputArtifactDetailsOutput

func (CustomActionTypeInputArtifactDetailsArgs) ToCustomActionTypeInputArtifactDetailsOutputWithContext

func (i CustomActionTypeInputArtifactDetailsArgs) ToCustomActionTypeInputArtifactDetailsOutputWithContext(ctx context.Context) CustomActionTypeInputArtifactDetailsOutput

func (CustomActionTypeInputArtifactDetailsArgs) ToCustomActionTypeInputArtifactDetailsPtrOutput

func (i CustomActionTypeInputArtifactDetailsArgs) ToCustomActionTypeInputArtifactDetailsPtrOutput() CustomActionTypeInputArtifactDetailsPtrOutput

func (CustomActionTypeInputArtifactDetailsArgs) ToCustomActionTypeInputArtifactDetailsPtrOutputWithContext

func (i CustomActionTypeInputArtifactDetailsArgs) ToCustomActionTypeInputArtifactDetailsPtrOutputWithContext(ctx context.Context) CustomActionTypeInputArtifactDetailsPtrOutput

type CustomActionTypeInputArtifactDetailsInput

type CustomActionTypeInputArtifactDetailsInput interface {
	pulumi.Input

	ToCustomActionTypeInputArtifactDetailsOutput() CustomActionTypeInputArtifactDetailsOutput
	ToCustomActionTypeInputArtifactDetailsOutputWithContext(context.Context) CustomActionTypeInputArtifactDetailsOutput
}

CustomActionTypeInputArtifactDetailsInput is an input type that accepts CustomActionTypeInputArtifactDetailsArgs and CustomActionTypeInputArtifactDetailsOutput values. You can construct a concrete instance of `CustomActionTypeInputArtifactDetailsInput` via:

CustomActionTypeInputArtifactDetailsArgs{...}

type CustomActionTypeInputArtifactDetailsOutput

type CustomActionTypeInputArtifactDetailsOutput struct{ *pulumi.OutputState }

func (CustomActionTypeInputArtifactDetailsOutput) ElementType

func (CustomActionTypeInputArtifactDetailsOutput) MaximumCount

The maximum number of artifacts allowed for the action type. Min: 0, Max: 5

func (CustomActionTypeInputArtifactDetailsOutput) MinimumCount

The minimum number of artifacts allowed for the action type. Min: 0, Max: 5

func (CustomActionTypeInputArtifactDetailsOutput) ToCustomActionTypeInputArtifactDetailsOutput

func (o CustomActionTypeInputArtifactDetailsOutput) ToCustomActionTypeInputArtifactDetailsOutput() CustomActionTypeInputArtifactDetailsOutput

func (CustomActionTypeInputArtifactDetailsOutput) ToCustomActionTypeInputArtifactDetailsOutputWithContext

func (o CustomActionTypeInputArtifactDetailsOutput) ToCustomActionTypeInputArtifactDetailsOutputWithContext(ctx context.Context) CustomActionTypeInputArtifactDetailsOutput

func (CustomActionTypeInputArtifactDetailsOutput) ToCustomActionTypeInputArtifactDetailsPtrOutput

func (o CustomActionTypeInputArtifactDetailsOutput) ToCustomActionTypeInputArtifactDetailsPtrOutput() CustomActionTypeInputArtifactDetailsPtrOutput

func (CustomActionTypeInputArtifactDetailsOutput) ToCustomActionTypeInputArtifactDetailsPtrOutputWithContext

func (o CustomActionTypeInputArtifactDetailsOutput) ToCustomActionTypeInputArtifactDetailsPtrOutputWithContext(ctx context.Context) CustomActionTypeInputArtifactDetailsPtrOutput

type CustomActionTypeInputArtifactDetailsPtrInput

type CustomActionTypeInputArtifactDetailsPtrInput interface {
	pulumi.Input

	ToCustomActionTypeInputArtifactDetailsPtrOutput() CustomActionTypeInputArtifactDetailsPtrOutput
	ToCustomActionTypeInputArtifactDetailsPtrOutputWithContext(context.Context) CustomActionTypeInputArtifactDetailsPtrOutput
}

CustomActionTypeInputArtifactDetailsPtrInput is an input type that accepts CustomActionTypeInputArtifactDetailsArgs, CustomActionTypeInputArtifactDetailsPtr and CustomActionTypeInputArtifactDetailsPtrOutput values. You can construct a concrete instance of `CustomActionTypeInputArtifactDetailsPtrInput` via:

        CustomActionTypeInputArtifactDetailsArgs{...}

or:

        nil

type CustomActionTypeInputArtifactDetailsPtrOutput

type CustomActionTypeInputArtifactDetailsPtrOutput struct{ *pulumi.OutputState }

func (CustomActionTypeInputArtifactDetailsPtrOutput) Elem

func (CustomActionTypeInputArtifactDetailsPtrOutput) ElementType

func (CustomActionTypeInputArtifactDetailsPtrOutput) MaximumCount

The maximum number of artifacts allowed for the action type. Min: 0, Max: 5

func (CustomActionTypeInputArtifactDetailsPtrOutput) MinimumCount

The minimum number of artifacts allowed for the action type. Min: 0, Max: 5

func (CustomActionTypeInputArtifactDetailsPtrOutput) ToCustomActionTypeInputArtifactDetailsPtrOutput

func (o CustomActionTypeInputArtifactDetailsPtrOutput) ToCustomActionTypeInputArtifactDetailsPtrOutput() CustomActionTypeInputArtifactDetailsPtrOutput

func (CustomActionTypeInputArtifactDetailsPtrOutput) ToCustomActionTypeInputArtifactDetailsPtrOutputWithContext

func (o CustomActionTypeInputArtifactDetailsPtrOutput) ToCustomActionTypeInputArtifactDetailsPtrOutputWithContext(ctx context.Context) CustomActionTypeInputArtifactDetailsPtrOutput

type CustomActionTypeMap

type CustomActionTypeMap map[string]CustomActionTypeInput

func (CustomActionTypeMap) ElementType

func (CustomActionTypeMap) ElementType() reflect.Type

func (CustomActionTypeMap) ToCustomActionTypeMapOutput

func (i CustomActionTypeMap) ToCustomActionTypeMapOutput() CustomActionTypeMapOutput

func (CustomActionTypeMap) ToCustomActionTypeMapOutputWithContext

func (i CustomActionTypeMap) ToCustomActionTypeMapOutputWithContext(ctx context.Context) CustomActionTypeMapOutput

type CustomActionTypeMapInput

type CustomActionTypeMapInput interface {
	pulumi.Input

	ToCustomActionTypeMapOutput() CustomActionTypeMapOutput
	ToCustomActionTypeMapOutputWithContext(context.Context) CustomActionTypeMapOutput
}

CustomActionTypeMapInput is an input type that accepts CustomActionTypeMap and CustomActionTypeMapOutput values. You can construct a concrete instance of `CustomActionTypeMapInput` via:

CustomActionTypeMap{ "key": CustomActionTypeArgs{...} }

type CustomActionTypeMapOutput

type CustomActionTypeMapOutput struct{ *pulumi.OutputState }

func (CustomActionTypeMapOutput) ElementType

func (CustomActionTypeMapOutput) ElementType() reflect.Type

func (CustomActionTypeMapOutput) MapIndex

func (CustomActionTypeMapOutput) ToCustomActionTypeMapOutput

func (o CustomActionTypeMapOutput) ToCustomActionTypeMapOutput() CustomActionTypeMapOutput

func (CustomActionTypeMapOutput) ToCustomActionTypeMapOutputWithContext

func (o CustomActionTypeMapOutput) ToCustomActionTypeMapOutputWithContext(ctx context.Context) CustomActionTypeMapOutput

type CustomActionTypeOutput

type CustomActionTypeOutput struct{ *pulumi.OutputState }

func (CustomActionTypeOutput) Arn

The action ARN.

func (CustomActionTypeOutput) Category

The category of the custom action. Valid values: `Source`, `Build`, `Deploy`, `Test`, `Invoke`, `Approval`

func (CustomActionTypeOutput) ConfigurationProperties

The configuration properties for the custom action. Max 10 items.

func (CustomActionTypeOutput) ElementType

func (CustomActionTypeOutput) ElementType() reflect.Type

func (CustomActionTypeOutput) InputArtifactDetails

func (CustomActionTypeOutput) OutputArtifactDetails

func (CustomActionTypeOutput) Owner

The creator of the action being called.

func (CustomActionTypeOutput) ProviderName

func (o CustomActionTypeOutput) ProviderName() pulumi.StringOutput

func (CustomActionTypeOutput) Region

Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

func (CustomActionTypeOutput) Settings

func (CustomActionTypeOutput) Tags

func (CustomActionTypeOutput) TagsAll

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

func (CustomActionTypeOutput) ToCustomActionTypeOutput

func (o CustomActionTypeOutput) ToCustomActionTypeOutput() CustomActionTypeOutput

func (CustomActionTypeOutput) ToCustomActionTypeOutputWithContext

func (o CustomActionTypeOutput) ToCustomActionTypeOutputWithContext(ctx context.Context) CustomActionTypeOutput

func (CustomActionTypeOutput) Version

type CustomActionTypeOutputArtifactDetails

type CustomActionTypeOutputArtifactDetails struct {
	// The maximum number of artifacts allowed for the action type. Min: 0, Max: 5
	MaximumCount int `pulumi:"maximumCount"`
	// The minimum number of artifacts allowed for the action type. Min: 0, Max: 5
	MinimumCount int `pulumi:"minimumCount"`
}

type CustomActionTypeOutputArtifactDetailsArgs

type CustomActionTypeOutputArtifactDetailsArgs struct {
	// The maximum number of artifacts allowed for the action type. Min: 0, Max: 5
	MaximumCount pulumi.IntInput `pulumi:"maximumCount"`
	// The minimum number of artifacts allowed for the action type. Min: 0, Max: 5
	MinimumCount pulumi.IntInput `pulumi:"minimumCount"`
}

func (CustomActionTypeOutputArtifactDetailsArgs) ElementType

func (CustomActionTypeOutputArtifactDetailsArgs) ToCustomActionTypeOutputArtifactDetailsOutput

func (i CustomActionTypeOutputArtifactDetailsArgs) ToCustomActionTypeOutputArtifactDetailsOutput() CustomActionTypeOutputArtifactDetailsOutput

func (CustomActionTypeOutputArtifactDetailsArgs) ToCustomActionTypeOutputArtifactDetailsOutputWithContext

func (i CustomActionTypeOutputArtifactDetailsArgs) ToCustomActionTypeOutputArtifactDetailsOutputWithContext(ctx context.Context) CustomActionTypeOutputArtifactDetailsOutput

func (CustomActionTypeOutputArtifactDetailsArgs) ToCustomActionTypeOutputArtifactDetailsPtrOutput

func (i CustomActionTypeOutputArtifactDetailsArgs) ToCustomActionTypeOutputArtifactDetailsPtrOutput() CustomActionTypeOutputArtifactDetailsPtrOutput

func (CustomActionTypeOutputArtifactDetailsArgs) ToCustomActionTypeOutputArtifactDetailsPtrOutputWithContext

func (i CustomActionTypeOutputArtifactDetailsArgs) ToCustomActionTypeOutputArtifactDetailsPtrOutputWithContext(ctx context.Context) CustomActionTypeOutputArtifactDetailsPtrOutput

type CustomActionTypeOutputArtifactDetailsInput

type CustomActionTypeOutputArtifactDetailsInput interface {
	pulumi.Input

	ToCustomActionTypeOutputArtifactDetailsOutput() CustomActionTypeOutputArtifactDetailsOutput
	ToCustomActionTypeOutputArtifactDetailsOutputWithContext(context.Context) CustomActionTypeOutputArtifactDetailsOutput
}

CustomActionTypeOutputArtifactDetailsInput is an input type that accepts CustomActionTypeOutputArtifactDetailsArgs and CustomActionTypeOutputArtifactDetailsOutput values. You can construct a concrete instance of `CustomActionTypeOutputArtifactDetailsInput` via:

CustomActionTypeOutputArtifactDetailsArgs{...}

type CustomActionTypeOutputArtifactDetailsOutput

type CustomActionTypeOutputArtifactDetailsOutput struct{ *pulumi.OutputState }

func (CustomActionTypeOutputArtifactDetailsOutput) ElementType

func (CustomActionTypeOutputArtifactDetailsOutput) MaximumCount

The maximum number of artifacts allowed for the action type. Min: 0, Max: 5

func (CustomActionTypeOutputArtifactDetailsOutput) MinimumCount

The minimum number of artifacts allowed for the action type. Min: 0, Max: 5

func (CustomActionTypeOutputArtifactDetailsOutput) ToCustomActionTypeOutputArtifactDetailsOutput

func (o CustomActionTypeOutputArtifactDetailsOutput) ToCustomActionTypeOutputArtifactDetailsOutput() CustomActionTypeOutputArtifactDetailsOutput

func (CustomActionTypeOutputArtifactDetailsOutput) ToCustomActionTypeOutputArtifactDetailsOutputWithContext

func (o CustomActionTypeOutputArtifactDetailsOutput) ToCustomActionTypeOutputArtifactDetailsOutputWithContext(ctx context.Context) CustomActionTypeOutputArtifactDetailsOutput

func (CustomActionTypeOutputArtifactDetailsOutput) ToCustomActionTypeOutputArtifactDetailsPtrOutput

func (o CustomActionTypeOutputArtifactDetailsOutput) ToCustomActionTypeOutputArtifactDetailsPtrOutput() CustomActionTypeOutputArtifactDetailsPtrOutput

func (CustomActionTypeOutputArtifactDetailsOutput) ToCustomActionTypeOutputArtifactDetailsPtrOutputWithContext

func (o CustomActionTypeOutputArtifactDetailsOutput) ToCustomActionTypeOutputArtifactDetailsPtrOutputWithContext(ctx context.Context) CustomActionTypeOutputArtifactDetailsPtrOutput

type CustomActionTypeOutputArtifactDetailsPtrInput

type CustomActionTypeOutputArtifactDetailsPtrInput interface {
	pulumi.Input

	ToCustomActionTypeOutputArtifactDetailsPtrOutput() CustomActionTypeOutputArtifactDetailsPtrOutput
	ToCustomActionTypeOutputArtifactDetailsPtrOutputWithContext(context.Context) CustomActionTypeOutputArtifactDetailsPtrOutput
}

CustomActionTypeOutputArtifactDetailsPtrInput is an input type that accepts CustomActionTypeOutputArtifactDetailsArgs, CustomActionTypeOutputArtifactDetailsPtr and CustomActionTypeOutputArtifactDetailsPtrOutput values. You can construct a concrete instance of `CustomActionTypeOutputArtifactDetailsPtrInput` via:

        CustomActionTypeOutputArtifactDetailsArgs{...}

or:

        nil

type CustomActionTypeOutputArtifactDetailsPtrOutput

type CustomActionTypeOutputArtifactDetailsPtrOutput struct{ *pulumi.OutputState }

func (CustomActionTypeOutputArtifactDetailsPtrOutput) Elem

func (CustomActionTypeOutputArtifactDetailsPtrOutput) ElementType

func (CustomActionTypeOutputArtifactDetailsPtrOutput) MaximumCount

The maximum number of artifacts allowed for the action type. Min: 0, Max: 5

func (CustomActionTypeOutputArtifactDetailsPtrOutput) MinimumCount

The minimum number of artifacts allowed for the action type. Min: 0, Max: 5

func (CustomActionTypeOutputArtifactDetailsPtrOutput) ToCustomActionTypeOutputArtifactDetailsPtrOutput

func (o CustomActionTypeOutputArtifactDetailsPtrOutput) ToCustomActionTypeOutputArtifactDetailsPtrOutput() CustomActionTypeOutputArtifactDetailsPtrOutput

func (CustomActionTypeOutputArtifactDetailsPtrOutput) ToCustomActionTypeOutputArtifactDetailsPtrOutputWithContext

func (o CustomActionTypeOutputArtifactDetailsPtrOutput) ToCustomActionTypeOutputArtifactDetailsPtrOutputWithContext(ctx context.Context) CustomActionTypeOutputArtifactDetailsPtrOutput

type CustomActionTypeSettings

type CustomActionTypeSettings struct {
	// The URL returned to the AWS CodePipeline console that provides a deep link to the resources of the external system.
	EntityUrlTemplate *string `pulumi:"entityUrlTemplate"`
	// The URL returned to the AWS CodePipeline console that contains a link to the top-level landing page for the external system.
	ExecutionUrlTemplate *string `pulumi:"executionUrlTemplate"`
	// The URL returned to the AWS CodePipeline console that contains a link to the page where customers can update or change the configuration of the external action.
	RevisionUrlTemplate *string `pulumi:"revisionUrlTemplate"`
	// The URL of a sign-up page where users can sign up for an external service and perform initial configuration of the action provided by that service.
	ThirdPartyConfigurationUrl *string `pulumi:"thirdPartyConfigurationUrl"`
}

type CustomActionTypeSettingsArgs

type CustomActionTypeSettingsArgs struct {
	// The URL returned to the AWS CodePipeline console that provides a deep link to the resources of the external system.
	EntityUrlTemplate pulumi.StringPtrInput `pulumi:"entityUrlTemplate"`
	// The URL returned to the AWS CodePipeline console that contains a link to the top-level landing page for the external system.
	ExecutionUrlTemplate pulumi.StringPtrInput `pulumi:"executionUrlTemplate"`
	// The URL returned to the AWS CodePipeline console that contains a link to the page where customers can update or change the configuration of the external action.
	RevisionUrlTemplate pulumi.StringPtrInput `pulumi:"revisionUrlTemplate"`
	// The URL of a sign-up page where users can sign up for an external service and perform initial configuration of the action provided by that service.
	ThirdPartyConfigurationUrl pulumi.StringPtrInput `pulumi:"thirdPartyConfigurationUrl"`
}

func (CustomActionTypeSettingsArgs) ElementType

func (CustomActionTypeSettingsArgs) ToCustomActionTypeSettingsOutput

func (i CustomActionTypeSettingsArgs) ToCustomActionTypeSettingsOutput() CustomActionTypeSettingsOutput

func (CustomActionTypeSettingsArgs) ToCustomActionTypeSettingsOutputWithContext

func (i CustomActionTypeSettingsArgs) ToCustomActionTypeSettingsOutputWithContext(ctx context.Context) CustomActionTypeSettingsOutput

func (CustomActionTypeSettingsArgs) ToCustomActionTypeSettingsPtrOutput

func (i CustomActionTypeSettingsArgs) ToCustomActionTypeSettingsPtrOutput() CustomActionTypeSettingsPtrOutput

func (CustomActionTypeSettingsArgs) ToCustomActionTypeSettingsPtrOutputWithContext

func (i CustomActionTypeSettingsArgs) ToCustomActionTypeSettingsPtrOutputWithContext(ctx context.Context) CustomActionTypeSettingsPtrOutput

type CustomActionTypeSettingsInput

type CustomActionTypeSettingsInput interface {
	pulumi.Input

	ToCustomActionTypeSettingsOutput() CustomActionTypeSettingsOutput
	ToCustomActionTypeSettingsOutputWithContext(context.Context) CustomActionTypeSettingsOutput
}

CustomActionTypeSettingsInput is an input type that accepts CustomActionTypeSettingsArgs and CustomActionTypeSettingsOutput values. You can construct a concrete instance of `CustomActionTypeSettingsInput` via:

CustomActionTypeSettingsArgs{...}

type CustomActionTypeSettingsOutput

type CustomActionTypeSettingsOutput struct{ *pulumi.OutputState }

func (CustomActionTypeSettingsOutput) ElementType

func (CustomActionTypeSettingsOutput) EntityUrlTemplate

The URL returned to the AWS CodePipeline console that provides a deep link to the resources of the external system.

func (CustomActionTypeSettingsOutput) ExecutionUrlTemplate

func (o CustomActionTypeSettingsOutput) ExecutionUrlTemplate() pulumi.StringPtrOutput

The URL returned to the AWS CodePipeline console that contains a link to the top-level landing page for the external system.

func (CustomActionTypeSettingsOutput) RevisionUrlTemplate

func (o CustomActionTypeSettingsOutput) RevisionUrlTemplate() pulumi.StringPtrOutput

The URL returned to the AWS CodePipeline console that contains a link to the page where customers can update or change the configuration of the external action.

func (CustomActionTypeSettingsOutput) ThirdPartyConfigurationUrl

func (o CustomActionTypeSettingsOutput) ThirdPartyConfigurationUrl() pulumi.StringPtrOutput

The URL of a sign-up page where users can sign up for an external service and perform initial configuration of the action provided by that service.

func (CustomActionTypeSettingsOutput) ToCustomActionTypeSettingsOutput

func (o CustomActionTypeSettingsOutput) ToCustomActionTypeSettingsOutput() CustomActionTypeSettingsOutput

func (CustomActionTypeSettingsOutput) ToCustomActionTypeSettingsOutputWithContext

func (o CustomActionTypeSettingsOutput) ToCustomActionTypeSettingsOutputWithContext(ctx context.Context) CustomActionTypeSettingsOutput

func (CustomActionTypeSettingsOutput) ToCustomActionTypeSettingsPtrOutput

func (o CustomActionTypeSettingsOutput) ToCustomActionTypeSettingsPtrOutput() CustomActionTypeSettingsPtrOutput

func (CustomActionTypeSettingsOutput) ToCustomActionTypeSettingsPtrOutputWithContext

func (o CustomActionTypeSettingsOutput) ToCustomActionTypeSettingsPtrOutputWithContext(ctx context.Context) CustomActionTypeSettingsPtrOutput

type CustomActionTypeSettingsPtrInput

type CustomActionTypeSettingsPtrInput interface {
	pulumi.Input

	ToCustomActionTypeSettingsPtrOutput() CustomActionTypeSettingsPtrOutput
	ToCustomActionTypeSettingsPtrOutputWithContext(context.Context) CustomActionTypeSettingsPtrOutput
}

CustomActionTypeSettingsPtrInput is an input type that accepts CustomActionTypeSettingsArgs, CustomActionTypeSettingsPtr and CustomActionTypeSettingsPtrOutput values. You can construct a concrete instance of `CustomActionTypeSettingsPtrInput` via:

        CustomActionTypeSettingsArgs{...}

or:

        nil

type CustomActionTypeSettingsPtrOutput

type CustomActionTypeSettingsPtrOutput struct{ *pulumi.OutputState }

func (CustomActionTypeSettingsPtrOutput) Elem

func (CustomActionTypeSettingsPtrOutput) ElementType

func (CustomActionTypeSettingsPtrOutput) EntityUrlTemplate

The URL returned to the AWS CodePipeline console that provides a deep link to the resources of the external system.

func (CustomActionTypeSettingsPtrOutput) ExecutionUrlTemplate

func (o CustomActionTypeSettingsPtrOutput) ExecutionUrlTemplate() pulumi.StringPtrOutput

The URL returned to the AWS CodePipeline console that contains a link to the top-level landing page for the external system.

func (CustomActionTypeSettingsPtrOutput) RevisionUrlTemplate

The URL returned to the AWS CodePipeline console that contains a link to the page where customers can update or change the configuration of the external action.

func (CustomActionTypeSettingsPtrOutput) ThirdPartyConfigurationUrl

func (o CustomActionTypeSettingsPtrOutput) ThirdPartyConfigurationUrl() pulumi.StringPtrOutput

The URL of a sign-up page where users can sign up for an external service and perform initial configuration of the action provided by that service.

func (CustomActionTypeSettingsPtrOutput) ToCustomActionTypeSettingsPtrOutput

func (o CustomActionTypeSettingsPtrOutput) ToCustomActionTypeSettingsPtrOutput() CustomActionTypeSettingsPtrOutput

func (CustomActionTypeSettingsPtrOutput) ToCustomActionTypeSettingsPtrOutputWithContext

func (o CustomActionTypeSettingsPtrOutput) ToCustomActionTypeSettingsPtrOutputWithContext(ctx context.Context) CustomActionTypeSettingsPtrOutput

type CustomActionTypeState

type CustomActionTypeState struct {
	// The action ARN.
	Arn pulumi.StringPtrInput
	// The category of the custom action. Valid values: `Source`, `Build`, `Deploy`, `Test`, `Invoke`, `Approval`
	Category pulumi.StringPtrInput
	// The configuration properties for the custom action. Max 10 items.
	ConfigurationProperties CustomActionTypeConfigurationPropertyArrayInput
	InputArtifactDetails    CustomActionTypeInputArtifactDetailsPtrInput
	OutputArtifactDetails   CustomActionTypeOutputArtifactDetailsPtrInput
	// The creator of the action being called.
	Owner        pulumi.StringPtrInput
	ProviderName pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region   pulumi.StringPtrInput
	Settings CustomActionTypeSettingsPtrInput
	Tags     pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
	Version pulumi.StringPtrInput
}

func (CustomActionTypeState) ElementType

func (CustomActionTypeState) ElementType() reflect.Type

type Pipeline

type Pipeline struct {
	pulumi.CustomResourceState

	// Codepipeline ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// One or more artifactStore blocks. Artifact stores are documented below.
	ArtifactStores PipelineArtifactStoreArrayOutput `pulumi:"artifactStores"`
	// The method that the pipeline will use to handle multiple executions. The default mode is `SUPERSEDED`. For value values, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PipelineDeclaration.html#CodePipeline-Type-PipelineDeclaration-executionMode).
	ExecutionMode pulumi.StringPtrOutput `pulumi:"executionMode"`
	// The name of the pipeline.
	Name pulumi.StringOutput `pulumi:"name"`
	// Type of the pipeline. Possible values are: `V1` and `V2`. Default value is `V1`.
	PipelineType pulumi.StringPtrOutput `pulumi:"pipelineType"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// A service role Amazon Resource Name (ARN) that grants AWS CodePipeline permission to make calls to AWS services on your behalf.
	RoleArn pulumi.StringOutput `pulumi:"roleArn"`
	// A stage block. Stages are documented below.
	Stages PipelineStageArrayOutput `pulumi:"stages"`
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// A list of all triggers present on the pipeline, including default triggers added by AWS for `V2` pipelines which omit an explicit `trigger` definition.
	TriggerAlls PipelineTriggerAllArrayOutput `pulumi:"triggerAlls"`
	// A trigger block. Valid only when `pipelineType` is `V2`. Triggers are documented below.
	Triggers PipelineTriggerArrayOutput `pulumi:"triggers"`
	// A pipeline-level variable block. Valid only when `pipelineType` is `V2`. Variable are documented below.
	//
	// **Note:** `QUEUED` or `PARALLEL` mode can only be used with V2 pipelines.
	Variables PipelineVariableArrayOutput `pulumi:"variables"`
}

Provides a CodePipeline.

## Example Usage

```go package main

import (

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/codepipeline"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/codestarconnections"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/kms"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := codestarconnections.NewConnection(ctx, "example", &codestarconnections.ConnectionArgs{
			Name:         pulumi.String("example-connection"),
			ProviderType: pulumi.String("GitHub"),
		})
		if err != nil {
			return err
		}
		codepipelineBucket, err := s3.NewBucket(ctx, "codepipeline_bucket", &s3.BucketArgs{
			Bucket: pulumi.String("test-bucket"),
		})
		if err != nil {
			return err
		}
		assumeRole, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				{
					Effect: pulumi.StringRef("Allow"),
					Principals: []iam.GetPolicyDocumentStatementPrincipal{
						{
							Type: "Service",
							Identifiers: []string{
								"codepipeline.amazonaws.com",
							},
						},
					},
					Actions: []string{
						"sts:AssumeRole",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		codepipelineRole, err := iam.NewRole(ctx, "codepipeline_role", &iam.RoleArgs{
			Name:             pulumi.String("test-role"),
			AssumeRolePolicy: pulumi.String(assumeRole.Json),
		})
		if err != nil {
			return err
		}
		s3kmskey, err := kms.LookupAlias(ctx, &kms.LookupAliasArgs{
			Name: "alias/myKmsKey",
		}, nil)
		if err != nil {
			return err
		}
		_, err = codepipeline.NewPipeline(ctx, "codepipeline", &codepipeline.PipelineArgs{
			Name:    pulumi.String("tf-test-pipeline"),
			RoleArn: codepipelineRole.Arn,
			ArtifactStores: codepipeline.PipelineArtifactStoreArray{
				&codepipeline.PipelineArtifactStoreArgs{
					Location: codepipelineBucket.Bucket,
					Type:     pulumi.String("S3"),
					EncryptionKey: &codepipeline.PipelineArtifactStoreEncryptionKeyArgs{
						Id:   pulumi.String(s3kmskey.Arn),
						Type: pulumi.String("KMS"),
					},
				},
			},
			Stages: codepipeline.PipelineStageArray{
				&codepipeline.PipelineStageArgs{
					Name: pulumi.String("Source"),
					Actions: codepipeline.PipelineStageActionArray{
						&codepipeline.PipelineStageActionArgs{
							Name:     pulumi.String("Source"),
							Category: pulumi.String("Source"),
							Owner:    pulumi.String("AWS"),
							Provider: pulumi.String("CodeStarSourceConnection"),
							Version:  pulumi.String("1"),
							OutputArtifacts: pulumi.StringArray{
								pulumi.String("source_output"),
							},
							Configuration: pulumi.StringMap{
								"ConnectionArn":    example.Arn,
								"FullRepositoryId": pulumi.String("my-organization/example"),
								"BranchName":       pulumi.String("main"),
							},
						},
					},
				},
				&codepipeline.PipelineStageArgs{
					Name: pulumi.String("Build"),
					Actions: codepipeline.PipelineStageActionArray{
						&codepipeline.PipelineStageActionArgs{
							Name:     pulumi.String("Build"),
							Category: pulumi.String("Build"),
							Owner:    pulumi.String("AWS"),
							Provider: pulumi.String("CodeBuild"),
							InputArtifacts: pulumi.StringArray{
								pulumi.String("source_output"),
							},
							OutputArtifacts: pulumi.StringArray{
								pulumi.String("build_output"),
							},
							Version: pulumi.String("1"),
							Configuration: pulumi.StringMap{
								"ProjectName": pulumi.String("test"),
							},
						},
					},
				},
				&codepipeline.PipelineStageArgs{
					Name: pulumi.String("Deploy"),
					Actions: codepipeline.PipelineStageActionArray{
						&codepipeline.PipelineStageActionArgs{
							Name:     pulumi.String("Deploy"),
							Category: pulumi.String("Deploy"),
							Owner:    pulumi.String("AWS"),
							Provider: pulumi.String("CloudFormation"),
							InputArtifacts: pulumi.StringArray{
								pulumi.String("build_output"),
							},
							Version: pulumi.String("1"),
							Configuration: pulumi.StringMap{
								"ActionMode":     pulumi.String("REPLACE_ON_FAILURE"),
								"Capabilities":   pulumi.String("CAPABILITY_AUTO_EXPAND,CAPABILITY_IAM"),
								"OutputFileName": pulumi.String("CreateStackOutput.json"),
								"StackName":      pulumi.String("MyStack"),
								"TemplatePath":   pulumi.String("build_output::sam-templated.yaml"),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = s3.NewBucketPublicAccessBlock(ctx, "codepipeline_bucket_pab", &s3.BucketPublicAccessBlockArgs{
			Bucket:                codepipelineBucket.ID(),
			BlockPublicAcls:       pulumi.Bool(true),
			BlockPublicPolicy:     pulumi.Bool(true),
			IgnorePublicAcls:      pulumi.Bool(true),
			RestrictPublicBuckets: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		codepipelinePolicy := iam.GetPolicyDocumentOutput(ctx, iam.GetPolicyDocumentOutputArgs{
			Statements: iam.GetPolicyDocumentStatementArray{
				&iam.GetPolicyDocumentStatementArgs{
					Effect: pulumi.String("Allow"),
					Actions: pulumi.StringArray{
						pulumi.String("s3:GetObject"),
						pulumi.String("s3:GetObjectVersion"),
						pulumi.String("s3:GetBucketVersioning"),
						pulumi.String("s3:PutObjectAcl"),
						pulumi.String("s3:PutObject"),
					},
					Resources: pulumi.StringArray{
						codepipelineBucket.Arn,
						codepipelineBucket.Arn.ApplyT(func(arn string) (string, error) {
							return fmt.Sprintf("%v/*", arn), nil
						}).(pulumi.StringOutput),
					},
				},
				&iam.GetPolicyDocumentStatementArgs{
					Effect: pulumi.String("Allow"),
					Actions: pulumi.StringArray{
						pulumi.String("codestar-connections:UseConnection"),
					},
					Resources: pulumi.StringArray{
						example.Arn,
					},
				},
				&iam.GetPolicyDocumentStatementArgs{
					Effect: pulumi.String("Allow"),
					Actions: pulumi.StringArray{
						pulumi.String("codebuild:BatchGetBuilds"),
						pulumi.String("codebuild:StartBuild"),
					},
					Resources: pulumi.StringArray{
						pulumi.String("*"),
					},
				},
			},
		}, nil)
		_, err = iam.NewRolePolicy(ctx, "codepipeline_policy", &iam.RolePolicyArgs{
			Name: pulumi.String("codepipeline_policy"),
			Role: codepipelineRole.ID(),
			Policy: pulumi.String(codepipelinePolicy.ApplyT(func(codepipelinePolicy iam.GetPolicyDocumentResult) (*string, error) {
				return &codepipelinePolicy.Json, nil
			}).(pulumi.StringPtrOutput)),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import CodePipelines using the `name`. For example:

```sh $ pulumi import aws:codepipeline/pipeline:Pipeline example example-pipeline ```

func GetPipeline

func GetPipeline(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *PipelineState, opts ...pulumi.ResourceOption) (*Pipeline, error)

GetPipeline gets an existing Pipeline resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewPipeline

func NewPipeline(ctx *pulumi.Context,
	name string, args *PipelineArgs, opts ...pulumi.ResourceOption) (*Pipeline, error)

NewPipeline registers a new resource with the given unique name, arguments, and options.

func (*Pipeline) ElementType

func (*Pipeline) ElementType() reflect.Type

func (*Pipeline) ToPipelineOutput

func (i *Pipeline) ToPipelineOutput() PipelineOutput

func (*Pipeline) ToPipelineOutputWithContext

func (i *Pipeline) ToPipelineOutputWithContext(ctx context.Context) PipelineOutput

type PipelineArgs

type PipelineArgs struct {
	// One or more artifactStore blocks. Artifact stores are documented below.
	ArtifactStores PipelineArtifactStoreArrayInput
	// The method that the pipeline will use to handle multiple executions. The default mode is `SUPERSEDED`. For value values, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PipelineDeclaration.html#CodePipeline-Type-PipelineDeclaration-executionMode).
	ExecutionMode pulumi.StringPtrInput
	// The name of the pipeline.
	Name pulumi.StringPtrInput
	// Type of the pipeline. Possible values are: `V1` and `V2`. Default value is `V1`.
	PipelineType pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// A service role Amazon Resource Name (ARN) that grants AWS CodePipeline permission to make calls to AWS services on your behalf.
	RoleArn pulumi.StringInput
	// A stage block. Stages are documented below.
	Stages PipelineStageArrayInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A trigger block. Valid only when `pipelineType` is `V2`. Triggers are documented below.
	Triggers PipelineTriggerArrayInput
	// A pipeline-level variable block. Valid only when `pipelineType` is `V2`. Variable are documented below.
	//
	// **Note:** `QUEUED` or `PARALLEL` mode can only be used with V2 pipelines.
	Variables PipelineVariableArrayInput
}

The set of arguments for constructing a Pipeline resource.

func (PipelineArgs) ElementType

func (PipelineArgs) ElementType() reflect.Type

type PipelineArray

type PipelineArray []PipelineInput

func (PipelineArray) ElementType

func (PipelineArray) ElementType() reflect.Type

func (PipelineArray) ToPipelineArrayOutput

func (i PipelineArray) ToPipelineArrayOutput() PipelineArrayOutput

func (PipelineArray) ToPipelineArrayOutputWithContext

func (i PipelineArray) ToPipelineArrayOutputWithContext(ctx context.Context) PipelineArrayOutput

type PipelineArrayInput

type PipelineArrayInput interface {
	pulumi.Input

	ToPipelineArrayOutput() PipelineArrayOutput
	ToPipelineArrayOutputWithContext(context.Context) PipelineArrayOutput
}

PipelineArrayInput is an input type that accepts PipelineArray and PipelineArrayOutput values. You can construct a concrete instance of `PipelineArrayInput` via:

PipelineArray{ PipelineArgs{...} }

type PipelineArrayOutput

type PipelineArrayOutput struct{ *pulumi.OutputState }

func (PipelineArrayOutput) ElementType

func (PipelineArrayOutput) ElementType() reflect.Type

func (PipelineArrayOutput) Index

func (PipelineArrayOutput) ToPipelineArrayOutput

func (o PipelineArrayOutput) ToPipelineArrayOutput() PipelineArrayOutput

func (PipelineArrayOutput) ToPipelineArrayOutputWithContext

func (o PipelineArrayOutput) ToPipelineArrayOutputWithContext(ctx context.Context) PipelineArrayOutput

type PipelineArtifactStore

type PipelineArtifactStore struct {
	// The encryption key block AWS CodePipeline uses to encrypt the data in the artifact store, such as an AWS Key Management Service (AWS KMS) key. If you don't specify a key, AWS CodePipeline uses the default key for Amazon Simple Storage Service (Amazon S3). An `encryptionKey` block is documented below.
	EncryptionKey *PipelineArtifactStoreEncryptionKey `pulumi:"encryptionKey"`
	// The location where AWS CodePipeline stores artifacts for a pipeline; currently only `S3` is supported.
	Location string `pulumi:"location"`
	// The region where the artifact store is located. Required for a cross-region CodePipeline, do not provide for a single-region CodePipeline.
	Region *string `pulumi:"region"`
	// The type of the artifact store, such as Amazon S3
	Type string `pulumi:"type"`
}

type PipelineArtifactStoreArgs

type PipelineArtifactStoreArgs struct {
	// The encryption key block AWS CodePipeline uses to encrypt the data in the artifact store, such as an AWS Key Management Service (AWS KMS) key. If you don't specify a key, AWS CodePipeline uses the default key for Amazon Simple Storage Service (Amazon S3). An `encryptionKey` block is documented below.
	EncryptionKey PipelineArtifactStoreEncryptionKeyPtrInput `pulumi:"encryptionKey"`
	// The location where AWS CodePipeline stores artifacts for a pipeline; currently only `S3` is supported.
	Location pulumi.StringInput `pulumi:"location"`
	// The region where the artifact store is located. Required for a cross-region CodePipeline, do not provide for a single-region CodePipeline.
	Region pulumi.StringPtrInput `pulumi:"region"`
	// The type of the artifact store, such as Amazon S3
	Type pulumi.StringInput `pulumi:"type"`
}

func (PipelineArtifactStoreArgs) ElementType

func (PipelineArtifactStoreArgs) ElementType() reflect.Type

func (PipelineArtifactStoreArgs) ToPipelineArtifactStoreOutput

func (i PipelineArtifactStoreArgs) ToPipelineArtifactStoreOutput() PipelineArtifactStoreOutput

func (PipelineArtifactStoreArgs) ToPipelineArtifactStoreOutputWithContext

func (i PipelineArtifactStoreArgs) ToPipelineArtifactStoreOutputWithContext(ctx context.Context) PipelineArtifactStoreOutput

type PipelineArtifactStoreArray

type PipelineArtifactStoreArray []PipelineArtifactStoreInput

func (PipelineArtifactStoreArray) ElementType

func (PipelineArtifactStoreArray) ElementType() reflect.Type

func (PipelineArtifactStoreArray) ToPipelineArtifactStoreArrayOutput

func (i PipelineArtifactStoreArray) ToPipelineArtifactStoreArrayOutput() PipelineArtifactStoreArrayOutput

func (PipelineArtifactStoreArray) ToPipelineArtifactStoreArrayOutputWithContext

func (i PipelineArtifactStoreArray) ToPipelineArtifactStoreArrayOutputWithContext(ctx context.Context) PipelineArtifactStoreArrayOutput

type PipelineArtifactStoreArrayInput

type PipelineArtifactStoreArrayInput interface {
	pulumi.Input

	ToPipelineArtifactStoreArrayOutput() PipelineArtifactStoreArrayOutput
	ToPipelineArtifactStoreArrayOutputWithContext(context.Context) PipelineArtifactStoreArrayOutput
}

PipelineArtifactStoreArrayInput is an input type that accepts PipelineArtifactStoreArray and PipelineArtifactStoreArrayOutput values. You can construct a concrete instance of `PipelineArtifactStoreArrayInput` via:

PipelineArtifactStoreArray{ PipelineArtifactStoreArgs{...} }

type PipelineArtifactStoreArrayOutput

type PipelineArtifactStoreArrayOutput struct{ *pulumi.OutputState }

func (PipelineArtifactStoreArrayOutput) ElementType

func (PipelineArtifactStoreArrayOutput) Index

func (PipelineArtifactStoreArrayOutput) ToPipelineArtifactStoreArrayOutput

func (o PipelineArtifactStoreArrayOutput) ToPipelineArtifactStoreArrayOutput() PipelineArtifactStoreArrayOutput

func (PipelineArtifactStoreArrayOutput) ToPipelineArtifactStoreArrayOutputWithContext

func (o PipelineArtifactStoreArrayOutput) ToPipelineArtifactStoreArrayOutputWithContext(ctx context.Context) PipelineArtifactStoreArrayOutput

type PipelineArtifactStoreEncryptionKey

type PipelineArtifactStoreEncryptionKey struct {
	// The KMS key ARN or ID
	Id string `pulumi:"id"`
	// The type of key; currently only `KMS` is supported
	Type string `pulumi:"type"`
}

type PipelineArtifactStoreEncryptionKeyArgs

type PipelineArtifactStoreEncryptionKeyArgs struct {
	// The KMS key ARN or ID
	Id pulumi.StringInput `pulumi:"id"`
	// The type of key; currently only `KMS` is supported
	Type pulumi.StringInput `pulumi:"type"`
}

func (PipelineArtifactStoreEncryptionKeyArgs) ElementType

func (PipelineArtifactStoreEncryptionKeyArgs) ToPipelineArtifactStoreEncryptionKeyOutput

func (i PipelineArtifactStoreEncryptionKeyArgs) ToPipelineArtifactStoreEncryptionKeyOutput() PipelineArtifactStoreEncryptionKeyOutput

func (PipelineArtifactStoreEncryptionKeyArgs) ToPipelineArtifactStoreEncryptionKeyOutputWithContext

func (i PipelineArtifactStoreEncryptionKeyArgs) ToPipelineArtifactStoreEncryptionKeyOutputWithContext(ctx context.Context) PipelineArtifactStoreEncryptionKeyOutput

func (PipelineArtifactStoreEncryptionKeyArgs) ToPipelineArtifactStoreEncryptionKeyPtrOutput

func (i PipelineArtifactStoreEncryptionKeyArgs) ToPipelineArtifactStoreEncryptionKeyPtrOutput() PipelineArtifactStoreEncryptionKeyPtrOutput

func (PipelineArtifactStoreEncryptionKeyArgs) ToPipelineArtifactStoreEncryptionKeyPtrOutputWithContext

func (i PipelineArtifactStoreEncryptionKeyArgs) ToPipelineArtifactStoreEncryptionKeyPtrOutputWithContext(ctx context.Context) PipelineArtifactStoreEncryptionKeyPtrOutput

type PipelineArtifactStoreEncryptionKeyInput

type PipelineArtifactStoreEncryptionKeyInput interface {
	pulumi.Input

	ToPipelineArtifactStoreEncryptionKeyOutput() PipelineArtifactStoreEncryptionKeyOutput
	ToPipelineArtifactStoreEncryptionKeyOutputWithContext(context.Context) PipelineArtifactStoreEncryptionKeyOutput
}

PipelineArtifactStoreEncryptionKeyInput is an input type that accepts PipelineArtifactStoreEncryptionKeyArgs and PipelineArtifactStoreEncryptionKeyOutput values. You can construct a concrete instance of `PipelineArtifactStoreEncryptionKeyInput` via:

PipelineArtifactStoreEncryptionKeyArgs{...}

type PipelineArtifactStoreEncryptionKeyOutput

type PipelineArtifactStoreEncryptionKeyOutput struct{ *pulumi.OutputState }

func (PipelineArtifactStoreEncryptionKeyOutput) ElementType

func (PipelineArtifactStoreEncryptionKeyOutput) Id

The KMS key ARN or ID

func (PipelineArtifactStoreEncryptionKeyOutput) ToPipelineArtifactStoreEncryptionKeyOutput

func (o PipelineArtifactStoreEncryptionKeyOutput) ToPipelineArtifactStoreEncryptionKeyOutput() PipelineArtifactStoreEncryptionKeyOutput

func (PipelineArtifactStoreEncryptionKeyOutput) ToPipelineArtifactStoreEncryptionKeyOutputWithContext

func (o PipelineArtifactStoreEncryptionKeyOutput) ToPipelineArtifactStoreEncryptionKeyOutputWithContext(ctx context.Context) PipelineArtifactStoreEncryptionKeyOutput

func (PipelineArtifactStoreEncryptionKeyOutput) ToPipelineArtifactStoreEncryptionKeyPtrOutput

func (o PipelineArtifactStoreEncryptionKeyOutput) ToPipelineArtifactStoreEncryptionKeyPtrOutput() PipelineArtifactStoreEncryptionKeyPtrOutput

func (PipelineArtifactStoreEncryptionKeyOutput) ToPipelineArtifactStoreEncryptionKeyPtrOutputWithContext

func (o PipelineArtifactStoreEncryptionKeyOutput) ToPipelineArtifactStoreEncryptionKeyPtrOutputWithContext(ctx context.Context) PipelineArtifactStoreEncryptionKeyPtrOutput

func (PipelineArtifactStoreEncryptionKeyOutput) Type

The type of key; currently only `KMS` is supported

type PipelineArtifactStoreEncryptionKeyPtrInput

type PipelineArtifactStoreEncryptionKeyPtrInput interface {
	pulumi.Input

	ToPipelineArtifactStoreEncryptionKeyPtrOutput() PipelineArtifactStoreEncryptionKeyPtrOutput
	ToPipelineArtifactStoreEncryptionKeyPtrOutputWithContext(context.Context) PipelineArtifactStoreEncryptionKeyPtrOutput
}

PipelineArtifactStoreEncryptionKeyPtrInput is an input type that accepts PipelineArtifactStoreEncryptionKeyArgs, PipelineArtifactStoreEncryptionKeyPtr and PipelineArtifactStoreEncryptionKeyPtrOutput values. You can construct a concrete instance of `PipelineArtifactStoreEncryptionKeyPtrInput` via:

        PipelineArtifactStoreEncryptionKeyArgs{...}

or:

        nil

type PipelineArtifactStoreEncryptionKeyPtrOutput

type PipelineArtifactStoreEncryptionKeyPtrOutput struct{ *pulumi.OutputState }

func (PipelineArtifactStoreEncryptionKeyPtrOutput) Elem

func (PipelineArtifactStoreEncryptionKeyPtrOutput) ElementType

func (PipelineArtifactStoreEncryptionKeyPtrOutput) Id

The KMS key ARN or ID

func (PipelineArtifactStoreEncryptionKeyPtrOutput) ToPipelineArtifactStoreEncryptionKeyPtrOutput

func (o PipelineArtifactStoreEncryptionKeyPtrOutput) ToPipelineArtifactStoreEncryptionKeyPtrOutput() PipelineArtifactStoreEncryptionKeyPtrOutput

func (PipelineArtifactStoreEncryptionKeyPtrOutput) ToPipelineArtifactStoreEncryptionKeyPtrOutputWithContext

func (o PipelineArtifactStoreEncryptionKeyPtrOutput) ToPipelineArtifactStoreEncryptionKeyPtrOutputWithContext(ctx context.Context) PipelineArtifactStoreEncryptionKeyPtrOutput

func (PipelineArtifactStoreEncryptionKeyPtrOutput) Type

The type of key; currently only `KMS` is supported

type PipelineArtifactStoreInput

type PipelineArtifactStoreInput interface {
	pulumi.Input

	ToPipelineArtifactStoreOutput() PipelineArtifactStoreOutput
	ToPipelineArtifactStoreOutputWithContext(context.Context) PipelineArtifactStoreOutput
}

PipelineArtifactStoreInput is an input type that accepts PipelineArtifactStoreArgs and PipelineArtifactStoreOutput values. You can construct a concrete instance of `PipelineArtifactStoreInput` via:

PipelineArtifactStoreArgs{...}

type PipelineArtifactStoreOutput

type PipelineArtifactStoreOutput struct{ *pulumi.OutputState }

func (PipelineArtifactStoreOutput) ElementType

func (PipelineArtifactStoreOutput) EncryptionKey

The encryption key block AWS CodePipeline uses to encrypt the data in the artifact store, such as an AWS Key Management Service (AWS KMS) key. If you don't specify a key, AWS CodePipeline uses the default key for Amazon Simple Storage Service (Amazon S3). An `encryptionKey` block is documented below.

func (PipelineArtifactStoreOutput) Location

The location where AWS CodePipeline stores artifacts for a pipeline; currently only `S3` is supported.

func (PipelineArtifactStoreOutput) Region

The region where the artifact store is located. Required for a cross-region CodePipeline, do not provide for a single-region CodePipeline.

func (PipelineArtifactStoreOutput) ToPipelineArtifactStoreOutput

func (o PipelineArtifactStoreOutput) ToPipelineArtifactStoreOutput() PipelineArtifactStoreOutput

func (PipelineArtifactStoreOutput) ToPipelineArtifactStoreOutputWithContext

func (o PipelineArtifactStoreOutput) ToPipelineArtifactStoreOutputWithContext(ctx context.Context) PipelineArtifactStoreOutput

func (PipelineArtifactStoreOutput) Type

The type of the artifact store, such as Amazon S3

type PipelineInput

type PipelineInput interface {
	pulumi.Input

	ToPipelineOutput() PipelineOutput
	ToPipelineOutputWithContext(ctx context.Context) PipelineOutput
}

type PipelineMap

type PipelineMap map[string]PipelineInput

func (PipelineMap) ElementType

func (PipelineMap) ElementType() reflect.Type

func (PipelineMap) ToPipelineMapOutput

func (i PipelineMap) ToPipelineMapOutput() PipelineMapOutput

func (PipelineMap) ToPipelineMapOutputWithContext

func (i PipelineMap) ToPipelineMapOutputWithContext(ctx context.Context) PipelineMapOutput

type PipelineMapInput

type PipelineMapInput interface {
	pulumi.Input

	ToPipelineMapOutput() PipelineMapOutput
	ToPipelineMapOutputWithContext(context.Context) PipelineMapOutput
}

PipelineMapInput is an input type that accepts PipelineMap and PipelineMapOutput values. You can construct a concrete instance of `PipelineMapInput` via:

PipelineMap{ "key": PipelineArgs{...} }

type PipelineMapOutput

type PipelineMapOutput struct{ *pulumi.OutputState }

func (PipelineMapOutput) ElementType

func (PipelineMapOutput) ElementType() reflect.Type

func (PipelineMapOutput) MapIndex

func (PipelineMapOutput) ToPipelineMapOutput

func (o PipelineMapOutput) ToPipelineMapOutput() PipelineMapOutput

func (PipelineMapOutput) ToPipelineMapOutputWithContext

func (o PipelineMapOutput) ToPipelineMapOutputWithContext(ctx context.Context) PipelineMapOutput

type PipelineOutput

type PipelineOutput struct{ *pulumi.OutputState }

func (PipelineOutput) Arn

Codepipeline ARN.

func (PipelineOutput) ArtifactStores

One or more artifactStore blocks. Artifact stores are documented below.

func (PipelineOutput) ElementType

func (PipelineOutput) ElementType() reflect.Type

func (PipelineOutput) ExecutionMode

func (o PipelineOutput) ExecutionMode() pulumi.StringPtrOutput

The method that the pipeline will use to handle multiple executions. The default mode is `SUPERSEDED`. For value values, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PipelineDeclaration.html#CodePipeline-Type-PipelineDeclaration-executionMode).

func (PipelineOutput) Name

The name of the pipeline.

func (PipelineOutput) PipelineType

func (o PipelineOutput) PipelineType() pulumi.StringPtrOutput

Type of the pipeline. Possible values are: `V1` and `V2`. Default value is `V1`.

func (PipelineOutput) Region

func (o PipelineOutput) Region() pulumi.StringOutput

Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

func (PipelineOutput) RoleArn

func (o PipelineOutput) RoleArn() pulumi.StringOutput

A service role Amazon Resource Name (ARN) that grants AWS CodePipeline permission to make calls to AWS services on your behalf.

func (PipelineOutput) Stages

A stage block. Stages are documented below.

func (PipelineOutput) Tags

A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (PipelineOutput) TagsAll

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

func (PipelineOutput) ToPipelineOutput

func (o PipelineOutput) ToPipelineOutput() PipelineOutput

func (PipelineOutput) ToPipelineOutputWithContext

func (o PipelineOutput) ToPipelineOutputWithContext(ctx context.Context) PipelineOutput

func (PipelineOutput) TriggerAlls

A list of all triggers present on the pipeline, including default triggers added by AWS for `V2` pipelines which omit an explicit `trigger` definition.

func (PipelineOutput) Triggers

A trigger block. Valid only when `pipelineType` is `V2`. Triggers are documented below.

func (PipelineOutput) Variables

A pipeline-level variable block. Valid only when `pipelineType` is `V2`. Variable are documented below.

**Note:** `QUEUED` or `PARALLEL` mode can only be used with V2 pipelines.

type PipelineStage

type PipelineStage struct {
	// The action(s) to include in the stage. Defined as an `action` block below
	Actions []PipelineStageAction `pulumi:"actions"`
	// The method to use when a stage allows entry. For example, configuring this field for conditions will allow entry to the stage when the conditions are met.
	BeforeEntry *PipelineStageBeforeEntry `pulumi:"beforeEntry"`
	// The name of the stage.
	Name string `pulumi:"name"`
	// The method to use when a stage has not completed successfully. For example, configuring this field for rollback will roll back a failed stage automatically to the last successful pipeline execution in the stage.
	OnFailure *PipelineStageOnFailure `pulumi:"onFailure"`
	// The method to use when a stage has succeeded. For example, configuring this field for conditions will allow the stage to succeed when the conditions are met.
	OnSuccess *PipelineStageOnSuccess `pulumi:"onSuccess"`
}

type PipelineStageAction

type PipelineStageAction struct {
	// A category defines what kind of action can be taken in the stage, and constrains the provider type for the action. Possible values are `Approval`, `Build`, `Deploy`, `Invoke`, `Source` and `Test`.
	Category string `pulumi:"category"`
	// A map of the action declaration's configuration. Configurations options for action types and providers can be found in the [Pipeline Structure Reference](http://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements) and [Action Structure Reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference.html) documentation. Note: The `DetectChanges` parameter (optional, default value is true) in the `configuration` section causes CodePipeline to automatically start your pipeline upon new commits. Please refer to AWS Documentation for more details: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodestarConnectionSource.html#action-reference-CodestarConnectionSource-config.
	Configuration map[string]string `pulumi:"configuration"`
	// A list of artifact names to be worked on.
	InputArtifacts []string `pulumi:"inputArtifacts"`
	// The action declaration's name.
	Name string `pulumi:"name"`
	// The namespace all output variables will be accessed from.
	Namespace *string `pulumi:"namespace"`
	// A list of artifact names to output. Output artifact names must be unique within a pipeline.
	OutputArtifacts []string `pulumi:"outputArtifacts"`
	// The creator of the action being called. Possible values are `AWS`, `Custom` and `ThirdParty`.
	Owner string `pulumi:"owner"`
	// The provider of the service being called by the action. Valid providers are determined by the action category. Provider names are listed in the [Action Structure Reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference.html) documentation.
	Provider string `pulumi:"provider"`
	// The region in which to run the action.
	Region *string `pulumi:"region"`
	// The ARN of the IAM service role that will perform the declared action. This is assumed through the roleArn for the pipeline.
	RoleArn *string `pulumi:"roleArn"`
	// The order in which actions are run.
	RunOrder *int `pulumi:"runOrder"`
	// The action timeout for the rule.
	TimeoutInMinutes *int `pulumi:"timeoutInMinutes"`
	// A string that identifies the action type.
	Version string `pulumi:"version"`
}

type PipelineStageActionArgs

type PipelineStageActionArgs struct {
	// A category defines what kind of action can be taken in the stage, and constrains the provider type for the action. Possible values are `Approval`, `Build`, `Deploy`, `Invoke`, `Source` and `Test`.
	Category pulumi.StringInput `pulumi:"category"`
	// A map of the action declaration's configuration. Configurations options for action types and providers can be found in the [Pipeline Structure Reference](http://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements) and [Action Structure Reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference.html) documentation. Note: The `DetectChanges` parameter (optional, default value is true) in the `configuration` section causes CodePipeline to automatically start your pipeline upon new commits. Please refer to AWS Documentation for more details: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodestarConnectionSource.html#action-reference-CodestarConnectionSource-config.
	Configuration pulumi.StringMapInput `pulumi:"configuration"`
	// A list of artifact names to be worked on.
	InputArtifacts pulumi.StringArrayInput `pulumi:"inputArtifacts"`
	// The action declaration's name.
	Name pulumi.StringInput `pulumi:"name"`
	// The namespace all output variables will be accessed from.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
	// A list of artifact names to output. Output artifact names must be unique within a pipeline.
	OutputArtifacts pulumi.StringArrayInput `pulumi:"outputArtifacts"`
	// The creator of the action being called. Possible values are `AWS`, `Custom` and `ThirdParty`.
	Owner pulumi.StringInput `pulumi:"owner"`
	// The provider of the service being called by the action. Valid providers are determined by the action category. Provider names are listed in the [Action Structure Reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference.html) documentation.
	Provider pulumi.StringInput `pulumi:"provider"`
	// The region in which to run the action.
	Region pulumi.StringPtrInput `pulumi:"region"`
	// The ARN of the IAM service role that will perform the declared action. This is assumed through the roleArn for the pipeline.
	RoleArn pulumi.StringPtrInput `pulumi:"roleArn"`
	// The order in which actions are run.
	RunOrder pulumi.IntPtrInput `pulumi:"runOrder"`
	// The action timeout for the rule.
	TimeoutInMinutes pulumi.IntPtrInput `pulumi:"timeoutInMinutes"`
	// A string that identifies the action type.
	Version pulumi.StringInput `pulumi:"version"`
}

func (PipelineStageActionArgs) ElementType

func (PipelineStageActionArgs) ElementType() reflect.Type

func (PipelineStageActionArgs) ToPipelineStageActionOutput

func (i PipelineStageActionArgs) ToPipelineStageActionOutput() PipelineStageActionOutput

func (PipelineStageActionArgs) ToPipelineStageActionOutputWithContext

func (i PipelineStageActionArgs) ToPipelineStageActionOutputWithContext(ctx context.Context) PipelineStageActionOutput

type PipelineStageActionArray

type PipelineStageActionArray []PipelineStageActionInput

func (PipelineStageActionArray) ElementType

func (PipelineStageActionArray) ElementType() reflect.Type

func (PipelineStageActionArray) ToPipelineStageActionArrayOutput

func (i PipelineStageActionArray) ToPipelineStageActionArrayOutput() PipelineStageActionArrayOutput

func (PipelineStageActionArray) ToPipelineStageActionArrayOutputWithContext

func (i PipelineStageActionArray) ToPipelineStageActionArrayOutputWithContext(ctx context.Context) PipelineStageActionArrayOutput

type PipelineStageActionArrayInput

type PipelineStageActionArrayInput interface {
	pulumi.Input

	ToPipelineStageActionArrayOutput() PipelineStageActionArrayOutput
	ToPipelineStageActionArrayOutputWithContext(context.Context) PipelineStageActionArrayOutput
}

PipelineStageActionArrayInput is an input type that accepts PipelineStageActionArray and PipelineStageActionArrayOutput values. You can construct a concrete instance of `PipelineStageActionArrayInput` via:

PipelineStageActionArray{ PipelineStageActionArgs{...} }

type PipelineStageActionArrayOutput

type PipelineStageActionArrayOutput struct{ *pulumi.OutputState }

func (PipelineStageActionArrayOutput) ElementType

func (PipelineStageActionArrayOutput) Index

func (PipelineStageActionArrayOutput) ToPipelineStageActionArrayOutput

func (o PipelineStageActionArrayOutput) ToPipelineStageActionArrayOutput() PipelineStageActionArrayOutput

func (PipelineStageActionArrayOutput) ToPipelineStageActionArrayOutputWithContext

func (o PipelineStageActionArrayOutput) ToPipelineStageActionArrayOutputWithContext(ctx context.Context) PipelineStageActionArrayOutput

type PipelineStageActionInput

type PipelineStageActionInput interface {
	pulumi.Input

	ToPipelineStageActionOutput() PipelineStageActionOutput
	ToPipelineStageActionOutputWithContext(context.Context) PipelineStageActionOutput
}

PipelineStageActionInput is an input type that accepts PipelineStageActionArgs and PipelineStageActionOutput values. You can construct a concrete instance of `PipelineStageActionInput` via:

PipelineStageActionArgs{...}

type PipelineStageActionOutput

type PipelineStageActionOutput struct{ *pulumi.OutputState }

func (PipelineStageActionOutput) Category

A category defines what kind of action can be taken in the stage, and constrains the provider type for the action. Possible values are `Approval`, `Build`, `Deploy`, `Invoke`, `Source` and `Test`.

func (PipelineStageActionOutput) Configuration

A map of the action declaration's configuration. Configurations options for action types and providers can be found in the [Pipeline Structure Reference](http://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements) and [Action Structure Reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference.html) documentation. Note: The `DetectChanges` parameter (optional, default value is true) in the `configuration` section causes CodePipeline to automatically start your pipeline upon new commits. Please refer to AWS Documentation for more details: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodestarConnectionSource.html#action-reference-CodestarConnectionSource-config.

func (PipelineStageActionOutput) ElementType

func (PipelineStageActionOutput) ElementType() reflect.Type

func (PipelineStageActionOutput) InputArtifacts

A list of artifact names to be worked on.

func (PipelineStageActionOutput) Name

The action declaration's name.

func (PipelineStageActionOutput) Namespace

The namespace all output variables will be accessed from.

func (PipelineStageActionOutput) OutputArtifacts

A list of artifact names to output. Output artifact names must be unique within a pipeline.

func (PipelineStageActionOutput) Owner

The creator of the action being called. Possible values are `AWS`, `Custom` and `ThirdParty`.

func (PipelineStageActionOutput) Provider

The provider of the service being called by the action. Valid providers are determined by the action category. Provider names are listed in the [Action Structure Reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference.html) documentation.

func (PipelineStageActionOutput) Region

The region in which to run the action.

func (PipelineStageActionOutput) RoleArn

The ARN of the IAM service role that will perform the declared action. This is assumed through the roleArn for the pipeline.

func (PipelineStageActionOutput) RunOrder

The order in which actions are run.

func (PipelineStageActionOutput) TimeoutInMinutes

func (o PipelineStageActionOutput) TimeoutInMinutes() pulumi.IntPtrOutput

The action timeout for the rule.

func (PipelineStageActionOutput) ToPipelineStageActionOutput

func (o PipelineStageActionOutput) ToPipelineStageActionOutput() PipelineStageActionOutput

func (PipelineStageActionOutput) ToPipelineStageActionOutputWithContext

func (o PipelineStageActionOutput) ToPipelineStageActionOutputWithContext(ctx context.Context) PipelineStageActionOutput

func (PipelineStageActionOutput) Version

A string that identifies the action type.

type PipelineStageArgs

type PipelineStageArgs struct {
	// The action(s) to include in the stage. Defined as an `action` block below
	Actions PipelineStageActionArrayInput `pulumi:"actions"`
	// The method to use when a stage allows entry. For example, configuring this field for conditions will allow entry to the stage when the conditions are met.
	BeforeEntry PipelineStageBeforeEntryPtrInput `pulumi:"beforeEntry"`
	// The name of the stage.
	Name pulumi.StringInput `pulumi:"name"`
	// The method to use when a stage has not completed successfully. For example, configuring this field for rollback will roll back a failed stage automatically to the last successful pipeline execution in the stage.
	OnFailure PipelineStageOnFailurePtrInput `pulumi:"onFailure"`
	// The method to use when a stage has succeeded. For example, configuring this field for conditions will allow the stage to succeed when the conditions are met.
	OnSuccess PipelineStageOnSuccessPtrInput `pulumi:"onSuccess"`
}

func (PipelineStageArgs) ElementType

func (PipelineStageArgs) ElementType() reflect.Type

func (PipelineStageArgs) ToPipelineStageOutput

func (i PipelineStageArgs) ToPipelineStageOutput() PipelineStageOutput

func (PipelineStageArgs) ToPipelineStageOutputWithContext

func (i PipelineStageArgs) ToPipelineStageOutputWithContext(ctx context.Context) PipelineStageOutput

type PipelineStageArray

type PipelineStageArray []PipelineStageInput

func (PipelineStageArray) ElementType

func (PipelineStageArray) ElementType() reflect.Type

func (PipelineStageArray) ToPipelineStageArrayOutput

func (i PipelineStageArray) ToPipelineStageArrayOutput() PipelineStageArrayOutput

func (PipelineStageArray) ToPipelineStageArrayOutputWithContext

func (i PipelineStageArray) ToPipelineStageArrayOutputWithContext(ctx context.Context) PipelineStageArrayOutput

type PipelineStageArrayInput

type PipelineStageArrayInput interface {
	pulumi.Input

	ToPipelineStageArrayOutput() PipelineStageArrayOutput
	ToPipelineStageArrayOutputWithContext(context.Context) PipelineStageArrayOutput
}

PipelineStageArrayInput is an input type that accepts PipelineStageArray and PipelineStageArrayOutput values. You can construct a concrete instance of `PipelineStageArrayInput` via:

PipelineStageArray{ PipelineStageArgs{...} }

type PipelineStageArrayOutput

type PipelineStageArrayOutput struct{ *pulumi.OutputState }

func (PipelineStageArrayOutput) ElementType

func (PipelineStageArrayOutput) ElementType() reflect.Type

func (PipelineStageArrayOutput) Index

func (PipelineStageArrayOutput) ToPipelineStageArrayOutput

func (o PipelineStageArrayOutput) ToPipelineStageArrayOutput() PipelineStageArrayOutput

func (PipelineStageArrayOutput) ToPipelineStageArrayOutputWithContext

func (o PipelineStageArrayOutput) ToPipelineStageArrayOutputWithContext(ctx context.Context) PipelineStageArrayOutput

type PipelineStageBeforeEntry

type PipelineStageBeforeEntry struct {
	// The conditions that are configured as entry condition. Defined as a `condition` block below.
	Condition PipelineStageBeforeEntryCondition `pulumi:"condition"`
}

type PipelineStageBeforeEntryArgs

type PipelineStageBeforeEntryArgs struct {
	// The conditions that are configured as entry condition. Defined as a `condition` block below.
	Condition PipelineStageBeforeEntryConditionInput `pulumi:"condition"`
}

func (PipelineStageBeforeEntryArgs) ElementType

func (PipelineStageBeforeEntryArgs) ToPipelineStageBeforeEntryOutput

func (i PipelineStageBeforeEntryArgs) ToPipelineStageBeforeEntryOutput() PipelineStageBeforeEntryOutput

func (PipelineStageBeforeEntryArgs) ToPipelineStageBeforeEntryOutputWithContext

func (i PipelineStageBeforeEntryArgs) ToPipelineStageBeforeEntryOutputWithContext(ctx context.Context) PipelineStageBeforeEntryOutput

func (PipelineStageBeforeEntryArgs) ToPipelineStageBeforeEntryPtrOutput

func (i PipelineStageBeforeEntryArgs) ToPipelineStageBeforeEntryPtrOutput() PipelineStageBeforeEntryPtrOutput

func (PipelineStageBeforeEntryArgs) ToPipelineStageBeforeEntryPtrOutputWithContext

func (i PipelineStageBeforeEntryArgs) ToPipelineStageBeforeEntryPtrOutputWithContext(ctx context.Context) PipelineStageBeforeEntryPtrOutput

type PipelineStageBeforeEntryCondition

type PipelineStageBeforeEntryCondition struct {
	// The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.
	Result *string `pulumi:"result"`
	// The rules that make up the condition. Defined as a `rule` block below.
	Rules []PipelineStageBeforeEntryConditionRule `pulumi:"rules"`
}

type PipelineStageBeforeEntryConditionArgs

type PipelineStageBeforeEntryConditionArgs struct {
	// The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.
	Result pulumi.StringPtrInput `pulumi:"result"`
	// The rules that make up the condition. Defined as a `rule` block below.
	Rules PipelineStageBeforeEntryConditionRuleArrayInput `pulumi:"rules"`
}

func (PipelineStageBeforeEntryConditionArgs) ElementType

func (PipelineStageBeforeEntryConditionArgs) ToPipelineStageBeforeEntryConditionOutput

func (i PipelineStageBeforeEntryConditionArgs) ToPipelineStageBeforeEntryConditionOutput() PipelineStageBeforeEntryConditionOutput

func (PipelineStageBeforeEntryConditionArgs) ToPipelineStageBeforeEntryConditionOutputWithContext

func (i PipelineStageBeforeEntryConditionArgs) ToPipelineStageBeforeEntryConditionOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionOutput

func (PipelineStageBeforeEntryConditionArgs) ToPipelineStageBeforeEntryConditionPtrOutput

func (i PipelineStageBeforeEntryConditionArgs) ToPipelineStageBeforeEntryConditionPtrOutput() PipelineStageBeforeEntryConditionPtrOutput

func (PipelineStageBeforeEntryConditionArgs) ToPipelineStageBeforeEntryConditionPtrOutputWithContext

func (i PipelineStageBeforeEntryConditionArgs) ToPipelineStageBeforeEntryConditionPtrOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionPtrOutput

type PipelineStageBeforeEntryConditionInput

type PipelineStageBeforeEntryConditionInput interface {
	pulumi.Input

	ToPipelineStageBeforeEntryConditionOutput() PipelineStageBeforeEntryConditionOutput
	ToPipelineStageBeforeEntryConditionOutputWithContext(context.Context) PipelineStageBeforeEntryConditionOutput
}

PipelineStageBeforeEntryConditionInput is an input type that accepts PipelineStageBeforeEntryConditionArgs and PipelineStageBeforeEntryConditionOutput values. You can construct a concrete instance of `PipelineStageBeforeEntryConditionInput` via:

PipelineStageBeforeEntryConditionArgs{...}

type PipelineStageBeforeEntryConditionOutput

type PipelineStageBeforeEntryConditionOutput struct{ *pulumi.OutputState }

func (PipelineStageBeforeEntryConditionOutput) ElementType

func (PipelineStageBeforeEntryConditionOutput) Result

The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.

func (PipelineStageBeforeEntryConditionOutput) Rules

The rules that make up the condition. Defined as a `rule` block below.

func (PipelineStageBeforeEntryConditionOutput) ToPipelineStageBeforeEntryConditionOutput

func (o PipelineStageBeforeEntryConditionOutput) ToPipelineStageBeforeEntryConditionOutput() PipelineStageBeforeEntryConditionOutput

func (PipelineStageBeforeEntryConditionOutput) ToPipelineStageBeforeEntryConditionOutputWithContext

func (o PipelineStageBeforeEntryConditionOutput) ToPipelineStageBeforeEntryConditionOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionOutput

func (PipelineStageBeforeEntryConditionOutput) ToPipelineStageBeforeEntryConditionPtrOutput

func (o PipelineStageBeforeEntryConditionOutput) ToPipelineStageBeforeEntryConditionPtrOutput() PipelineStageBeforeEntryConditionPtrOutput

func (PipelineStageBeforeEntryConditionOutput) ToPipelineStageBeforeEntryConditionPtrOutputWithContext

func (o PipelineStageBeforeEntryConditionOutput) ToPipelineStageBeforeEntryConditionPtrOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionPtrOutput

type PipelineStageBeforeEntryConditionPtrInput

type PipelineStageBeforeEntryConditionPtrInput interface {
	pulumi.Input

	ToPipelineStageBeforeEntryConditionPtrOutput() PipelineStageBeforeEntryConditionPtrOutput
	ToPipelineStageBeforeEntryConditionPtrOutputWithContext(context.Context) PipelineStageBeforeEntryConditionPtrOutput
}

PipelineStageBeforeEntryConditionPtrInput is an input type that accepts PipelineStageBeforeEntryConditionArgs, PipelineStageBeforeEntryConditionPtr and PipelineStageBeforeEntryConditionPtrOutput values. You can construct a concrete instance of `PipelineStageBeforeEntryConditionPtrInput` via:

        PipelineStageBeforeEntryConditionArgs{...}

or:

        nil

type PipelineStageBeforeEntryConditionPtrOutput

type PipelineStageBeforeEntryConditionPtrOutput struct{ *pulumi.OutputState }

func (PipelineStageBeforeEntryConditionPtrOutput) Elem

func (PipelineStageBeforeEntryConditionPtrOutput) ElementType

func (PipelineStageBeforeEntryConditionPtrOutput) Result

The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.

func (PipelineStageBeforeEntryConditionPtrOutput) Rules

The rules that make up the condition. Defined as a `rule` block below.

func (PipelineStageBeforeEntryConditionPtrOutput) ToPipelineStageBeforeEntryConditionPtrOutput

func (o PipelineStageBeforeEntryConditionPtrOutput) ToPipelineStageBeforeEntryConditionPtrOutput() PipelineStageBeforeEntryConditionPtrOutput

func (PipelineStageBeforeEntryConditionPtrOutput) ToPipelineStageBeforeEntryConditionPtrOutputWithContext

func (o PipelineStageBeforeEntryConditionPtrOutput) ToPipelineStageBeforeEntryConditionPtrOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionPtrOutput

type PipelineStageBeforeEntryConditionRule

type PipelineStageBeforeEntryConditionRule struct {
	// The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats.
	Commands []string `pulumi:"commands"`
	// The action configuration fields for the rule. Configurations options for rule types and providers can be found in the [Rule structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Configuration map[string]string `pulumi:"configuration"`
	// The list of the input artifacts fields for the rule, such as specifying an input file for the rule.
	InputArtifacts []string `pulumi:"inputArtifacts"`
	// The name of the rule that is created for the condition, such as `VariableCheck`.
	Name string `pulumi:"name"`
	// The Region for the condition associated with the rule.
	Region *string `pulumi:"region"`
	// The pipeline role ARN associated with the rule.
	RoleArn *string `pulumi:"roleArn"`
	// The ID for the rule type, which is made up of the combined values for `category`, `owner`, `provider`, and `version`. Defined as an `ruleTypeId` block below.
	RuleTypeId PipelineStageBeforeEntryConditionRuleRuleTypeId `pulumi:"ruleTypeId"`
	// The action timeout for the rule.
	TimeoutInMinutes *int `pulumi:"timeoutInMinutes"`
}

type PipelineStageBeforeEntryConditionRuleArgs

type PipelineStageBeforeEntryConditionRuleArgs struct {
	// The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats.
	Commands pulumi.StringArrayInput `pulumi:"commands"`
	// The action configuration fields for the rule. Configurations options for rule types and providers can be found in the [Rule structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Configuration pulumi.StringMapInput `pulumi:"configuration"`
	// The list of the input artifacts fields for the rule, such as specifying an input file for the rule.
	InputArtifacts pulumi.StringArrayInput `pulumi:"inputArtifacts"`
	// The name of the rule that is created for the condition, such as `VariableCheck`.
	Name pulumi.StringInput `pulumi:"name"`
	// The Region for the condition associated with the rule.
	Region pulumi.StringPtrInput `pulumi:"region"`
	// The pipeline role ARN associated with the rule.
	RoleArn pulumi.StringPtrInput `pulumi:"roleArn"`
	// The ID for the rule type, which is made up of the combined values for `category`, `owner`, `provider`, and `version`. Defined as an `ruleTypeId` block below.
	RuleTypeId PipelineStageBeforeEntryConditionRuleRuleTypeIdInput `pulumi:"ruleTypeId"`
	// The action timeout for the rule.
	TimeoutInMinutes pulumi.IntPtrInput `pulumi:"timeoutInMinutes"`
}

func (PipelineStageBeforeEntryConditionRuleArgs) ElementType

func (PipelineStageBeforeEntryConditionRuleArgs) ToPipelineStageBeforeEntryConditionRuleOutput

func (i PipelineStageBeforeEntryConditionRuleArgs) ToPipelineStageBeforeEntryConditionRuleOutput() PipelineStageBeforeEntryConditionRuleOutput

func (PipelineStageBeforeEntryConditionRuleArgs) ToPipelineStageBeforeEntryConditionRuleOutputWithContext

func (i PipelineStageBeforeEntryConditionRuleArgs) ToPipelineStageBeforeEntryConditionRuleOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionRuleOutput

type PipelineStageBeforeEntryConditionRuleArray

type PipelineStageBeforeEntryConditionRuleArray []PipelineStageBeforeEntryConditionRuleInput

func (PipelineStageBeforeEntryConditionRuleArray) ElementType

func (PipelineStageBeforeEntryConditionRuleArray) ToPipelineStageBeforeEntryConditionRuleArrayOutput

func (i PipelineStageBeforeEntryConditionRuleArray) ToPipelineStageBeforeEntryConditionRuleArrayOutput() PipelineStageBeforeEntryConditionRuleArrayOutput

func (PipelineStageBeforeEntryConditionRuleArray) ToPipelineStageBeforeEntryConditionRuleArrayOutputWithContext

func (i PipelineStageBeforeEntryConditionRuleArray) ToPipelineStageBeforeEntryConditionRuleArrayOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionRuleArrayOutput

type PipelineStageBeforeEntryConditionRuleArrayInput

type PipelineStageBeforeEntryConditionRuleArrayInput interface {
	pulumi.Input

	ToPipelineStageBeforeEntryConditionRuleArrayOutput() PipelineStageBeforeEntryConditionRuleArrayOutput
	ToPipelineStageBeforeEntryConditionRuleArrayOutputWithContext(context.Context) PipelineStageBeforeEntryConditionRuleArrayOutput
}

PipelineStageBeforeEntryConditionRuleArrayInput is an input type that accepts PipelineStageBeforeEntryConditionRuleArray and PipelineStageBeforeEntryConditionRuleArrayOutput values. You can construct a concrete instance of `PipelineStageBeforeEntryConditionRuleArrayInput` via:

PipelineStageBeforeEntryConditionRuleArray{ PipelineStageBeforeEntryConditionRuleArgs{...} }

type PipelineStageBeforeEntryConditionRuleArrayOutput

type PipelineStageBeforeEntryConditionRuleArrayOutput struct{ *pulumi.OutputState }

func (PipelineStageBeforeEntryConditionRuleArrayOutput) ElementType

func (PipelineStageBeforeEntryConditionRuleArrayOutput) Index

func (PipelineStageBeforeEntryConditionRuleArrayOutput) ToPipelineStageBeforeEntryConditionRuleArrayOutput

func (o PipelineStageBeforeEntryConditionRuleArrayOutput) ToPipelineStageBeforeEntryConditionRuleArrayOutput() PipelineStageBeforeEntryConditionRuleArrayOutput

func (PipelineStageBeforeEntryConditionRuleArrayOutput) ToPipelineStageBeforeEntryConditionRuleArrayOutputWithContext

func (o PipelineStageBeforeEntryConditionRuleArrayOutput) ToPipelineStageBeforeEntryConditionRuleArrayOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionRuleArrayOutput

type PipelineStageBeforeEntryConditionRuleInput

type PipelineStageBeforeEntryConditionRuleInput interface {
	pulumi.Input

	ToPipelineStageBeforeEntryConditionRuleOutput() PipelineStageBeforeEntryConditionRuleOutput
	ToPipelineStageBeforeEntryConditionRuleOutputWithContext(context.Context) PipelineStageBeforeEntryConditionRuleOutput
}

PipelineStageBeforeEntryConditionRuleInput is an input type that accepts PipelineStageBeforeEntryConditionRuleArgs and PipelineStageBeforeEntryConditionRuleOutput values. You can construct a concrete instance of `PipelineStageBeforeEntryConditionRuleInput` via:

PipelineStageBeforeEntryConditionRuleArgs{...}

type PipelineStageBeforeEntryConditionRuleOutput

type PipelineStageBeforeEntryConditionRuleOutput struct{ *pulumi.OutputState }

func (PipelineStageBeforeEntryConditionRuleOutput) Commands

The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats.

func (PipelineStageBeforeEntryConditionRuleOutput) Configuration

The action configuration fields for the rule. Configurations options for rule types and providers can be found in the [Rule structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).

func (PipelineStageBeforeEntryConditionRuleOutput) ElementType

func (PipelineStageBeforeEntryConditionRuleOutput) InputArtifacts

The list of the input artifacts fields for the rule, such as specifying an input file for the rule.

func (PipelineStageBeforeEntryConditionRuleOutput) Name

The name of the rule that is created for the condition, such as `VariableCheck`.

func (PipelineStageBeforeEntryConditionRuleOutput) Region

The Region for the condition associated with the rule.

func (PipelineStageBeforeEntryConditionRuleOutput) RoleArn

The pipeline role ARN associated with the rule.

func (PipelineStageBeforeEntryConditionRuleOutput) RuleTypeId

The ID for the rule type, which is made up of the combined values for `category`, `owner`, `provider`, and `version`. Defined as an `ruleTypeId` block below.

func (PipelineStageBeforeEntryConditionRuleOutput) TimeoutInMinutes

The action timeout for the rule.

func (PipelineStageBeforeEntryConditionRuleOutput) ToPipelineStageBeforeEntryConditionRuleOutput

func (o PipelineStageBeforeEntryConditionRuleOutput) ToPipelineStageBeforeEntryConditionRuleOutput() PipelineStageBeforeEntryConditionRuleOutput

func (PipelineStageBeforeEntryConditionRuleOutput) ToPipelineStageBeforeEntryConditionRuleOutputWithContext

func (o PipelineStageBeforeEntryConditionRuleOutput) ToPipelineStageBeforeEntryConditionRuleOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionRuleOutput

type PipelineStageBeforeEntryConditionRuleRuleTypeId

type PipelineStageBeforeEntryConditionRuleRuleTypeId struct {
	// A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule. The valid category is `Rule`.
	Category string `pulumi:"category"`
	// The creator of the rule being called. The valid value for the Owner field in the rule category is `AWS`.
	Owner *string `pulumi:"owner"`
	// The rule provider, such as the DeploymentWindow rule. For a list of rule provider names, see the rules listed in the [AWS CodePipeline rule reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Provider string `pulumi:"provider"`
	// A string that describes the rule version.
	Version *string `pulumi:"version"`
}

type PipelineStageBeforeEntryConditionRuleRuleTypeIdArgs

type PipelineStageBeforeEntryConditionRuleRuleTypeIdArgs struct {
	// A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule. The valid category is `Rule`.
	Category pulumi.StringInput `pulumi:"category"`
	// The creator of the rule being called. The valid value for the Owner field in the rule category is `AWS`.
	Owner pulumi.StringPtrInput `pulumi:"owner"`
	// The rule provider, such as the DeploymentWindow rule. For a list of rule provider names, see the rules listed in the [AWS CodePipeline rule reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Provider pulumi.StringInput `pulumi:"provider"`
	// A string that describes the rule version.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdArgs) ElementType

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdArgs) ToPipelineStageBeforeEntryConditionRuleRuleTypeIdOutput

func (i PipelineStageBeforeEntryConditionRuleRuleTypeIdArgs) ToPipelineStageBeforeEntryConditionRuleRuleTypeIdOutput() PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdArgs) ToPipelineStageBeforeEntryConditionRuleRuleTypeIdOutputWithContext

func (i PipelineStageBeforeEntryConditionRuleRuleTypeIdArgs) ToPipelineStageBeforeEntryConditionRuleRuleTypeIdOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput

type PipelineStageBeforeEntryConditionRuleRuleTypeIdInput

type PipelineStageBeforeEntryConditionRuleRuleTypeIdInput interface {
	pulumi.Input

	ToPipelineStageBeforeEntryConditionRuleRuleTypeIdOutput() PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput
	ToPipelineStageBeforeEntryConditionRuleRuleTypeIdOutputWithContext(context.Context) PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput
}

PipelineStageBeforeEntryConditionRuleRuleTypeIdInput is an input type that accepts PipelineStageBeforeEntryConditionRuleRuleTypeIdArgs and PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput values. You can construct a concrete instance of `PipelineStageBeforeEntryConditionRuleRuleTypeIdInput` via:

PipelineStageBeforeEntryConditionRuleRuleTypeIdArgs{...}

type PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput

type PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput struct{ *pulumi.OutputState }

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput) Category

A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule. The valid category is `Rule`.

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput) ElementType

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput) Owner

The creator of the rule being called. The valid value for the Owner field in the rule category is `AWS`.

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput) Provider

The rule provider, such as the DeploymentWindow rule. For a list of rule provider names, see the rules listed in the [AWS CodePipeline rule reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput) ToPipelineStageBeforeEntryConditionRuleRuleTypeIdOutput

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput) ToPipelineStageBeforeEntryConditionRuleRuleTypeIdOutputWithContext

func (o PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput) ToPipelineStageBeforeEntryConditionRuleRuleTypeIdOutputWithContext(ctx context.Context) PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput

func (PipelineStageBeforeEntryConditionRuleRuleTypeIdOutput) Version

A string that describes the rule version.

type PipelineStageBeforeEntryInput

type PipelineStageBeforeEntryInput interface {
	pulumi.Input

	ToPipelineStageBeforeEntryOutput() PipelineStageBeforeEntryOutput
	ToPipelineStageBeforeEntryOutputWithContext(context.Context) PipelineStageBeforeEntryOutput
}

PipelineStageBeforeEntryInput is an input type that accepts PipelineStageBeforeEntryArgs and PipelineStageBeforeEntryOutput values. You can construct a concrete instance of `PipelineStageBeforeEntryInput` via:

PipelineStageBeforeEntryArgs{...}

type PipelineStageBeforeEntryOutput

type PipelineStageBeforeEntryOutput struct{ *pulumi.OutputState }

func (PipelineStageBeforeEntryOutput) Condition

The conditions that are configured as entry condition. Defined as a `condition` block below.

func (PipelineStageBeforeEntryOutput) ElementType

func (PipelineStageBeforeEntryOutput) ToPipelineStageBeforeEntryOutput

func (o PipelineStageBeforeEntryOutput) ToPipelineStageBeforeEntryOutput() PipelineStageBeforeEntryOutput

func (PipelineStageBeforeEntryOutput) ToPipelineStageBeforeEntryOutputWithContext

func (o PipelineStageBeforeEntryOutput) ToPipelineStageBeforeEntryOutputWithContext(ctx context.Context) PipelineStageBeforeEntryOutput

func (PipelineStageBeforeEntryOutput) ToPipelineStageBeforeEntryPtrOutput

func (o PipelineStageBeforeEntryOutput) ToPipelineStageBeforeEntryPtrOutput() PipelineStageBeforeEntryPtrOutput

func (PipelineStageBeforeEntryOutput) ToPipelineStageBeforeEntryPtrOutputWithContext

func (o PipelineStageBeforeEntryOutput) ToPipelineStageBeforeEntryPtrOutputWithContext(ctx context.Context) PipelineStageBeforeEntryPtrOutput

type PipelineStageBeforeEntryPtrInput

type PipelineStageBeforeEntryPtrInput interface {
	pulumi.Input

	ToPipelineStageBeforeEntryPtrOutput() PipelineStageBeforeEntryPtrOutput
	ToPipelineStageBeforeEntryPtrOutputWithContext(context.Context) PipelineStageBeforeEntryPtrOutput
}

PipelineStageBeforeEntryPtrInput is an input type that accepts PipelineStageBeforeEntryArgs, PipelineStageBeforeEntryPtr and PipelineStageBeforeEntryPtrOutput values. You can construct a concrete instance of `PipelineStageBeforeEntryPtrInput` via:

        PipelineStageBeforeEntryArgs{...}

or:

        nil

type PipelineStageBeforeEntryPtrOutput

type PipelineStageBeforeEntryPtrOutput struct{ *pulumi.OutputState }

func (PipelineStageBeforeEntryPtrOutput) Condition

The conditions that are configured as entry condition. Defined as a `condition` block below.

func (PipelineStageBeforeEntryPtrOutput) Elem

func (PipelineStageBeforeEntryPtrOutput) ElementType

func (PipelineStageBeforeEntryPtrOutput) ToPipelineStageBeforeEntryPtrOutput

func (o PipelineStageBeforeEntryPtrOutput) ToPipelineStageBeforeEntryPtrOutput() PipelineStageBeforeEntryPtrOutput

func (PipelineStageBeforeEntryPtrOutput) ToPipelineStageBeforeEntryPtrOutputWithContext

func (o PipelineStageBeforeEntryPtrOutput) ToPipelineStageBeforeEntryPtrOutputWithContext(ctx context.Context) PipelineStageBeforeEntryPtrOutput

type PipelineStageInput

type PipelineStageInput interface {
	pulumi.Input

	ToPipelineStageOutput() PipelineStageOutput
	ToPipelineStageOutputWithContext(context.Context) PipelineStageOutput
}

PipelineStageInput is an input type that accepts PipelineStageArgs and PipelineStageOutput values. You can construct a concrete instance of `PipelineStageInput` via:

PipelineStageArgs{...}

type PipelineStageOnFailure

type PipelineStageOnFailure struct {
	// The conditions that are failure conditions. Defined as a `condition` block below.
	Condition *PipelineStageOnFailureCondition `pulumi:"condition"`
	// The conditions that are configured as failure conditions. Possible values are `ROLLBACK`,  `FAIL`, `RETRY` and `SKIP`.
	Result *string `pulumi:"result"`
	// The retry configuration specifies automatic retry for a failed stage, along with the configured retry mode. Defined as a `retryConfiguration` block below.
	RetryConfiguration *PipelineStageOnFailureRetryConfiguration `pulumi:"retryConfiguration"`
}

type PipelineStageOnFailureArgs

type PipelineStageOnFailureArgs struct {
	// The conditions that are failure conditions. Defined as a `condition` block below.
	Condition PipelineStageOnFailureConditionPtrInput `pulumi:"condition"`
	// The conditions that are configured as failure conditions. Possible values are `ROLLBACK`,  `FAIL`, `RETRY` and `SKIP`.
	Result pulumi.StringPtrInput `pulumi:"result"`
	// The retry configuration specifies automatic retry for a failed stage, along with the configured retry mode. Defined as a `retryConfiguration` block below.
	RetryConfiguration PipelineStageOnFailureRetryConfigurationPtrInput `pulumi:"retryConfiguration"`
}

func (PipelineStageOnFailureArgs) ElementType

func (PipelineStageOnFailureArgs) ElementType() reflect.Type

func (PipelineStageOnFailureArgs) ToPipelineStageOnFailureOutput

func (i PipelineStageOnFailureArgs) ToPipelineStageOnFailureOutput() PipelineStageOnFailureOutput

func (PipelineStageOnFailureArgs) ToPipelineStageOnFailureOutputWithContext

func (i PipelineStageOnFailureArgs) ToPipelineStageOnFailureOutputWithContext(ctx context.Context) PipelineStageOnFailureOutput

func (PipelineStageOnFailureArgs) ToPipelineStageOnFailurePtrOutput

func (i PipelineStageOnFailureArgs) ToPipelineStageOnFailurePtrOutput() PipelineStageOnFailurePtrOutput

func (PipelineStageOnFailureArgs) ToPipelineStageOnFailurePtrOutputWithContext

func (i PipelineStageOnFailureArgs) ToPipelineStageOnFailurePtrOutputWithContext(ctx context.Context) PipelineStageOnFailurePtrOutput

type PipelineStageOnFailureCondition

type PipelineStageOnFailureCondition struct {
	// The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.
	Result *string `pulumi:"result"`
	// The rules that make up the condition. Defined as a `rule` block below.
	Rules []PipelineStageOnFailureConditionRule `pulumi:"rules"`
}

type PipelineStageOnFailureConditionArgs

type PipelineStageOnFailureConditionArgs struct {
	// The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.
	Result pulumi.StringPtrInput `pulumi:"result"`
	// The rules that make up the condition. Defined as a `rule` block below.
	Rules PipelineStageOnFailureConditionRuleArrayInput `pulumi:"rules"`
}

func (PipelineStageOnFailureConditionArgs) ElementType

func (PipelineStageOnFailureConditionArgs) ToPipelineStageOnFailureConditionOutput

func (i PipelineStageOnFailureConditionArgs) ToPipelineStageOnFailureConditionOutput() PipelineStageOnFailureConditionOutput

func (PipelineStageOnFailureConditionArgs) ToPipelineStageOnFailureConditionOutputWithContext

func (i PipelineStageOnFailureConditionArgs) ToPipelineStageOnFailureConditionOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionOutput

func (PipelineStageOnFailureConditionArgs) ToPipelineStageOnFailureConditionPtrOutput

func (i PipelineStageOnFailureConditionArgs) ToPipelineStageOnFailureConditionPtrOutput() PipelineStageOnFailureConditionPtrOutput

func (PipelineStageOnFailureConditionArgs) ToPipelineStageOnFailureConditionPtrOutputWithContext

func (i PipelineStageOnFailureConditionArgs) ToPipelineStageOnFailureConditionPtrOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionPtrOutput

type PipelineStageOnFailureConditionInput

type PipelineStageOnFailureConditionInput interface {
	pulumi.Input

	ToPipelineStageOnFailureConditionOutput() PipelineStageOnFailureConditionOutput
	ToPipelineStageOnFailureConditionOutputWithContext(context.Context) PipelineStageOnFailureConditionOutput
}

PipelineStageOnFailureConditionInput is an input type that accepts PipelineStageOnFailureConditionArgs and PipelineStageOnFailureConditionOutput values. You can construct a concrete instance of `PipelineStageOnFailureConditionInput` via:

PipelineStageOnFailureConditionArgs{...}

type PipelineStageOnFailureConditionOutput

type PipelineStageOnFailureConditionOutput struct{ *pulumi.OutputState }

func (PipelineStageOnFailureConditionOutput) ElementType

func (PipelineStageOnFailureConditionOutput) Result

The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.

func (PipelineStageOnFailureConditionOutput) Rules

The rules that make up the condition. Defined as a `rule` block below.

func (PipelineStageOnFailureConditionOutput) ToPipelineStageOnFailureConditionOutput

func (o PipelineStageOnFailureConditionOutput) ToPipelineStageOnFailureConditionOutput() PipelineStageOnFailureConditionOutput

func (PipelineStageOnFailureConditionOutput) ToPipelineStageOnFailureConditionOutputWithContext

func (o PipelineStageOnFailureConditionOutput) ToPipelineStageOnFailureConditionOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionOutput

func (PipelineStageOnFailureConditionOutput) ToPipelineStageOnFailureConditionPtrOutput

func (o PipelineStageOnFailureConditionOutput) ToPipelineStageOnFailureConditionPtrOutput() PipelineStageOnFailureConditionPtrOutput

func (PipelineStageOnFailureConditionOutput) ToPipelineStageOnFailureConditionPtrOutputWithContext

func (o PipelineStageOnFailureConditionOutput) ToPipelineStageOnFailureConditionPtrOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionPtrOutput

type PipelineStageOnFailureConditionPtrInput

type PipelineStageOnFailureConditionPtrInput interface {
	pulumi.Input

	ToPipelineStageOnFailureConditionPtrOutput() PipelineStageOnFailureConditionPtrOutput
	ToPipelineStageOnFailureConditionPtrOutputWithContext(context.Context) PipelineStageOnFailureConditionPtrOutput
}

PipelineStageOnFailureConditionPtrInput is an input type that accepts PipelineStageOnFailureConditionArgs, PipelineStageOnFailureConditionPtr and PipelineStageOnFailureConditionPtrOutput values. You can construct a concrete instance of `PipelineStageOnFailureConditionPtrInput` via:

        PipelineStageOnFailureConditionArgs{...}

or:

        nil

type PipelineStageOnFailureConditionPtrOutput

type PipelineStageOnFailureConditionPtrOutput struct{ *pulumi.OutputState }

func (PipelineStageOnFailureConditionPtrOutput) Elem

func (PipelineStageOnFailureConditionPtrOutput) ElementType

func (PipelineStageOnFailureConditionPtrOutput) Result

The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.

func (PipelineStageOnFailureConditionPtrOutput) Rules

The rules that make up the condition. Defined as a `rule` block below.

func (PipelineStageOnFailureConditionPtrOutput) ToPipelineStageOnFailureConditionPtrOutput

func (o PipelineStageOnFailureConditionPtrOutput) ToPipelineStageOnFailureConditionPtrOutput() PipelineStageOnFailureConditionPtrOutput

func (PipelineStageOnFailureConditionPtrOutput) ToPipelineStageOnFailureConditionPtrOutputWithContext

func (o PipelineStageOnFailureConditionPtrOutput) ToPipelineStageOnFailureConditionPtrOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionPtrOutput

type PipelineStageOnFailureConditionRule

type PipelineStageOnFailureConditionRule struct {
	// The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats.
	Commands []string `pulumi:"commands"`
	// The action configuration fields for the rule. Configurations options for rule types and providers can be found in the [Rule structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Configuration map[string]string `pulumi:"configuration"`
	// The list of the input artifacts fields for the rule, such as specifying an input file for the rule.
	InputArtifacts []string `pulumi:"inputArtifacts"`
	// The name of the rule that is created for the condition, such as `VariableCheck`.
	Name string `pulumi:"name"`
	// The Region for the condition associated with the rule.
	Region *string `pulumi:"region"`
	// The pipeline role ARN associated with the rule.
	RoleArn *string `pulumi:"roleArn"`
	// The ID for the rule type, which is made up of the combined values for `category`, `owner`, `provider`, and `version`. Defined as an `ruleTypeId` block below.
	RuleTypeId PipelineStageOnFailureConditionRuleRuleTypeId `pulumi:"ruleTypeId"`
	// The action timeout for the rule.
	TimeoutInMinutes *int `pulumi:"timeoutInMinutes"`
}

type PipelineStageOnFailureConditionRuleArgs

type PipelineStageOnFailureConditionRuleArgs struct {
	// The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats.
	Commands pulumi.StringArrayInput `pulumi:"commands"`
	// The action configuration fields for the rule. Configurations options for rule types and providers can be found in the [Rule structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Configuration pulumi.StringMapInput `pulumi:"configuration"`
	// The list of the input artifacts fields for the rule, such as specifying an input file for the rule.
	InputArtifacts pulumi.StringArrayInput `pulumi:"inputArtifacts"`
	// The name of the rule that is created for the condition, such as `VariableCheck`.
	Name pulumi.StringInput `pulumi:"name"`
	// The Region for the condition associated with the rule.
	Region pulumi.StringPtrInput `pulumi:"region"`
	// The pipeline role ARN associated with the rule.
	RoleArn pulumi.StringPtrInput `pulumi:"roleArn"`
	// The ID for the rule type, which is made up of the combined values for `category`, `owner`, `provider`, and `version`. Defined as an `ruleTypeId` block below.
	RuleTypeId PipelineStageOnFailureConditionRuleRuleTypeIdInput `pulumi:"ruleTypeId"`
	// The action timeout for the rule.
	TimeoutInMinutes pulumi.IntPtrInput `pulumi:"timeoutInMinutes"`
}

func (PipelineStageOnFailureConditionRuleArgs) ElementType

func (PipelineStageOnFailureConditionRuleArgs) ToPipelineStageOnFailureConditionRuleOutput

func (i PipelineStageOnFailureConditionRuleArgs) ToPipelineStageOnFailureConditionRuleOutput() PipelineStageOnFailureConditionRuleOutput

func (PipelineStageOnFailureConditionRuleArgs) ToPipelineStageOnFailureConditionRuleOutputWithContext

func (i PipelineStageOnFailureConditionRuleArgs) ToPipelineStageOnFailureConditionRuleOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionRuleOutput

type PipelineStageOnFailureConditionRuleArray

type PipelineStageOnFailureConditionRuleArray []PipelineStageOnFailureConditionRuleInput

func (PipelineStageOnFailureConditionRuleArray) ElementType

func (PipelineStageOnFailureConditionRuleArray) ToPipelineStageOnFailureConditionRuleArrayOutput

func (i PipelineStageOnFailureConditionRuleArray) ToPipelineStageOnFailureConditionRuleArrayOutput() PipelineStageOnFailureConditionRuleArrayOutput

func (PipelineStageOnFailureConditionRuleArray) ToPipelineStageOnFailureConditionRuleArrayOutputWithContext

func (i PipelineStageOnFailureConditionRuleArray) ToPipelineStageOnFailureConditionRuleArrayOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionRuleArrayOutput

type PipelineStageOnFailureConditionRuleArrayInput

type PipelineStageOnFailureConditionRuleArrayInput interface {
	pulumi.Input

	ToPipelineStageOnFailureConditionRuleArrayOutput() PipelineStageOnFailureConditionRuleArrayOutput
	ToPipelineStageOnFailureConditionRuleArrayOutputWithContext(context.Context) PipelineStageOnFailureConditionRuleArrayOutput
}

PipelineStageOnFailureConditionRuleArrayInput is an input type that accepts PipelineStageOnFailureConditionRuleArray and PipelineStageOnFailureConditionRuleArrayOutput values. You can construct a concrete instance of `PipelineStageOnFailureConditionRuleArrayInput` via:

PipelineStageOnFailureConditionRuleArray{ PipelineStageOnFailureConditionRuleArgs{...} }

type PipelineStageOnFailureConditionRuleArrayOutput

type PipelineStageOnFailureConditionRuleArrayOutput struct{ *pulumi.OutputState }

func (PipelineStageOnFailureConditionRuleArrayOutput) ElementType

func (PipelineStageOnFailureConditionRuleArrayOutput) Index

func (PipelineStageOnFailureConditionRuleArrayOutput) ToPipelineStageOnFailureConditionRuleArrayOutput

func (o PipelineStageOnFailureConditionRuleArrayOutput) ToPipelineStageOnFailureConditionRuleArrayOutput() PipelineStageOnFailureConditionRuleArrayOutput

func (PipelineStageOnFailureConditionRuleArrayOutput) ToPipelineStageOnFailureConditionRuleArrayOutputWithContext

func (o PipelineStageOnFailureConditionRuleArrayOutput) ToPipelineStageOnFailureConditionRuleArrayOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionRuleArrayOutput

type PipelineStageOnFailureConditionRuleInput

type PipelineStageOnFailureConditionRuleInput interface {
	pulumi.Input

	ToPipelineStageOnFailureConditionRuleOutput() PipelineStageOnFailureConditionRuleOutput
	ToPipelineStageOnFailureConditionRuleOutputWithContext(context.Context) PipelineStageOnFailureConditionRuleOutput
}

PipelineStageOnFailureConditionRuleInput is an input type that accepts PipelineStageOnFailureConditionRuleArgs and PipelineStageOnFailureConditionRuleOutput values. You can construct a concrete instance of `PipelineStageOnFailureConditionRuleInput` via:

PipelineStageOnFailureConditionRuleArgs{...}

type PipelineStageOnFailureConditionRuleOutput

type PipelineStageOnFailureConditionRuleOutput struct{ *pulumi.OutputState }

func (PipelineStageOnFailureConditionRuleOutput) Commands

The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats.

func (PipelineStageOnFailureConditionRuleOutput) Configuration

The action configuration fields for the rule. Configurations options for rule types and providers can be found in the [Rule structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).

func (PipelineStageOnFailureConditionRuleOutput) ElementType

func (PipelineStageOnFailureConditionRuleOutput) InputArtifacts

The list of the input artifacts fields for the rule, such as specifying an input file for the rule.

func (PipelineStageOnFailureConditionRuleOutput) Name

The name of the rule that is created for the condition, such as `VariableCheck`.

func (PipelineStageOnFailureConditionRuleOutput) Region

The Region for the condition associated with the rule.

func (PipelineStageOnFailureConditionRuleOutput) RoleArn

The pipeline role ARN associated with the rule.

func (PipelineStageOnFailureConditionRuleOutput) RuleTypeId

The ID for the rule type, which is made up of the combined values for `category`, `owner`, `provider`, and `version`. Defined as an `ruleTypeId` block below.

func (PipelineStageOnFailureConditionRuleOutput) TimeoutInMinutes

The action timeout for the rule.

func (PipelineStageOnFailureConditionRuleOutput) ToPipelineStageOnFailureConditionRuleOutput

func (o PipelineStageOnFailureConditionRuleOutput) ToPipelineStageOnFailureConditionRuleOutput() PipelineStageOnFailureConditionRuleOutput

func (PipelineStageOnFailureConditionRuleOutput) ToPipelineStageOnFailureConditionRuleOutputWithContext

func (o PipelineStageOnFailureConditionRuleOutput) ToPipelineStageOnFailureConditionRuleOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionRuleOutput

type PipelineStageOnFailureConditionRuleRuleTypeId

type PipelineStageOnFailureConditionRuleRuleTypeId struct {
	// A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule. The valid category is `Rule`.
	Category string `pulumi:"category"`
	// The creator of the rule being called. The valid value for the Owner field in the rule category is `AWS`.
	Owner *string `pulumi:"owner"`
	// The rule provider, such as the DeploymentWindow rule. For a list of rule provider names, see the rules listed in the [AWS CodePipeline rule reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Provider string `pulumi:"provider"`
	// A string that describes the rule version.
	Version *string `pulumi:"version"`
}

type PipelineStageOnFailureConditionRuleRuleTypeIdArgs

type PipelineStageOnFailureConditionRuleRuleTypeIdArgs struct {
	// A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule. The valid category is `Rule`.
	Category pulumi.StringInput `pulumi:"category"`
	// The creator of the rule being called. The valid value for the Owner field in the rule category is `AWS`.
	Owner pulumi.StringPtrInput `pulumi:"owner"`
	// The rule provider, such as the DeploymentWindow rule. For a list of rule provider names, see the rules listed in the [AWS CodePipeline rule reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Provider pulumi.StringInput `pulumi:"provider"`
	// A string that describes the rule version.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (PipelineStageOnFailureConditionRuleRuleTypeIdArgs) ElementType

func (PipelineStageOnFailureConditionRuleRuleTypeIdArgs) ToPipelineStageOnFailureConditionRuleRuleTypeIdOutput

func (i PipelineStageOnFailureConditionRuleRuleTypeIdArgs) ToPipelineStageOnFailureConditionRuleRuleTypeIdOutput() PipelineStageOnFailureConditionRuleRuleTypeIdOutput

func (PipelineStageOnFailureConditionRuleRuleTypeIdArgs) ToPipelineStageOnFailureConditionRuleRuleTypeIdOutputWithContext

func (i PipelineStageOnFailureConditionRuleRuleTypeIdArgs) ToPipelineStageOnFailureConditionRuleRuleTypeIdOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionRuleRuleTypeIdOutput

type PipelineStageOnFailureConditionRuleRuleTypeIdInput

type PipelineStageOnFailureConditionRuleRuleTypeIdInput interface {
	pulumi.Input

	ToPipelineStageOnFailureConditionRuleRuleTypeIdOutput() PipelineStageOnFailureConditionRuleRuleTypeIdOutput
	ToPipelineStageOnFailureConditionRuleRuleTypeIdOutputWithContext(context.Context) PipelineStageOnFailureConditionRuleRuleTypeIdOutput
}

PipelineStageOnFailureConditionRuleRuleTypeIdInput is an input type that accepts PipelineStageOnFailureConditionRuleRuleTypeIdArgs and PipelineStageOnFailureConditionRuleRuleTypeIdOutput values. You can construct a concrete instance of `PipelineStageOnFailureConditionRuleRuleTypeIdInput` via:

PipelineStageOnFailureConditionRuleRuleTypeIdArgs{...}

type PipelineStageOnFailureConditionRuleRuleTypeIdOutput

type PipelineStageOnFailureConditionRuleRuleTypeIdOutput struct{ *pulumi.OutputState }

func (PipelineStageOnFailureConditionRuleRuleTypeIdOutput) Category

A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule. The valid category is `Rule`.

func (PipelineStageOnFailureConditionRuleRuleTypeIdOutput) ElementType

func (PipelineStageOnFailureConditionRuleRuleTypeIdOutput) Owner

The creator of the rule being called. The valid value for the Owner field in the rule category is `AWS`.

func (PipelineStageOnFailureConditionRuleRuleTypeIdOutput) Provider

The rule provider, such as the DeploymentWindow rule. For a list of rule provider names, see the rules listed in the [AWS CodePipeline rule reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).

func (PipelineStageOnFailureConditionRuleRuleTypeIdOutput) ToPipelineStageOnFailureConditionRuleRuleTypeIdOutput

func (o PipelineStageOnFailureConditionRuleRuleTypeIdOutput) ToPipelineStageOnFailureConditionRuleRuleTypeIdOutput() PipelineStageOnFailureConditionRuleRuleTypeIdOutput

func (PipelineStageOnFailureConditionRuleRuleTypeIdOutput) ToPipelineStageOnFailureConditionRuleRuleTypeIdOutputWithContext

func (o PipelineStageOnFailureConditionRuleRuleTypeIdOutput) ToPipelineStageOnFailureConditionRuleRuleTypeIdOutputWithContext(ctx context.Context) PipelineStageOnFailureConditionRuleRuleTypeIdOutput

func (PipelineStageOnFailureConditionRuleRuleTypeIdOutput) Version

A string that describes the rule version.

type PipelineStageOnFailureInput

type PipelineStageOnFailureInput interface {
	pulumi.Input

	ToPipelineStageOnFailureOutput() PipelineStageOnFailureOutput
	ToPipelineStageOnFailureOutputWithContext(context.Context) PipelineStageOnFailureOutput
}

PipelineStageOnFailureInput is an input type that accepts PipelineStageOnFailureArgs and PipelineStageOnFailureOutput values. You can construct a concrete instance of `PipelineStageOnFailureInput` via:

PipelineStageOnFailureArgs{...}

type PipelineStageOnFailureOutput

type PipelineStageOnFailureOutput struct{ *pulumi.OutputState }

func (PipelineStageOnFailureOutput) Condition

The conditions that are failure conditions. Defined as a `condition` block below.

func (PipelineStageOnFailureOutput) ElementType

func (PipelineStageOnFailureOutput) Result

The conditions that are configured as failure conditions. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.

func (PipelineStageOnFailureOutput) RetryConfiguration

The retry configuration specifies automatic retry for a failed stage, along with the configured retry mode. Defined as a `retryConfiguration` block below.

func (PipelineStageOnFailureOutput) ToPipelineStageOnFailureOutput

func (o PipelineStageOnFailureOutput) ToPipelineStageOnFailureOutput() PipelineStageOnFailureOutput

func (PipelineStageOnFailureOutput) ToPipelineStageOnFailureOutputWithContext

func (o PipelineStageOnFailureOutput) ToPipelineStageOnFailureOutputWithContext(ctx context.Context) PipelineStageOnFailureOutput

func (PipelineStageOnFailureOutput) ToPipelineStageOnFailurePtrOutput

func (o PipelineStageOnFailureOutput) ToPipelineStageOnFailurePtrOutput() PipelineStageOnFailurePtrOutput

func (PipelineStageOnFailureOutput) ToPipelineStageOnFailurePtrOutputWithContext

func (o PipelineStageOnFailureOutput) ToPipelineStageOnFailurePtrOutputWithContext(ctx context.Context) PipelineStageOnFailurePtrOutput

type PipelineStageOnFailurePtrInput

type PipelineStageOnFailurePtrInput interface {
	pulumi.Input

	ToPipelineStageOnFailurePtrOutput() PipelineStageOnFailurePtrOutput
	ToPipelineStageOnFailurePtrOutputWithContext(context.Context) PipelineStageOnFailurePtrOutput
}

PipelineStageOnFailurePtrInput is an input type that accepts PipelineStageOnFailureArgs, PipelineStageOnFailurePtr and PipelineStageOnFailurePtrOutput values. You can construct a concrete instance of `PipelineStageOnFailurePtrInput` via:

        PipelineStageOnFailureArgs{...}

or:

        nil

type PipelineStageOnFailurePtrOutput

type PipelineStageOnFailurePtrOutput struct{ *pulumi.OutputState }

func (PipelineStageOnFailurePtrOutput) Condition

The conditions that are failure conditions. Defined as a `condition` block below.

func (PipelineStageOnFailurePtrOutput) Elem

func (PipelineStageOnFailurePtrOutput) ElementType

func (PipelineStageOnFailurePtrOutput) Result

The conditions that are configured as failure conditions. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.

func (PipelineStageOnFailurePtrOutput) RetryConfiguration

The retry configuration specifies automatic retry for a failed stage, along with the configured retry mode. Defined as a `retryConfiguration` block below.

func (PipelineStageOnFailurePtrOutput) ToPipelineStageOnFailurePtrOutput

func (o PipelineStageOnFailurePtrOutput) ToPipelineStageOnFailurePtrOutput() PipelineStageOnFailurePtrOutput

func (PipelineStageOnFailurePtrOutput) ToPipelineStageOnFailurePtrOutputWithContext

func (o PipelineStageOnFailurePtrOutput) ToPipelineStageOnFailurePtrOutputWithContext(ctx context.Context) PipelineStageOnFailurePtrOutput

type PipelineStageOnFailureRetryConfiguration

type PipelineStageOnFailureRetryConfiguration struct {
	// The method that you want to configure for automatic stage retry on stage failure. You can specify to retry only failed action in the stage or all actions in the stage. Possible values are `FAILED_ACTIONS` and `ALL_ACTIONS`.
	RetryMode *string `pulumi:"retryMode"`
}

type PipelineStageOnFailureRetryConfigurationArgs

type PipelineStageOnFailureRetryConfigurationArgs struct {
	// The method that you want to configure for automatic stage retry on stage failure. You can specify to retry only failed action in the stage or all actions in the stage. Possible values are `FAILED_ACTIONS` and `ALL_ACTIONS`.
	RetryMode pulumi.StringPtrInput `pulumi:"retryMode"`
}

func (PipelineStageOnFailureRetryConfigurationArgs) ElementType

func (PipelineStageOnFailureRetryConfigurationArgs) ToPipelineStageOnFailureRetryConfigurationOutput

func (i PipelineStageOnFailureRetryConfigurationArgs) ToPipelineStageOnFailureRetryConfigurationOutput() PipelineStageOnFailureRetryConfigurationOutput

func (PipelineStageOnFailureRetryConfigurationArgs) ToPipelineStageOnFailureRetryConfigurationOutputWithContext

func (i PipelineStageOnFailureRetryConfigurationArgs) ToPipelineStageOnFailureRetryConfigurationOutputWithContext(ctx context.Context) PipelineStageOnFailureRetryConfigurationOutput

func (PipelineStageOnFailureRetryConfigurationArgs) ToPipelineStageOnFailureRetryConfigurationPtrOutput

func (i PipelineStageOnFailureRetryConfigurationArgs) ToPipelineStageOnFailureRetryConfigurationPtrOutput() PipelineStageOnFailureRetryConfigurationPtrOutput

func (PipelineStageOnFailureRetryConfigurationArgs) ToPipelineStageOnFailureRetryConfigurationPtrOutputWithContext

func (i PipelineStageOnFailureRetryConfigurationArgs) ToPipelineStageOnFailureRetryConfigurationPtrOutputWithContext(ctx context.Context) PipelineStageOnFailureRetryConfigurationPtrOutput

type PipelineStageOnFailureRetryConfigurationInput

type PipelineStageOnFailureRetryConfigurationInput interface {
	pulumi.Input

	ToPipelineStageOnFailureRetryConfigurationOutput() PipelineStageOnFailureRetryConfigurationOutput
	ToPipelineStageOnFailureRetryConfigurationOutputWithContext(context.Context) PipelineStageOnFailureRetryConfigurationOutput
}

PipelineStageOnFailureRetryConfigurationInput is an input type that accepts PipelineStageOnFailureRetryConfigurationArgs and PipelineStageOnFailureRetryConfigurationOutput values. You can construct a concrete instance of `PipelineStageOnFailureRetryConfigurationInput` via:

PipelineStageOnFailureRetryConfigurationArgs{...}

type PipelineStageOnFailureRetryConfigurationOutput

type PipelineStageOnFailureRetryConfigurationOutput struct{ *pulumi.OutputState }

func (PipelineStageOnFailureRetryConfigurationOutput) ElementType

func (PipelineStageOnFailureRetryConfigurationOutput) RetryMode

The method that you want to configure for automatic stage retry on stage failure. You can specify to retry only failed action in the stage or all actions in the stage. Possible values are `FAILED_ACTIONS` and `ALL_ACTIONS`.

func (PipelineStageOnFailureRetryConfigurationOutput) ToPipelineStageOnFailureRetryConfigurationOutput

func (o PipelineStageOnFailureRetryConfigurationOutput) ToPipelineStageOnFailureRetryConfigurationOutput() PipelineStageOnFailureRetryConfigurationOutput

func (PipelineStageOnFailureRetryConfigurationOutput) ToPipelineStageOnFailureRetryConfigurationOutputWithContext

func (o PipelineStageOnFailureRetryConfigurationOutput) ToPipelineStageOnFailureRetryConfigurationOutputWithContext(ctx context.Context) PipelineStageOnFailureRetryConfigurationOutput

func (PipelineStageOnFailureRetryConfigurationOutput) ToPipelineStageOnFailureRetryConfigurationPtrOutput

func (o PipelineStageOnFailureRetryConfigurationOutput) ToPipelineStageOnFailureRetryConfigurationPtrOutput() PipelineStageOnFailureRetryConfigurationPtrOutput

func (PipelineStageOnFailureRetryConfigurationOutput) ToPipelineStageOnFailureRetryConfigurationPtrOutputWithContext

func (o PipelineStageOnFailureRetryConfigurationOutput) ToPipelineStageOnFailureRetryConfigurationPtrOutputWithContext(ctx context.Context) PipelineStageOnFailureRetryConfigurationPtrOutput

type PipelineStageOnFailureRetryConfigurationPtrInput

type PipelineStageOnFailureRetryConfigurationPtrInput interface {
	pulumi.Input

	ToPipelineStageOnFailureRetryConfigurationPtrOutput() PipelineStageOnFailureRetryConfigurationPtrOutput
	ToPipelineStageOnFailureRetryConfigurationPtrOutputWithContext(context.Context) PipelineStageOnFailureRetryConfigurationPtrOutput
}

PipelineStageOnFailureRetryConfigurationPtrInput is an input type that accepts PipelineStageOnFailureRetryConfigurationArgs, PipelineStageOnFailureRetryConfigurationPtr and PipelineStageOnFailureRetryConfigurationPtrOutput values. You can construct a concrete instance of `PipelineStageOnFailureRetryConfigurationPtrInput` via:

        PipelineStageOnFailureRetryConfigurationArgs{...}

or:

        nil

type PipelineStageOnFailureRetryConfigurationPtrOutput

type PipelineStageOnFailureRetryConfigurationPtrOutput struct{ *pulumi.OutputState }

func (PipelineStageOnFailureRetryConfigurationPtrOutput) Elem

func (PipelineStageOnFailureRetryConfigurationPtrOutput) ElementType

func (PipelineStageOnFailureRetryConfigurationPtrOutput) RetryMode

The method that you want to configure for automatic stage retry on stage failure. You can specify to retry only failed action in the stage or all actions in the stage. Possible values are `FAILED_ACTIONS` and `ALL_ACTIONS`.

func (PipelineStageOnFailureRetryConfigurationPtrOutput) ToPipelineStageOnFailureRetryConfigurationPtrOutput

func (o PipelineStageOnFailureRetryConfigurationPtrOutput) ToPipelineStageOnFailureRetryConfigurationPtrOutput() PipelineStageOnFailureRetryConfigurationPtrOutput

func (PipelineStageOnFailureRetryConfigurationPtrOutput) ToPipelineStageOnFailureRetryConfigurationPtrOutputWithContext

func (o PipelineStageOnFailureRetryConfigurationPtrOutput) ToPipelineStageOnFailureRetryConfigurationPtrOutputWithContext(ctx context.Context) PipelineStageOnFailureRetryConfigurationPtrOutput

type PipelineStageOnSuccess

type PipelineStageOnSuccess struct {
	// The conditions that are success conditions. Defined as a `condition` block below.
	Condition PipelineStageOnSuccessCondition `pulumi:"condition"`
}

type PipelineStageOnSuccessArgs

type PipelineStageOnSuccessArgs struct {
	// The conditions that are success conditions. Defined as a `condition` block below.
	Condition PipelineStageOnSuccessConditionInput `pulumi:"condition"`
}

func (PipelineStageOnSuccessArgs) ElementType

func (PipelineStageOnSuccessArgs) ElementType() reflect.Type

func (PipelineStageOnSuccessArgs) ToPipelineStageOnSuccessOutput

func (i PipelineStageOnSuccessArgs) ToPipelineStageOnSuccessOutput() PipelineStageOnSuccessOutput

func (PipelineStageOnSuccessArgs) ToPipelineStageOnSuccessOutputWithContext

func (i PipelineStageOnSuccessArgs) ToPipelineStageOnSuccessOutputWithContext(ctx context.Context) PipelineStageOnSuccessOutput

func (PipelineStageOnSuccessArgs) ToPipelineStageOnSuccessPtrOutput

func (i PipelineStageOnSuccessArgs) ToPipelineStageOnSuccessPtrOutput() PipelineStageOnSuccessPtrOutput

func (PipelineStageOnSuccessArgs) ToPipelineStageOnSuccessPtrOutputWithContext

func (i PipelineStageOnSuccessArgs) ToPipelineStageOnSuccessPtrOutputWithContext(ctx context.Context) PipelineStageOnSuccessPtrOutput

type PipelineStageOnSuccessCondition

type PipelineStageOnSuccessCondition struct {
	// The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.
	Result *string `pulumi:"result"`
	// The rules that make up the condition. Defined as a `rule` block below.
	Rules []PipelineStageOnSuccessConditionRule `pulumi:"rules"`
}

type PipelineStageOnSuccessConditionArgs

type PipelineStageOnSuccessConditionArgs struct {
	// The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.
	Result pulumi.StringPtrInput `pulumi:"result"`
	// The rules that make up the condition. Defined as a `rule` block below.
	Rules PipelineStageOnSuccessConditionRuleArrayInput `pulumi:"rules"`
}

func (PipelineStageOnSuccessConditionArgs) ElementType

func (PipelineStageOnSuccessConditionArgs) ToPipelineStageOnSuccessConditionOutput

func (i PipelineStageOnSuccessConditionArgs) ToPipelineStageOnSuccessConditionOutput() PipelineStageOnSuccessConditionOutput

func (PipelineStageOnSuccessConditionArgs) ToPipelineStageOnSuccessConditionOutputWithContext

func (i PipelineStageOnSuccessConditionArgs) ToPipelineStageOnSuccessConditionOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionOutput

func (PipelineStageOnSuccessConditionArgs) ToPipelineStageOnSuccessConditionPtrOutput

func (i PipelineStageOnSuccessConditionArgs) ToPipelineStageOnSuccessConditionPtrOutput() PipelineStageOnSuccessConditionPtrOutput

func (PipelineStageOnSuccessConditionArgs) ToPipelineStageOnSuccessConditionPtrOutputWithContext

func (i PipelineStageOnSuccessConditionArgs) ToPipelineStageOnSuccessConditionPtrOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionPtrOutput

type PipelineStageOnSuccessConditionInput

type PipelineStageOnSuccessConditionInput interface {
	pulumi.Input

	ToPipelineStageOnSuccessConditionOutput() PipelineStageOnSuccessConditionOutput
	ToPipelineStageOnSuccessConditionOutputWithContext(context.Context) PipelineStageOnSuccessConditionOutput
}

PipelineStageOnSuccessConditionInput is an input type that accepts PipelineStageOnSuccessConditionArgs and PipelineStageOnSuccessConditionOutput values. You can construct a concrete instance of `PipelineStageOnSuccessConditionInput` via:

PipelineStageOnSuccessConditionArgs{...}

type PipelineStageOnSuccessConditionOutput

type PipelineStageOnSuccessConditionOutput struct{ *pulumi.OutputState }

func (PipelineStageOnSuccessConditionOutput) ElementType

func (PipelineStageOnSuccessConditionOutput) Result

The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.

func (PipelineStageOnSuccessConditionOutput) Rules

The rules that make up the condition. Defined as a `rule` block below.

func (PipelineStageOnSuccessConditionOutput) ToPipelineStageOnSuccessConditionOutput

func (o PipelineStageOnSuccessConditionOutput) ToPipelineStageOnSuccessConditionOutput() PipelineStageOnSuccessConditionOutput

func (PipelineStageOnSuccessConditionOutput) ToPipelineStageOnSuccessConditionOutputWithContext

func (o PipelineStageOnSuccessConditionOutput) ToPipelineStageOnSuccessConditionOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionOutput

func (PipelineStageOnSuccessConditionOutput) ToPipelineStageOnSuccessConditionPtrOutput

func (o PipelineStageOnSuccessConditionOutput) ToPipelineStageOnSuccessConditionPtrOutput() PipelineStageOnSuccessConditionPtrOutput

func (PipelineStageOnSuccessConditionOutput) ToPipelineStageOnSuccessConditionPtrOutputWithContext

func (o PipelineStageOnSuccessConditionOutput) ToPipelineStageOnSuccessConditionPtrOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionPtrOutput

type PipelineStageOnSuccessConditionPtrInput

type PipelineStageOnSuccessConditionPtrInput interface {
	pulumi.Input

	ToPipelineStageOnSuccessConditionPtrOutput() PipelineStageOnSuccessConditionPtrOutput
	ToPipelineStageOnSuccessConditionPtrOutputWithContext(context.Context) PipelineStageOnSuccessConditionPtrOutput
}

PipelineStageOnSuccessConditionPtrInput is an input type that accepts PipelineStageOnSuccessConditionArgs, PipelineStageOnSuccessConditionPtr and PipelineStageOnSuccessConditionPtrOutput values. You can construct a concrete instance of `PipelineStageOnSuccessConditionPtrInput` via:

        PipelineStageOnSuccessConditionArgs{...}

or:

        nil

type PipelineStageOnSuccessConditionPtrOutput

type PipelineStageOnSuccessConditionPtrOutput struct{ *pulumi.OutputState }

func (PipelineStageOnSuccessConditionPtrOutput) Elem

func (PipelineStageOnSuccessConditionPtrOutput) ElementType

func (PipelineStageOnSuccessConditionPtrOutput) Result

The action to be done when the condition is met. For example, rolling back an execution for a failure condition. Possible values are `ROLLBACK`, `FAIL`, `RETRY` and `SKIP`.

func (PipelineStageOnSuccessConditionPtrOutput) Rules

The rules that make up the condition. Defined as a `rule` block below.

func (PipelineStageOnSuccessConditionPtrOutput) ToPipelineStageOnSuccessConditionPtrOutput

func (o PipelineStageOnSuccessConditionPtrOutput) ToPipelineStageOnSuccessConditionPtrOutput() PipelineStageOnSuccessConditionPtrOutput

func (PipelineStageOnSuccessConditionPtrOutput) ToPipelineStageOnSuccessConditionPtrOutputWithContext

func (o PipelineStageOnSuccessConditionPtrOutput) ToPipelineStageOnSuccessConditionPtrOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionPtrOutput

type PipelineStageOnSuccessConditionRule

type PipelineStageOnSuccessConditionRule struct {
	// The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats.
	Commands []string `pulumi:"commands"`
	// The action configuration fields for the rule. Configurations options for rule types and providers can be found in the [Rule structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Configuration map[string]string `pulumi:"configuration"`
	// The list of the input artifacts fields for the rule, such as specifying an input file for the rule.
	InputArtifacts []string `pulumi:"inputArtifacts"`
	// The name of the rule that is created for the condition, such as `VariableCheck`.
	Name string `pulumi:"name"`
	// The Region for the condition associated with the rule.
	Region *string `pulumi:"region"`
	// The pipeline role ARN associated with the rule.
	RoleArn *string `pulumi:"roleArn"`
	// The ID for the rule type, which is made up of the combined values for `category`, `owner`, `provider`, and `version`. Defined as an `ruleTypeId` block below.
	RuleTypeId PipelineStageOnSuccessConditionRuleRuleTypeId `pulumi:"ruleTypeId"`
	// The action timeout for the rule.
	TimeoutInMinutes *int `pulumi:"timeoutInMinutes"`
}

type PipelineStageOnSuccessConditionRuleArgs

type PipelineStageOnSuccessConditionRuleArgs struct {
	// The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats.
	Commands pulumi.StringArrayInput `pulumi:"commands"`
	// The action configuration fields for the rule. Configurations options for rule types and providers can be found in the [Rule structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Configuration pulumi.StringMapInput `pulumi:"configuration"`
	// The list of the input artifacts fields for the rule, such as specifying an input file for the rule.
	InputArtifacts pulumi.StringArrayInput `pulumi:"inputArtifacts"`
	// The name of the rule that is created for the condition, such as `VariableCheck`.
	Name pulumi.StringInput `pulumi:"name"`
	// The Region for the condition associated with the rule.
	Region pulumi.StringPtrInput `pulumi:"region"`
	// The pipeline role ARN associated with the rule.
	RoleArn pulumi.StringPtrInput `pulumi:"roleArn"`
	// The ID for the rule type, which is made up of the combined values for `category`, `owner`, `provider`, and `version`. Defined as an `ruleTypeId` block below.
	RuleTypeId PipelineStageOnSuccessConditionRuleRuleTypeIdInput `pulumi:"ruleTypeId"`
	// The action timeout for the rule.
	TimeoutInMinutes pulumi.IntPtrInput `pulumi:"timeoutInMinutes"`
}

func (PipelineStageOnSuccessConditionRuleArgs) ElementType

func (PipelineStageOnSuccessConditionRuleArgs) ToPipelineStageOnSuccessConditionRuleOutput

func (i PipelineStageOnSuccessConditionRuleArgs) ToPipelineStageOnSuccessConditionRuleOutput() PipelineStageOnSuccessConditionRuleOutput

func (PipelineStageOnSuccessConditionRuleArgs) ToPipelineStageOnSuccessConditionRuleOutputWithContext

func (i PipelineStageOnSuccessConditionRuleArgs) ToPipelineStageOnSuccessConditionRuleOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionRuleOutput

type PipelineStageOnSuccessConditionRuleArray

type PipelineStageOnSuccessConditionRuleArray []PipelineStageOnSuccessConditionRuleInput

func (PipelineStageOnSuccessConditionRuleArray) ElementType

func (PipelineStageOnSuccessConditionRuleArray) ToPipelineStageOnSuccessConditionRuleArrayOutput

func (i PipelineStageOnSuccessConditionRuleArray) ToPipelineStageOnSuccessConditionRuleArrayOutput() PipelineStageOnSuccessConditionRuleArrayOutput

func (PipelineStageOnSuccessConditionRuleArray) ToPipelineStageOnSuccessConditionRuleArrayOutputWithContext

func (i PipelineStageOnSuccessConditionRuleArray) ToPipelineStageOnSuccessConditionRuleArrayOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionRuleArrayOutput

type PipelineStageOnSuccessConditionRuleArrayInput

type PipelineStageOnSuccessConditionRuleArrayInput interface {
	pulumi.Input

	ToPipelineStageOnSuccessConditionRuleArrayOutput() PipelineStageOnSuccessConditionRuleArrayOutput
	ToPipelineStageOnSuccessConditionRuleArrayOutputWithContext(context.Context) PipelineStageOnSuccessConditionRuleArrayOutput
}

PipelineStageOnSuccessConditionRuleArrayInput is an input type that accepts PipelineStageOnSuccessConditionRuleArray and PipelineStageOnSuccessConditionRuleArrayOutput values. You can construct a concrete instance of `PipelineStageOnSuccessConditionRuleArrayInput` via:

PipelineStageOnSuccessConditionRuleArray{ PipelineStageOnSuccessConditionRuleArgs{...} }

type PipelineStageOnSuccessConditionRuleArrayOutput

type PipelineStageOnSuccessConditionRuleArrayOutput struct{ *pulumi.OutputState }

func (PipelineStageOnSuccessConditionRuleArrayOutput) ElementType

func (PipelineStageOnSuccessConditionRuleArrayOutput) Index

func (PipelineStageOnSuccessConditionRuleArrayOutput) ToPipelineStageOnSuccessConditionRuleArrayOutput

func (o PipelineStageOnSuccessConditionRuleArrayOutput) ToPipelineStageOnSuccessConditionRuleArrayOutput() PipelineStageOnSuccessConditionRuleArrayOutput

func (PipelineStageOnSuccessConditionRuleArrayOutput) ToPipelineStageOnSuccessConditionRuleArrayOutputWithContext

func (o PipelineStageOnSuccessConditionRuleArrayOutput) ToPipelineStageOnSuccessConditionRuleArrayOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionRuleArrayOutput

type PipelineStageOnSuccessConditionRuleInput

type PipelineStageOnSuccessConditionRuleInput interface {
	pulumi.Input

	ToPipelineStageOnSuccessConditionRuleOutput() PipelineStageOnSuccessConditionRuleOutput
	ToPipelineStageOnSuccessConditionRuleOutputWithContext(context.Context) PipelineStageOnSuccessConditionRuleOutput
}

PipelineStageOnSuccessConditionRuleInput is an input type that accepts PipelineStageOnSuccessConditionRuleArgs and PipelineStageOnSuccessConditionRuleOutput values. You can construct a concrete instance of `PipelineStageOnSuccessConditionRuleInput` via:

PipelineStageOnSuccessConditionRuleArgs{...}

type PipelineStageOnSuccessConditionRuleOutput

type PipelineStageOnSuccessConditionRuleOutput struct{ *pulumi.OutputState }

func (PipelineStageOnSuccessConditionRuleOutput) Commands

The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats.

func (PipelineStageOnSuccessConditionRuleOutput) Configuration

The action configuration fields for the rule. Configurations options for rule types and providers can be found in the [Rule structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).

func (PipelineStageOnSuccessConditionRuleOutput) ElementType

func (PipelineStageOnSuccessConditionRuleOutput) InputArtifacts

The list of the input artifacts fields for the rule, such as specifying an input file for the rule.

func (PipelineStageOnSuccessConditionRuleOutput) Name

The name of the rule that is created for the condition, such as `VariableCheck`.

func (PipelineStageOnSuccessConditionRuleOutput) Region

The Region for the condition associated with the rule.

func (PipelineStageOnSuccessConditionRuleOutput) RoleArn

The pipeline role ARN associated with the rule.

func (PipelineStageOnSuccessConditionRuleOutput) RuleTypeId

The ID for the rule type, which is made up of the combined values for `category`, `owner`, `provider`, and `version`. Defined as an `ruleTypeId` block below.

func (PipelineStageOnSuccessConditionRuleOutput) TimeoutInMinutes

The action timeout for the rule.

func (PipelineStageOnSuccessConditionRuleOutput) ToPipelineStageOnSuccessConditionRuleOutput

func (o PipelineStageOnSuccessConditionRuleOutput) ToPipelineStageOnSuccessConditionRuleOutput() PipelineStageOnSuccessConditionRuleOutput

func (PipelineStageOnSuccessConditionRuleOutput) ToPipelineStageOnSuccessConditionRuleOutputWithContext

func (o PipelineStageOnSuccessConditionRuleOutput) ToPipelineStageOnSuccessConditionRuleOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionRuleOutput

type PipelineStageOnSuccessConditionRuleRuleTypeId

type PipelineStageOnSuccessConditionRuleRuleTypeId struct {
	// A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule. The valid category is `Rule`.
	Category string `pulumi:"category"`
	// The creator of the rule being called. The valid value for the Owner field in the rule category is `AWS`.
	Owner *string `pulumi:"owner"`
	// The rule provider, such as the DeploymentWindow rule. For a list of rule provider names, see the rules listed in the [AWS CodePipeline rule reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Provider string `pulumi:"provider"`
	// A string that describes the rule version.
	Version *string `pulumi:"version"`
}

type PipelineStageOnSuccessConditionRuleRuleTypeIdArgs

type PipelineStageOnSuccessConditionRuleRuleTypeIdArgs struct {
	// A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule. The valid category is `Rule`.
	Category pulumi.StringInput `pulumi:"category"`
	// The creator of the rule being called. The valid value for the Owner field in the rule category is `AWS`.
	Owner pulumi.StringPtrInput `pulumi:"owner"`
	// The rule provider, such as the DeploymentWindow rule. For a list of rule provider names, see the rules listed in the [AWS CodePipeline rule reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).
	Provider pulumi.StringInput `pulumi:"provider"`
	// A string that describes the rule version.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (PipelineStageOnSuccessConditionRuleRuleTypeIdArgs) ElementType

func (PipelineStageOnSuccessConditionRuleRuleTypeIdArgs) ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutput

func (i PipelineStageOnSuccessConditionRuleRuleTypeIdArgs) ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutput() PipelineStageOnSuccessConditionRuleRuleTypeIdOutput

func (PipelineStageOnSuccessConditionRuleRuleTypeIdArgs) ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutputWithContext

func (i PipelineStageOnSuccessConditionRuleRuleTypeIdArgs) ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionRuleRuleTypeIdOutput

type PipelineStageOnSuccessConditionRuleRuleTypeIdInput

type PipelineStageOnSuccessConditionRuleRuleTypeIdInput interface {
	pulumi.Input

	ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutput() PipelineStageOnSuccessConditionRuleRuleTypeIdOutput
	ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutputWithContext(context.Context) PipelineStageOnSuccessConditionRuleRuleTypeIdOutput
}

PipelineStageOnSuccessConditionRuleRuleTypeIdInput is an input type that accepts PipelineStageOnSuccessConditionRuleRuleTypeIdArgs and PipelineStageOnSuccessConditionRuleRuleTypeIdOutput values. You can construct a concrete instance of `PipelineStageOnSuccessConditionRuleRuleTypeIdInput` via:

PipelineStageOnSuccessConditionRuleRuleTypeIdArgs{...}

type PipelineStageOnSuccessConditionRuleRuleTypeIdOutput

type PipelineStageOnSuccessConditionRuleRuleTypeIdOutput struct{ *pulumi.OutputState }

func (PipelineStageOnSuccessConditionRuleRuleTypeIdOutput) Category

A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule. The valid category is `Rule`.

func (PipelineStageOnSuccessConditionRuleRuleTypeIdOutput) ElementType

func (PipelineStageOnSuccessConditionRuleRuleTypeIdOutput) Owner

The creator of the rule being called. The valid value for the Owner field in the rule category is `AWS`.

func (PipelineStageOnSuccessConditionRuleRuleTypeIdOutput) Provider

The rule provider, such as the DeploymentWindow rule. For a list of rule provider names, see the rules listed in the [AWS CodePipeline rule reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/rule-reference.html).

func (PipelineStageOnSuccessConditionRuleRuleTypeIdOutput) ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutput

func (o PipelineStageOnSuccessConditionRuleRuleTypeIdOutput) ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutput() PipelineStageOnSuccessConditionRuleRuleTypeIdOutput

func (PipelineStageOnSuccessConditionRuleRuleTypeIdOutput) ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutputWithContext

func (o PipelineStageOnSuccessConditionRuleRuleTypeIdOutput) ToPipelineStageOnSuccessConditionRuleRuleTypeIdOutputWithContext(ctx context.Context) PipelineStageOnSuccessConditionRuleRuleTypeIdOutput

func (PipelineStageOnSuccessConditionRuleRuleTypeIdOutput) Version

A string that describes the rule version.

type PipelineStageOnSuccessInput

type PipelineStageOnSuccessInput interface {
	pulumi.Input

	ToPipelineStageOnSuccessOutput() PipelineStageOnSuccessOutput
	ToPipelineStageOnSuccessOutputWithContext(context.Context) PipelineStageOnSuccessOutput
}

PipelineStageOnSuccessInput is an input type that accepts PipelineStageOnSuccessArgs and PipelineStageOnSuccessOutput values. You can construct a concrete instance of `PipelineStageOnSuccessInput` via:

PipelineStageOnSuccessArgs{...}

type PipelineStageOnSuccessOutput

type PipelineStageOnSuccessOutput struct{ *pulumi.OutputState }

func (PipelineStageOnSuccessOutput) Condition

The conditions that are success conditions. Defined as a `condition` block below.

func (PipelineStageOnSuccessOutput) ElementType

func (PipelineStageOnSuccessOutput) ToPipelineStageOnSuccessOutput

func (o PipelineStageOnSuccessOutput) ToPipelineStageOnSuccessOutput() PipelineStageOnSuccessOutput

func (PipelineStageOnSuccessOutput) ToPipelineStageOnSuccessOutputWithContext

func (o PipelineStageOnSuccessOutput) ToPipelineStageOnSuccessOutputWithContext(ctx context.Context) PipelineStageOnSuccessOutput

func (PipelineStageOnSuccessOutput) ToPipelineStageOnSuccessPtrOutput

func (o PipelineStageOnSuccessOutput) ToPipelineStageOnSuccessPtrOutput() PipelineStageOnSuccessPtrOutput

func (PipelineStageOnSuccessOutput) ToPipelineStageOnSuccessPtrOutputWithContext

func (o PipelineStageOnSuccessOutput) ToPipelineStageOnSuccessPtrOutputWithContext(ctx context.Context) PipelineStageOnSuccessPtrOutput

type PipelineStageOnSuccessPtrInput

type PipelineStageOnSuccessPtrInput interface {
	pulumi.Input

	ToPipelineStageOnSuccessPtrOutput() PipelineStageOnSuccessPtrOutput
	ToPipelineStageOnSuccessPtrOutputWithContext(context.Context) PipelineStageOnSuccessPtrOutput
}

PipelineStageOnSuccessPtrInput is an input type that accepts PipelineStageOnSuccessArgs, PipelineStageOnSuccessPtr and PipelineStageOnSuccessPtrOutput values. You can construct a concrete instance of `PipelineStageOnSuccessPtrInput` via:

        PipelineStageOnSuccessArgs{...}

or:

        nil

type PipelineStageOnSuccessPtrOutput

type PipelineStageOnSuccessPtrOutput struct{ *pulumi.OutputState }

func (PipelineStageOnSuccessPtrOutput) Condition

The conditions that are success conditions. Defined as a `condition` block below.

func (PipelineStageOnSuccessPtrOutput) Elem

func (PipelineStageOnSuccessPtrOutput) ElementType

func (PipelineStageOnSuccessPtrOutput) ToPipelineStageOnSuccessPtrOutput

func (o PipelineStageOnSuccessPtrOutput) ToPipelineStageOnSuccessPtrOutput() PipelineStageOnSuccessPtrOutput

func (PipelineStageOnSuccessPtrOutput) ToPipelineStageOnSuccessPtrOutputWithContext

func (o PipelineStageOnSuccessPtrOutput) ToPipelineStageOnSuccessPtrOutputWithContext(ctx context.Context) PipelineStageOnSuccessPtrOutput

type PipelineStageOutput

type PipelineStageOutput struct{ *pulumi.OutputState }

func (PipelineStageOutput) Actions

The action(s) to include in the stage. Defined as an `action` block below

func (PipelineStageOutput) BeforeEntry

The method to use when a stage allows entry. For example, configuring this field for conditions will allow entry to the stage when the conditions are met.

func (PipelineStageOutput) ElementType

func (PipelineStageOutput) ElementType() reflect.Type

func (PipelineStageOutput) Name

The name of the stage.

func (PipelineStageOutput) OnFailure

The method to use when a stage has not completed successfully. For example, configuring this field for rollback will roll back a failed stage automatically to the last successful pipeline execution in the stage.

func (PipelineStageOutput) OnSuccess

The method to use when a stage has succeeded. For example, configuring this field for conditions will allow the stage to succeed when the conditions are met.

func (PipelineStageOutput) ToPipelineStageOutput

func (o PipelineStageOutput) ToPipelineStageOutput() PipelineStageOutput

func (PipelineStageOutput) ToPipelineStageOutputWithContext

func (o PipelineStageOutput) ToPipelineStageOutputWithContext(ctx context.Context) PipelineStageOutput

type PipelineState

type PipelineState struct {
	// Codepipeline ARN.
	Arn pulumi.StringPtrInput
	// One or more artifactStore blocks. Artifact stores are documented below.
	ArtifactStores PipelineArtifactStoreArrayInput
	// The method that the pipeline will use to handle multiple executions. The default mode is `SUPERSEDED`. For value values, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PipelineDeclaration.html#CodePipeline-Type-PipelineDeclaration-executionMode).
	ExecutionMode pulumi.StringPtrInput
	// The name of the pipeline.
	Name pulumi.StringPtrInput
	// Type of the pipeline. Possible values are: `V1` and `V2`. Default value is `V1`.
	PipelineType pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// A service role Amazon Resource Name (ARN) that grants AWS CodePipeline permission to make calls to AWS services on your behalf.
	RoleArn pulumi.StringPtrInput
	// A stage block. Stages are documented below.
	Stages PipelineStageArrayInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
	// A list of all triggers present on the pipeline, including default triggers added by AWS for `V2` pipelines which omit an explicit `trigger` definition.
	TriggerAlls PipelineTriggerAllArrayInput
	// A trigger block. Valid only when `pipelineType` is `V2`. Triggers are documented below.
	Triggers PipelineTriggerArrayInput
	// A pipeline-level variable block. Valid only when `pipelineType` is `V2`. Variable are documented below.
	//
	// **Note:** `QUEUED` or `PARALLEL` mode can only be used with V2 pipelines.
	Variables PipelineVariableArrayInput
}

func (PipelineState) ElementType

func (PipelineState) ElementType() reflect.Type

type PipelineTrigger

type PipelineTrigger struct {
	// Provides the filter criteria and the source stage for the repository event that starts the pipeline. For more information, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-filter.html). A `gitConfiguration` block is documented below.
	GitConfiguration PipelineTriggerGitConfiguration `pulumi:"gitConfiguration"`
	// The source provider for the event. Possible value is `CodeStarSourceConnection`.
	ProviderType string `pulumi:"providerType"`
}

type PipelineTriggerAll

type PipelineTriggerAll struct {
	// Provides the filter criteria and the source stage for the repository event that starts the pipeline. For more information, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-filter.html). A `gitConfiguration` block is documented below.
	GitConfigurations []PipelineTriggerAllGitConfiguration `pulumi:"gitConfigurations"`
	// The source provider for the event. Possible value is `CodeStarSourceConnection`.
	ProviderType *string `pulumi:"providerType"`
}

type PipelineTriggerAllArgs

type PipelineTriggerAllArgs struct {
	// Provides the filter criteria and the source stage for the repository event that starts the pipeline. For more information, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-filter.html). A `gitConfiguration` block is documented below.
	GitConfigurations PipelineTriggerAllGitConfigurationArrayInput `pulumi:"gitConfigurations"`
	// The source provider for the event. Possible value is `CodeStarSourceConnection`.
	ProviderType pulumi.StringPtrInput `pulumi:"providerType"`
}

func (PipelineTriggerAllArgs) ElementType

func (PipelineTriggerAllArgs) ElementType() reflect.Type

func (PipelineTriggerAllArgs) ToPipelineTriggerAllOutput

func (i PipelineTriggerAllArgs) ToPipelineTriggerAllOutput() PipelineTriggerAllOutput

func (PipelineTriggerAllArgs) ToPipelineTriggerAllOutputWithContext

func (i PipelineTriggerAllArgs) ToPipelineTriggerAllOutputWithContext(ctx context.Context) PipelineTriggerAllOutput

type PipelineTriggerAllArray

type PipelineTriggerAllArray []PipelineTriggerAllInput

func (PipelineTriggerAllArray) ElementType

func (PipelineTriggerAllArray) ElementType() reflect.Type

func (PipelineTriggerAllArray) ToPipelineTriggerAllArrayOutput

func (i PipelineTriggerAllArray) ToPipelineTriggerAllArrayOutput() PipelineTriggerAllArrayOutput

func (PipelineTriggerAllArray) ToPipelineTriggerAllArrayOutputWithContext

func (i PipelineTriggerAllArray) ToPipelineTriggerAllArrayOutputWithContext(ctx context.Context) PipelineTriggerAllArrayOutput

type PipelineTriggerAllArrayInput

type PipelineTriggerAllArrayInput interface {
	pulumi.Input

	ToPipelineTriggerAllArrayOutput() PipelineTriggerAllArrayOutput
	ToPipelineTriggerAllArrayOutputWithContext(context.Context) PipelineTriggerAllArrayOutput
}

PipelineTriggerAllArrayInput is an input type that accepts PipelineTriggerAllArray and PipelineTriggerAllArrayOutput values. You can construct a concrete instance of `PipelineTriggerAllArrayInput` via:

PipelineTriggerAllArray{ PipelineTriggerAllArgs{...} }

type PipelineTriggerAllArrayOutput

type PipelineTriggerAllArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllArrayOutput) ElementType

func (PipelineTriggerAllArrayOutput) Index

func (PipelineTriggerAllArrayOutput) ToPipelineTriggerAllArrayOutput

func (o PipelineTriggerAllArrayOutput) ToPipelineTriggerAllArrayOutput() PipelineTriggerAllArrayOutput

func (PipelineTriggerAllArrayOutput) ToPipelineTriggerAllArrayOutputWithContext

func (o PipelineTriggerAllArrayOutput) ToPipelineTriggerAllArrayOutputWithContext(ctx context.Context) PipelineTriggerAllArrayOutput

type PipelineTriggerAllGitConfiguration

type PipelineTriggerAllGitConfiguration struct {
	// The field where the repository event that will start the pipeline is specified as pull requests. A `pullRequest` block is documented below.
	PullRequests []PipelineTriggerAllGitConfigurationPullRequest `pulumi:"pullRequests"`
	// The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. A `push` block is documented below.
	Pushes []PipelineTriggerAllGitConfigurationPush `pulumi:"pushes"`
	// The name of the pipeline source action where the trigger configuration, such as Git tags, is specified. The trigger configuration will start the pipeline upon the specified change only.
	SourceActionName *string `pulumi:"sourceActionName"`
}

type PipelineTriggerAllGitConfigurationArgs

type PipelineTriggerAllGitConfigurationArgs struct {
	// The field where the repository event that will start the pipeline is specified as pull requests. A `pullRequest` block is documented below.
	PullRequests PipelineTriggerAllGitConfigurationPullRequestArrayInput `pulumi:"pullRequests"`
	// The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. A `push` block is documented below.
	Pushes PipelineTriggerAllGitConfigurationPushArrayInput `pulumi:"pushes"`
	// The name of the pipeline source action where the trigger configuration, such as Git tags, is specified. The trigger configuration will start the pipeline upon the specified change only.
	SourceActionName pulumi.StringPtrInput `pulumi:"sourceActionName"`
}

func (PipelineTriggerAllGitConfigurationArgs) ElementType

func (PipelineTriggerAllGitConfigurationArgs) ToPipelineTriggerAllGitConfigurationOutput

func (i PipelineTriggerAllGitConfigurationArgs) ToPipelineTriggerAllGitConfigurationOutput() PipelineTriggerAllGitConfigurationOutput

func (PipelineTriggerAllGitConfigurationArgs) ToPipelineTriggerAllGitConfigurationOutputWithContext

func (i PipelineTriggerAllGitConfigurationArgs) ToPipelineTriggerAllGitConfigurationOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationOutput

type PipelineTriggerAllGitConfigurationArray

type PipelineTriggerAllGitConfigurationArray []PipelineTriggerAllGitConfigurationInput

func (PipelineTriggerAllGitConfigurationArray) ElementType

func (PipelineTriggerAllGitConfigurationArray) ToPipelineTriggerAllGitConfigurationArrayOutput

func (i PipelineTriggerAllGitConfigurationArray) ToPipelineTriggerAllGitConfigurationArrayOutput() PipelineTriggerAllGitConfigurationArrayOutput

func (PipelineTriggerAllGitConfigurationArray) ToPipelineTriggerAllGitConfigurationArrayOutputWithContext

func (i PipelineTriggerAllGitConfigurationArray) ToPipelineTriggerAllGitConfigurationArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationArrayOutput

type PipelineTriggerAllGitConfigurationArrayInput

type PipelineTriggerAllGitConfigurationArrayInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationArrayOutput() PipelineTriggerAllGitConfigurationArrayOutput
	ToPipelineTriggerAllGitConfigurationArrayOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationArrayOutput
}

PipelineTriggerAllGitConfigurationArrayInput is an input type that accepts PipelineTriggerAllGitConfigurationArray and PipelineTriggerAllGitConfigurationArrayOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationArrayInput` via:

PipelineTriggerAllGitConfigurationArray{ PipelineTriggerAllGitConfigurationArgs{...} }

type PipelineTriggerAllGitConfigurationArrayOutput

type PipelineTriggerAllGitConfigurationArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationArrayOutput) ElementType

func (PipelineTriggerAllGitConfigurationArrayOutput) Index

func (PipelineTriggerAllGitConfigurationArrayOutput) ToPipelineTriggerAllGitConfigurationArrayOutput

func (o PipelineTriggerAllGitConfigurationArrayOutput) ToPipelineTriggerAllGitConfigurationArrayOutput() PipelineTriggerAllGitConfigurationArrayOutput

func (PipelineTriggerAllGitConfigurationArrayOutput) ToPipelineTriggerAllGitConfigurationArrayOutputWithContext

func (o PipelineTriggerAllGitConfigurationArrayOutput) ToPipelineTriggerAllGitConfigurationArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationArrayOutput

type PipelineTriggerAllGitConfigurationInput

type PipelineTriggerAllGitConfigurationInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationOutput() PipelineTriggerAllGitConfigurationOutput
	ToPipelineTriggerAllGitConfigurationOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationOutput
}

PipelineTriggerAllGitConfigurationInput is an input type that accepts PipelineTriggerAllGitConfigurationArgs and PipelineTriggerAllGitConfigurationOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationInput` via:

PipelineTriggerAllGitConfigurationArgs{...}

type PipelineTriggerAllGitConfigurationOutput

type PipelineTriggerAllGitConfigurationOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationOutput) ElementType

func (PipelineTriggerAllGitConfigurationOutput) PullRequests

The field where the repository event that will start the pipeline is specified as pull requests. A `pullRequest` block is documented below.

func (PipelineTriggerAllGitConfigurationOutput) Pushes

The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. A `push` block is documented below.

func (PipelineTriggerAllGitConfigurationOutput) SourceActionName

The name of the pipeline source action where the trigger configuration, such as Git tags, is specified. The trigger configuration will start the pipeline upon the specified change only.

func (PipelineTriggerAllGitConfigurationOutput) ToPipelineTriggerAllGitConfigurationOutput

func (o PipelineTriggerAllGitConfigurationOutput) ToPipelineTriggerAllGitConfigurationOutput() PipelineTriggerAllGitConfigurationOutput

func (PipelineTriggerAllGitConfigurationOutput) ToPipelineTriggerAllGitConfigurationOutputWithContext

func (o PipelineTriggerAllGitConfigurationOutput) ToPipelineTriggerAllGitConfigurationOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationOutput

type PipelineTriggerAllGitConfigurationPullRequest

type PipelineTriggerAllGitConfigurationPullRequest struct {
	// The field that specifies to filter on branches for the pull request trigger configuration. A `branches` block is documented below.
	Branches []PipelineTriggerAllGitConfigurationPullRequestBranch `pulumi:"branches"`
	// A list that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration. Possible values are `OPEN`, ` UPDATED  ` and `CLOSED`.
	Events []string `pulumi:"events"`
	// The field that specifies to filter on file paths for the pull request trigger configuration. A `filePaths` block is documented below.
	FilePaths []PipelineTriggerAllGitConfigurationPullRequestFilePath `pulumi:"filePaths"`
}

type PipelineTriggerAllGitConfigurationPullRequestArgs

type PipelineTriggerAllGitConfigurationPullRequestArgs struct {
	// The field that specifies to filter on branches for the pull request trigger configuration. A `branches` block is documented below.
	Branches PipelineTriggerAllGitConfigurationPullRequestBranchArrayInput `pulumi:"branches"`
	// A list that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration. Possible values are `OPEN`, ` UPDATED  ` and `CLOSED`.
	Events pulumi.StringArrayInput `pulumi:"events"`
	// The field that specifies to filter on file paths for the pull request trigger configuration. A `filePaths` block is documented below.
	FilePaths PipelineTriggerAllGitConfigurationPullRequestFilePathArrayInput `pulumi:"filePaths"`
}

func (PipelineTriggerAllGitConfigurationPullRequestArgs) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestArgs) ToPipelineTriggerAllGitConfigurationPullRequestOutput

func (i PipelineTriggerAllGitConfigurationPullRequestArgs) ToPipelineTriggerAllGitConfigurationPullRequestOutput() PipelineTriggerAllGitConfigurationPullRequestOutput

func (PipelineTriggerAllGitConfigurationPullRequestArgs) ToPipelineTriggerAllGitConfigurationPullRequestOutputWithContext

func (i PipelineTriggerAllGitConfigurationPullRequestArgs) ToPipelineTriggerAllGitConfigurationPullRequestOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestOutput

type PipelineTriggerAllGitConfigurationPullRequestArray

type PipelineTriggerAllGitConfigurationPullRequestArray []PipelineTriggerAllGitConfigurationPullRequestInput

func (PipelineTriggerAllGitConfigurationPullRequestArray) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestArray) ToPipelineTriggerAllGitConfigurationPullRequestArrayOutput

func (i PipelineTriggerAllGitConfigurationPullRequestArray) ToPipelineTriggerAllGitConfigurationPullRequestArrayOutput() PipelineTriggerAllGitConfigurationPullRequestArrayOutput

func (PipelineTriggerAllGitConfigurationPullRequestArray) ToPipelineTriggerAllGitConfigurationPullRequestArrayOutputWithContext

func (i PipelineTriggerAllGitConfigurationPullRequestArray) ToPipelineTriggerAllGitConfigurationPullRequestArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestArrayOutput

type PipelineTriggerAllGitConfigurationPullRequestArrayInput

type PipelineTriggerAllGitConfigurationPullRequestArrayInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPullRequestArrayOutput() PipelineTriggerAllGitConfigurationPullRequestArrayOutput
	ToPipelineTriggerAllGitConfigurationPullRequestArrayOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPullRequestArrayOutput
}

PipelineTriggerAllGitConfigurationPullRequestArrayInput is an input type that accepts PipelineTriggerAllGitConfigurationPullRequestArray and PipelineTriggerAllGitConfigurationPullRequestArrayOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPullRequestArrayInput` via:

PipelineTriggerAllGitConfigurationPullRequestArray{ PipelineTriggerAllGitConfigurationPullRequestArgs{...} }

type PipelineTriggerAllGitConfigurationPullRequestArrayOutput

type PipelineTriggerAllGitConfigurationPullRequestArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPullRequestArrayOutput) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestArrayOutput) Index

func (PipelineTriggerAllGitConfigurationPullRequestArrayOutput) ToPipelineTriggerAllGitConfigurationPullRequestArrayOutput

func (PipelineTriggerAllGitConfigurationPullRequestArrayOutput) ToPipelineTriggerAllGitConfigurationPullRequestArrayOutputWithContext

func (o PipelineTriggerAllGitConfigurationPullRequestArrayOutput) ToPipelineTriggerAllGitConfigurationPullRequestArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestArrayOutput

type PipelineTriggerAllGitConfigurationPullRequestBranch

type PipelineTriggerAllGitConfigurationPullRequestBranch struct {
	// A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerAllGitConfigurationPullRequestBranchArgs

type PipelineTriggerAllGitConfigurationPullRequestBranchArgs struct {
	// A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerAllGitConfigurationPullRequestBranchArgs) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestBranchArgs) ToPipelineTriggerAllGitConfigurationPullRequestBranchOutput

func (PipelineTriggerAllGitConfigurationPullRequestBranchArgs) ToPipelineTriggerAllGitConfigurationPullRequestBranchOutputWithContext

func (i PipelineTriggerAllGitConfigurationPullRequestBranchArgs) ToPipelineTriggerAllGitConfigurationPullRequestBranchOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestBranchOutput

type PipelineTriggerAllGitConfigurationPullRequestBranchArray

type PipelineTriggerAllGitConfigurationPullRequestBranchArray []PipelineTriggerAllGitConfigurationPullRequestBranchInput

func (PipelineTriggerAllGitConfigurationPullRequestBranchArray) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestBranchArray) ToPipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput

func (i PipelineTriggerAllGitConfigurationPullRequestBranchArray) ToPipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput() PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput

func (PipelineTriggerAllGitConfigurationPullRequestBranchArray) ToPipelineTriggerAllGitConfigurationPullRequestBranchArrayOutputWithContext

func (i PipelineTriggerAllGitConfigurationPullRequestBranchArray) ToPipelineTriggerAllGitConfigurationPullRequestBranchArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput

type PipelineTriggerAllGitConfigurationPullRequestBranchArrayInput

type PipelineTriggerAllGitConfigurationPullRequestBranchArrayInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput() PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput
	ToPipelineTriggerAllGitConfigurationPullRequestBranchArrayOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput
}

PipelineTriggerAllGitConfigurationPullRequestBranchArrayInput is an input type that accepts PipelineTriggerAllGitConfigurationPullRequestBranchArray and PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPullRequestBranchArrayInput` via:

PipelineTriggerAllGitConfigurationPullRequestBranchArray{ PipelineTriggerAllGitConfigurationPullRequestBranchArgs{...} }

type PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput

type PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput) Index

func (PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput) ToPipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput

func (PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput) ToPipelineTriggerAllGitConfigurationPullRequestBranchArrayOutputWithContext

func (o PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput) ToPipelineTriggerAllGitConfigurationPullRequestBranchArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestBranchArrayOutput

type PipelineTriggerAllGitConfigurationPullRequestBranchInput

type PipelineTriggerAllGitConfigurationPullRequestBranchInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPullRequestBranchOutput() PipelineTriggerAllGitConfigurationPullRequestBranchOutput
	ToPipelineTriggerAllGitConfigurationPullRequestBranchOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPullRequestBranchOutput
}

PipelineTriggerAllGitConfigurationPullRequestBranchInput is an input type that accepts PipelineTriggerAllGitConfigurationPullRequestBranchArgs and PipelineTriggerAllGitConfigurationPullRequestBranchOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPullRequestBranchInput` via:

PipelineTriggerAllGitConfigurationPullRequestBranchArgs{...}

type PipelineTriggerAllGitConfigurationPullRequestBranchOutput

type PipelineTriggerAllGitConfigurationPullRequestBranchOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPullRequestBranchOutput) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestBranchOutput) Excludes

A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerAllGitConfigurationPullRequestBranchOutput) Includes

A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerAllGitConfigurationPullRequestBranchOutput) ToPipelineTriggerAllGitConfigurationPullRequestBranchOutput

func (PipelineTriggerAllGitConfigurationPullRequestBranchOutput) ToPipelineTriggerAllGitConfigurationPullRequestBranchOutputWithContext

func (o PipelineTriggerAllGitConfigurationPullRequestBranchOutput) ToPipelineTriggerAllGitConfigurationPullRequestBranchOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestBranchOutput

type PipelineTriggerAllGitConfigurationPullRequestFilePath

type PipelineTriggerAllGitConfigurationPullRequestFilePath struct {
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerAllGitConfigurationPullRequestFilePathArgs

type PipelineTriggerAllGitConfigurationPullRequestFilePathArgs struct {
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArgs) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArgs) ToPipelineTriggerAllGitConfigurationPullRequestFilePathOutput

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArgs) ToPipelineTriggerAllGitConfigurationPullRequestFilePathOutputWithContext

func (i PipelineTriggerAllGitConfigurationPullRequestFilePathArgs) ToPipelineTriggerAllGitConfigurationPullRequestFilePathOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestFilePathOutput

type PipelineTriggerAllGitConfigurationPullRequestFilePathArray

type PipelineTriggerAllGitConfigurationPullRequestFilePathArray []PipelineTriggerAllGitConfigurationPullRequestFilePathInput

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArray) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArray) ToPipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArray) ToPipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutputWithContext

func (i PipelineTriggerAllGitConfigurationPullRequestFilePathArray) ToPipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput

type PipelineTriggerAllGitConfigurationPullRequestFilePathArrayInput

type PipelineTriggerAllGitConfigurationPullRequestFilePathArrayInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput() PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput
	ToPipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput
}

PipelineTriggerAllGitConfigurationPullRequestFilePathArrayInput is an input type that accepts PipelineTriggerAllGitConfigurationPullRequestFilePathArray and PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPullRequestFilePathArrayInput` via:

PipelineTriggerAllGitConfigurationPullRequestFilePathArray{ PipelineTriggerAllGitConfigurationPullRequestFilePathArgs{...} }

type PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput

type PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput) Index

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput) ToPipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput

func (PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput) ToPipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutputWithContext

func (o PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput) ToPipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestFilePathArrayOutput

type PipelineTriggerAllGitConfigurationPullRequestFilePathInput

type PipelineTriggerAllGitConfigurationPullRequestFilePathInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPullRequestFilePathOutput() PipelineTriggerAllGitConfigurationPullRequestFilePathOutput
	ToPipelineTriggerAllGitConfigurationPullRequestFilePathOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPullRequestFilePathOutput
}

PipelineTriggerAllGitConfigurationPullRequestFilePathInput is an input type that accepts PipelineTriggerAllGitConfigurationPullRequestFilePathArgs and PipelineTriggerAllGitConfigurationPullRequestFilePathOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPullRequestFilePathInput` via:

PipelineTriggerAllGitConfigurationPullRequestFilePathArgs{...}

type PipelineTriggerAllGitConfigurationPullRequestFilePathOutput

type PipelineTriggerAllGitConfigurationPullRequestFilePathOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPullRequestFilePathOutput) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestFilePathOutput) Excludes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerAllGitConfigurationPullRequestFilePathOutput) Includes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerAllGitConfigurationPullRequestFilePathOutput) ToPipelineTriggerAllGitConfigurationPullRequestFilePathOutput

func (PipelineTriggerAllGitConfigurationPullRequestFilePathOutput) ToPipelineTriggerAllGitConfigurationPullRequestFilePathOutputWithContext

func (o PipelineTriggerAllGitConfigurationPullRequestFilePathOutput) ToPipelineTriggerAllGitConfigurationPullRequestFilePathOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestFilePathOutput

type PipelineTriggerAllGitConfigurationPullRequestInput

type PipelineTriggerAllGitConfigurationPullRequestInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPullRequestOutput() PipelineTriggerAllGitConfigurationPullRequestOutput
	ToPipelineTriggerAllGitConfigurationPullRequestOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPullRequestOutput
}

PipelineTriggerAllGitConfigurationPullRequestInput is an input type that accepts PipelineTriggerAllGitConfigurationPullRequestArgs and PipelineTriggerAllGitConfigurationPullRequestOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPullRequestInput` via:

PipelineTriggerAllGitConfigurationPullRequestArgs{...}

type PipelineTriggerAllGitConfigurationPullRequestOutput

type PipelineTriggerAllGitConfigurationPullRequestOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPullRequestOutput) Branches

The field that specifies to filter on branches for the pull request trigger configuration. A `branches` block is documented below.

func (PipelineTriggerAllGitConfigurationPullRequestOutput) ElementType

func (PipelineTriggerAllGitConfigurationPullRequestOutput) Events

A list that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration. Possible values are `OPEN`, ` UPDATED ` and `CLOSED`.

func (PipelineTriggerAllGitConfigurationPullRequestOutput) FilePaths

The field that specifies to filter on file paths for the pull request trigger configuration. A `filePaths` block is documented below.

func (PipelineTriggerAllGitConfigurationPullRequestOutput) ToPipelineTriggerAllGitConfigurationPullRequestOutput

func (o PipelineTriggerAllGitConfigurationPullRequestOutput) ToPipelineTriggerAllGitConfigurationPullRequestOutput() PipelineTriggerAllGitConfigurationPullRequestOutput

func (PipelineTriggerAllGitConfigurationPullRequestOutput) ToPipelineTriggerAllGitConfigurationPullRequestOutputWithContext

func (o PipelineTriggerAllGitConfigurationPullRequestOutput) ToPipelineTriggerAllGitConfigurationPullRequestOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPullRequestOutput

type PipelineTriggerAllGitConfigurationPush

type PipelineTriggerAllGitConfigurationPush struct {
	// The field that specifies to filter on branches for the push trigger configuration. A `branches` block is documented below.
	Branches []PipelineTriggerAllGitConfigurationPushBranch `pulumi:"branches"`
	// The field that specifies to filter on file paths for the push trigger configuration. A `filePaths` block is documented below.
	FilePaths []PipelineTriggerAllGitConfigurationPushFilePath `pulumi:"filePaths"`
	// The field that contains the details for the Git tags trigger configuration. A `tags` block is documented below.
	Tags []PipelineTriggerAllGitConfigurationPushTag `pulumi:"tags"`
}

type PipelineTriggerAllGitConfigurationPushArgs

type PipelineTriggerAllGitConfigurationPushArgs struct {
	// The field that specifies to filter on branches for the push trigger configuration. A `branches` block is documented below.
	Branches PipelineTriggerAllGitConfigurationPushBranchArrayInput `pulumi:"branches"`
	// The field that specifies to filter on file paths for the push trigger configuration. A `filePaths` block is documented below.
	FilePaths PipelineTriggerAllGitConfigurationPushFilePathArrayInput `pulumi:"filePaths"`
	// The field that contains the details for the Git tags trigger configuration. A `tags` block is documented below.
	Tags PipelineTriggerAllGitConfigurationPushTagArrayInput `pulumi:"tags"`
}

func (PipelineTriggerAllGitConfigurationPushArgs) ElementType

func (PipelineTriggerAllGitConfigurationPushArgs) ToPipelineTriggerAllGitConfigurationPushOutput

func (i PipelineTriggerAllGitConfigurationPushArgs) ToPipelineTriggerAllGitConfigurationPushOutput() PipelineTriggerAllGitConfigurationPushOutput

func (PipelineTriggerAllGitConfigurationPushArgs) ToPipelineTriggerAllGitConfigurationPushOutputWithContext

func (i PipelineTriggerAllGitConfigurationPushArgs) ToPipelineTriggerAllGitConfigurationPushOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushOutput

type PipelineTriggerAllGitConfigurationPushArray

type PipelineTriggerAllGitConfigurationPushArray []PipelineTriggerAllGitConfigurationPushInput

func (PipelineTriggerAllGitConfigurationPushArray) ElementType

func (PipelineTriggerAllGitConfigurationPushArray) ToPipelineTriggerAllGitConfigurationPushArrayOutput

func (i PipelineTriggerAllGitConfigurationPushArray) ToPipelineTriggerAllGitConfigurationPushArrayOutput() PipelineTriggerAllGitConfigurationPushArrayOutput

func (PipelineTriggerAllGitConfigurationPushArray) ToPipelineTriggerAllGitConfigurationPushArrayOutputWithContext

func (i PipelineTriggerAllGitConfigurationPushArray) ToPipelineTriggerAllGitConfigurationPushArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushArrayOutput

type PipelineTriggerAllGitConfigurationPushArrayInput

type PipelineTriggerAllGitConfigurationPushArrayInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPushArrayOutput() PipelineTriggerAllGitConfigurationPushArrayOutput
	ToPipelineTriggerAllGitConfigurationPushArrayOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPushArrayOutput
}

PipelineTriggerAllGitConfigurationPushArrayInput is an input type that accepts PipelineTriggerAllGitConfigurationPushArray and PipelineTriggerAllGitConfigurationPushArrayOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPushArrayInput` via:

PipelineTriggerAllGitConfigurationPushArray{ PipelineTriggerAllGitConfigurationPushArgs{...} }

type PipelineTriggerAllGitConfigurationPushArrayOutput

type PipelineTriggerAllGitConfigurationPushArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPushArrayOutput) ElementType

func (PipelineTriggerAllGitConfigurationPushArrayOutput) Index

func (PipelineTriggerAllGitConfigurationPushArrayOutput) ToPipelineTriggerAllGitConfigurationPushArrayOutput

func (o PipelineTriggerAllGitConfigurationPushArrayOutput) ToPipelineTriggerAllGitConfigurationPushArrayOutput() PipelineTriggerAllGitConfigurationPushArrayOutput

func (PipelineTriggerAllGitConfigurationPushArrayOutput) ToPipelineTriggerAllGitConfigurationPushArrayOutputWithContext

func (o PipelineTriggerAllGitConfigurationPushArrayOutput) ToPipelineTriggerAllGitConfigurationPushArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushArrayOutput

type PipelineTriggerAllGitConfigurationPushBranch

type PipelineTriggerAllGitConfigurationPushBranch struct {
	// A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerAllGitConfigurationPushBranchArgs

type PipelineTriggerAllGitConfigurationPushBranchArgs struct {
	// A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerAllGitConfigurationPushBranchArgs) ElementType

func (PipelineTriggerAllGitConfigurationPushBranchArgs) ToPipelineTriggerAllGitConfigurationPushBranchOutput

func (i PipelineTriggerAllGitConfigurationPushBranchArgs) ToPipelineTriggerAllGitConfigurationPushBranchOutput() PipelineTriggerAllGitConfigurationPushBranchOutput

func (PipelineTriggerAllGitConfigurationPushBranchArgs) ToPipelineTriggerAllGitConfigurationPushBranchOutputWithContext

func (i PipelineTriggerAllGitConfigurationPushBranchArgs) ToPipelineTriggerAllGitConfigurationPushBranchOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushBranchOutput

type PipelineTriggerAllGitConfigurationPushBranchArray

type PipelineTriggerAllGitConfigurationPushBranchArray []PipelineTriggerAllGitConfigurationPushBranchInput

func (PipelineTriggerAllGitConfigurationPushBranchArray) ElementType

func (PipelineTriggerAllGitConfigurationPushBranchArray) ToPipelineTriggerAllGitConfigurationPushBranchArrayOutput

func (i PipelineTriggerAllGitConfigurationPushBranchArray) ToPipelineTriggerAllGitConfigurationPushBranchArrayOutput() PipelineTriggerAllGitConfigurationPushBranchArrayOutput

func (PipelineTriggerAllGitConfigurationPushBranchArray) ToPipelineTriggerAllGitConfigurationPushBranchArrayOutputWithContext

func (i PipelineTriggerAllGitConfigurationPushBranchArray) ToPipelineTriggerAllGitConfigurationPushBranchArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushBranchArrayOutput

type PipelineTriggerAllGitConfigurationPushBranchArrayInput

type PipelineTriggerAllGitConfigurationPushBranchArrayInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPushBranchArrayOutput() PipelineTriggerAllGitConfigurationPushBranchArrayOutput
	ToPipelineTriggerAllGitConfigurationPushBranchArrayOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPushBranchArrayOutput
}

PipelineTriggerAllGitConfigurationPushBranchArrayInput is an input type that accepts PipelineTriggerAllGitConfigurationPushBranchArray and PipelineTriggerAllGitConfigurationPushBranchArrayOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPushBranchArrayInput` via:

PipelineTriggerAllGitConfigurationPushBranchArray{ PipelineTriggerAllGitConfigurationPushBranchArgs{...} }

type PipelineTriggerAllGitConfigurationPushBranchArrayOutput

type PipelineTriggerAllGitConfigurationPushBranchArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPushBranchArrayOutput) ElementType

func (PipelineTriggerAllGitConfigurationPushBranchArrayOutput) Index

func (PipelineTriggerAllGitConfigurationPushBranchArrayOutput) ToPipelineTriggerAllGitConfigurationPushBranchArrayOutput

func (PipelineTriggerAllGitConfigurationPushBranchArrayOutput) ToPipelineTriggerAllGitConfigurationPushBranchArrayOutputWithContext

func (o PipelineTriggerAllGitConfigurationPushBranchArrayOutput) ToPipelineTriggerAllGitConfigurationPushBranchArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushBranchArrayOutput

type PipelineTriggerAllGitConfigurationPushBranchInput

type PipelineTriggerAllGitConfigurationPushBranchInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPushBranchOutput() PipelineTriggerAllGitConfigurationPushBranchOutput
	ToPipelineTriggerAllGitConfigurationPushBranchOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPushBranchOutput
}

PipelineTriggerAllGitConfigurationPushBranchInput is an input type that accepts PipelineTriggerAllGitConfigurationPushBranchArgs and PipelineTriggerAllGitConfigurationPushBranchOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPushBranchInput` via:

PipelineTriggerAllGitConfigurationPushBranchArgs{...}

type PipelineTriggerAllGitConfigurationPushBranchOutput

type PipelineTriggerAllGitConfigurationPushBranchOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPushBranchOutput) ElementType

func (PipelineTriggerAllGitConfigurationPushBranchOutput) Excludes

A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerAllGitConfigurationPushBranchOutput) Includes

A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerAllGitConfigurationPushBranchOutput) ToPipelineTriggerAllGitConfigurationPushBranchOutput

func (o PipelineTriggerAllGitConfigurationPushBranchOutput) ToPipelineTriggerAllGitConfigurationPushBranchOutput() PipelineTriggerAllGitConfigurationPushBranchOutput

func (PipelineTriggerAllGitConfigurationPushBranchOutput) ToPipelineTriggerAllGitConfigurationPushBranchOutputWithContext

func (o PipelineTriggerAllGitConfigurationPushBranchOutput) ToPipelineTriggerAllGitConfigurationPushBranchOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushBranchOutput

type PipelineTriggerAllGitConfigurationPushFilePath

type PipelineTriggerAllGitConfigurationPushFilePath struct {
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerAllGitConfigurationPushFilePathArgs

type PipelineTriggerAllGitConfigurationPushFilePathArgs struct {
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerAllGitConfigurationPushFilePathArgs) ElementType

func (PipelineTriggerAllGitConfigurationPushFilePathArgs) ToPipelineTriggerAllGitConfigurationPushFilePathOutput

func (i PipelineTriggerAllGitConfigurationPushFilePathArgs) ToPipelineTriggerAllGitConfigurationPushFilePathOutput() PipelineTriggerAllGitConfigurationPushFilePathOutput

func (PipelineTriggerAllGitConfigurationPushFilePathArgs) ToPipelineTriggerAllGitConfigurationPushFilePathOutputWithContext

func (i PipelineTriggerAllGitConfigurationPushFilePathArgs) ToPipelineTriggerAllGitConfigurationPushFilePathOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushFilePathOutput

type PipelineTriggerAllGitConfigurationPushFilePathArray

type PipelineTriggerAllGitConfigurationPushFilePathArray []PipelineTriggerAllGitConfigurationPushFilePathInput

func (PipelineTriggerAllGitConfigurationPushFilePathArray) ElementType

func (PipelineTriggerAllGitConfigurationPushFilePathArray) ToPipelineTriggerAllGitConfigurationPushFilePathArrayOutput

func (i PipelineTriggerAllGitConfigurationPushFilePathArray) ToPipelineTriggerAllGitConfigurationPushFilePathArrayOutput() PipelineTriggerAllGitConfigurationPushFilePathArrayOutput

func (PipelineTriggerAllGitConfigurationPushFilePathArray) ToPipelineTriggerAllGitConfigurationPushFilePathArrayOutputWithContext

func (i PipelineTriggerAllGitConfigurationPushFilePathArray) ToPipelineTriggerAllGitConfigurationPushFilePathArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushFilePathArrayOutput

type PipelineTriggerAllGitConfigurationPushFilePathArrayInput

type PipelineTriggerAllGitConfigurationPushFilePathArrayInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPushFilePathArrayOutput() PipelineTriggerAllGitConfigurationPushFilePathArrayOutput
	ToPipelineTriggerAllGitConfigurationPushFilePathArrayOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPushFilePathArrayOutput
}

PipelineTriggerAllGitConfigurationPushFilePathArrayInput is an input type that accepts PipelineTriggerAllGitConfigurationPushFilePathArray and PipelineTriggerAllGitConfigurationPushFilePathArrayOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPushFilePathArrayInput` via:

PipelineTriggerAllGitConfigurationPushFilePathArray{ PipelineTriggerAllGitConfigurationPushFilePathArgs{...} }

type PipelineTriggerAllGitConfigurationPushFilePathArrayOutput

type PipelineTriggerAllGitConfigurationPushFilePathArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPushFilePathArrayOutput) ElementType

func (PipelineTriggerAllGitConfigurationPushFilePathArrayOutput) Index

func (PipelineTriggerAllGitConfigurationPushFilePathArrayOutput) ToPipelineTriggerAllGitConfigurationPushFilePathArrayOutput

func (PipelineTriggerAllGitConfigurationPushFilePathArrayOutput) ToPipelineTriggerAllGitConfigurationPushFilePathArrayOutputWithContext

func (o PipelineTriggerAllGitConfigurationPushFilePathArrayOutput) ToPipelineTriggerAllGitConfigurationPushFilePathArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushFilePathArrayOutput

type PipelineTriggerAllGitConfigurationPushFilePathInput

type PipelineTriggerAllGitConfigurationPushFilePathInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPushFilePathOutput() PipelineTriggerAllGitConfigurationPushFilePathOutput
	ToPipelineTriggerAllGitConfigurationPushFilePathOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPushFilePathOutput
}

PipelineTriggerAllGitConfigurationPushFilePathInput is an input type that accepts PipelineTriggerAllGitConfigurationPushFilePathArgs and PipelineTriggerAllGitConfigurationPushFilePathOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPushFilePathInput` via:

PipelineTriggerAllGitConfigurationPushFilePathArgs{...}

type PipelineTriggerAllGitConfigurationPushFilePathOutput

type PipelineTriggerAllGitConfigurationPushFilePathOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPushFilePathOutput) ElementType

func (PipelineTriggerAllGitConfigurationPushFilePathOutput) Excludes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerAllGitConfigurationPushFilePathOutput) Includes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerAllGitConfigurationPushFilePathOutput) ToPipelineTriggerAllGitConfigurationPushFilePathOutput

func (PipelineTriggerAllGitConfigurationPushFilePathOutput) ToPipelineTriggerAllGitConfigurationPushFilePathOutputWithContext

func (o PipelineTriggerAllGitConfigurationPushFilePathOutput) ToPipelineTriggerAllGitConfigurationPushFilePathOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushFilePathOutput

type PipelineTriggerAllGitConfigurationPushInput

type PipelineTriggerAllGitConfigurationPushInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPushOutput() PipelineTriggerAllGitConfigurationPushOutput
	ToPipelineTriggerAllGitConfigurationPushOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPushOutput
}

PipelineTriggerAllGitConfigurationPushInput is an input type that accepts PipelineTriggerAllGitConfigurationPushArgs and PipelineTriggerAllGitConfigurationPushOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPushInput` via:

PipelineTriggerAllGitConfigurationPushArgs{...}

type PipelineTriggerAllGitConfigurationPushOutput

type PipelineTriggerAllGitConfigurationPushOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPushOutput) Branches

The field that specifies to filter on branches for the push trigger configuration. A `branches` block is documented below.

func (PipelineTriggerAllGitConfigurationPushOutput) ElementType

func (PipelineTriggerAllGitConfigurationPushOutput) FilePaths

The field that specifies to filter on file paths for the push trigger configuration. A `filePaths` block is documented below.

func (PipelineTriggerAllGitConfigurationPushOutput) Tags

The field that contains the details for the Git tags trigger configuration. A `tags` block is documented below.

func (PipelineTriggerAllGitConfigurationPushOutput) ToPipelineTriggerAllGitConfigurationPushOutput

func (o PipelineTriggerAllGitConfigurationPushOutput) ToPipelineTriggerAllGitConfigurationPushOutput() PipelineTriggerAllGitConfigurationPushOutput

func (PipelineTriggerAllGitConfigurationPushOutput) ToPipelineTriggerAllGitConfigurationPushOutputWithContext

func (o PipelineTriggerAllGitConfigurationPushOutput) ToPipelineTriggerAllGitConfigurationPushOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushOutput

type PipelineTriggerAllGitConfigurationPushTag

type PipelineTriggerAllGitConfigurationPushTag struct {
	// A list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerAllGitConfigurationPushTagArgs

type PipelineTriggerAllGitConfigurationPushTagArgs struct {
	// A list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerAllGitConfigurationPushTagArgs) ElementType

func (PipelineTriggerAllGitConfigurationPushTagArgs) ToPipelineTriggerAllGitConfigurationPushTagOutput

func (i PipelineTriggerAllGitConfigurationPushTagArgs) ToPipelineTriggerAllGitConfigurationPushTagOutput() PipelineTriggerAllGitConfigurationPushTagOutput

func (PipelineTriggerAllGitConfigurationPushTagArgs) ToPipelineTriggerAllGitConfigurationPushTagOutputWithContext

func (i PipelineTriggerAllGitConfigurationPushTagArgs) ToPipelineTriggerAllGitConfigurationPushTagOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushTagOutput

type PipelineTriggerAllGitConfigurationPushTagArray

type PipelineTriggerAllGitConfigurationPushTagArray []PipelineTriggerAllGitConfigurationPushTagInput

func (PipelineTriggerAllGitConfigurationPushTagArray) ElementType

func (PipelineTriggerAllGitConfigurationPushTagArray) ToPipelineTriggerAllGitConfigurationPushTagArrayOutput

func (i PipelineTriggerAllGitConfigurationPushTagArray) ToPipelineTriggerAllGitConfigurationPushTagArrayOutput() PipelineTriggerAllGitConfigurationPushTagArrayOutput

func (PipelineTriggerAllGitConfigurationPushTagArray) ToPipelineTriggerAllGitConfigurationPushTagArrayOutputWithContext

func (i PipelineTriggerAllGitConfigurationPushTagArray) ToPipelineTriggerAllGitConfigurationPushTagArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushTagArrayOutput

type PipelineTriggerAllGitConfigurationPushTagArrayInput

type PipelineTriggerAllGitConfigurationPushTagArrayInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPushTagArrayOutput() PipelineTriggerAllGitConfigurationPushTagArrayOutput
	ToPipelineTriggerAllGitConfigurationPushTagArrayOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPushTagArrayOutput
}

PipelineTriggerAllGitConfigurationPushTagArrayInput is an input type that accepts PipelineTriggerAllGitConfigurationPushTagArray and PipelineTriggerAllGitConfigurationPushTagArrayOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPushTagArrayInput` via:

PipelineTriggerAllGitConfigurationPushTagArray{ PipelineTriggerAllGitConfigurationPushTagArgs{...} }

type PipelineTriggerAllGitConfigurationPushTagArrayOutput

type PipelineTriggerAllGitConfigurationPushTagArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPushTagArrayOutput) ElementType

func (PipelineTriggerAllGitConfigurationPushTagArrayOutput) Index

func (PipelineTriggerAllGitConfigurationPushTagArrayOutput) ToPipelineTriggerAllGitConfigurationPushTagArrayOutput

func (PipelineTriggerAllGitConfigurationPushTagArrayOutput) ToPipelineTriggerAllGitConfigurationPushTagArrayOutputWithContext

func (o PipelineTriggerAllGitConfigurationPushTagArrayOutput) ToPipelineTriggerAllGitConfigurationPushTagArrayOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushTagArrayOutput

type PipelineTriggerAllGitConfigurationPushTagInput

type PipelineTriggerAllGitConfigurationPushTagInput interface {
	pulumi.Input

	ToPipelineTriggerAllGitConfigurationPushTagOutput() PipelineTriggerAllGitConfigurationPushTagOutput
	ToPipelineTriggerAllGitConfigurationPushTagOutputWithContext(context.Context) PipelineTriggerAllGitConfigurationPushTagOutput
}

PipelineTriggerAllGitConfigurationPushTagInput is an input type that accepts PipelineTriggerAllGitConfigurationPushTagArgs and PipelineTriggerAllGitConfigurationPushTagOutput values. You can construct a concrete instance of `PipelineTriggerAllGitConfigurationPushTagInput` via:

PipelineTriggerAllGitConfigurationPushTagArgs{...}

type PipelineTriggerAllGitConfigurationPushTagOutput

type PipelineTriggerAllGitConfigurationPushTagOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllGitConfigurationPushTagOutput) ElementType

func (PipelineTriggerAllGitConfigurationPushTagOutput) Excludes

A list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerAllGitConfigurationPushTagOutput) Includes

A list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerAllGitConfigurationPushTagOutput) ToPipelineTriggerAllGitConfigurationPushTagOutput

func (o PipelineTriggerAllGitConfigurationPushTagOutput) ToPipelineTriggerAllGitConfigurationPushTagOutput() PipelineTriggerAllGitConfigurationPushTagOutput

func (PipelineTriggerAllGitConfigurationPushTagOutput) ToPipelineTriggerAllGitConfigurationPushTagOutputWithContext

func (o PipelineTriggerAllGitConfigurationPushTagOutput) ToPipelineTriggerAllGitConfigurationPushTagOutputWithContext(ctx context.Context) PipelineTriggerAllGitConfigurationPushTagOutput

type PipelineTriggerAllInput

type PipelineTriggerAllInput interface {
	pulumi.Input

	ToPipelineTriggerAllOutput() PipelineTriggerAllOutput
	ToPipelineTriggerAllOutputWithContext(context.Context) PipelineTriggerAllOutput
}

PipelineTriggerAllInput is an input type that accepts PipelineTriggerAllArgs and PipelineTriggerAllOutput values. You can construct a concrete instance of `PipelineTriggerAllInput` via:

PipelineTriggerAllArgs{...}

type PipelineTriggerAllOutput

type PipelineTriggerAllOutput struct{ *pulumi.OutputState }

func (PipelineTriggerAllOutput) ElementType

func (PipelineTriggerAllOutput) ElementType() reflect.Type

func (PipelineTriggerAllOutput) GitConfigurations

Provides the filter criteria and the source stage for the repository event that starts the pipeline. For more information, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-filter.html). A `gitConfiguration` block is documented below.

func (PipelineTriggerAllOutput) ProviderType

The source provider for the event. Possible value is `CodeStarSourceConnection`.

func (PipelineTriggerAllOutput) ToPipelineTriggerAllOutput

func (o PipelineTriggerAllOutput) ToPipelineTriggerAllOutput() PipelineTriggerAllOutput

func (PipelineTriggerAllOutput) ToPipelineTriggerAllOutputWithContext

func (o PipelineTriggerAllOutput) ToPipelineTriggerAllOutputWithContext(ctx context.Context) PipelineTriggerAllOutput

type PipelineTriggerArgs

type PipelineTriggerArgs struct {
	// Provides the filter criteria and the source stage for the repository event that starts the pipeline. For more information, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-filter.html). A `gitConfiguration` block is documented below.
	GitConfiguration PipelineTriggerGitConfigurationInput `pulumi:"gitConfiguration"`
	// The source provider for the event. Possible value is `CodeStarSourceConnection`.
	ProviderType pulumi.StringInput `pulumi:"providerType"`
}

func (PipelineTriggerArgs) ElementType

func (PipelineTriggerArgs) ElementType() reflect.Type

func (PipelineTriggerArgs) ToPipelineTriggerOutput

func (i PipelineTriggerArgs) ToPipelineTriggerOutput() PipelineTriggerOutput

func (PipelineTriggerArgs) ToPipelineTriggerOutputWithContext

func (i PipelineTriggerArgs) ToPipelineTriggerOutputWithContext(ctx context.Context) PipelineTriggerOutput

type PipelineTriggerArray

type PipelineTriggerArray []PipelineTriggerInput

func (PipelineTriggerArray) ElementType

func (PipelineTriggerArray) ElementType() reflect.Type

func (PipelineTriggerArray) ToPipelineTriggerArrayOutput

func (i PipelineTriggerArray) ToPipelineTriggerArrayOutput() PipelineTriggerArrayOutput

func (PipelineTriggerArray) ToPipelineTriggerArrayOutputWithContext

func (i PipelineTriggerArray) ToPipelineTriggerArrayOutputWithContext(ctx context.Context) PipelineTriggerArrayOutput

type PipelineTriggerArrayInput

type PipelineTriggerArrayInput interface {
	pulumi.Input

	ToPipelineTriggerArrayOutput() PipelineTriggerArrayOutput
	ToPipelineTriggerArrayOutputWithContext(context.Context) PipelineTriggerArrayOutput
}

PipelineTriggerArrayInput is an input type that accepts PipelineTriggerArray and PipelineTriggerArrayOutput values. You can construct a concrete instance of `PipelineTriggerArrayInput` via:

PipelineTriggerArray{ PipelineTriggerArgs{...} }

type PipelineTriggerArrayOutput

type PipelineTriggerArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerArrayOutput) ElementType

func (PipelineTriggerArrayOutput) ElementType() reflect.Type

func (PipelineTriggerArrayOutput) Index

func (PipelineTriggerArrayOutput) ToPipelineTriggerArrayOutput

func (o PipelineTriggerArrayOutput) ToPipelineTriggerArrayOutput() PipelineTriggerArrayOutput

func (PipelineTriggerArrayOutput) ToPipelineTriggerArrayOutputWithContext

func (o PipelineTriggerArrayOutput) ToPipelineTriggerArrayOutputWithContext(ctx context.Context) PipelineTriggerArrayOutput

type PipelineTriggerGitConfiguration

type PipelineTriggerGitConfiguration struct {
	// The field where the repository event that will start the pipeline is specified as pull requests. A `pullRequest` block is documented below.
	PullRequests []PipelineTriggerGitConfigurationPullRequest `pulumi:"pullRequests"`
	// The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. A `push` block is documented below.
	Pushes []PipelineTriggerGitConfigurationPush `pulumi:"pushes"`
	// The name of the pipeline source action where the trigger configuration, such as Git tags, is specified. The trigger configuration will start the pipeline upon the specified change only.
	SourceActionName string `pulumi:"sourceActionName"`
}

type PipelineTriggerGitConfigurationArgs

type PipelineTriggerGitConfigurationArgs struct {
	// The field where the repository event that will start the pipeline is specified as pull requests. A `pullRequest` block is documented below.
	PullRequests PipelineTriggerGitConfigurationPullRequestArrayInput `pulumi:"pullRequests"`
	// The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. A `push` block is documented below.
	Pushes PipelineTriggerGitConfigurationPushArrayInput `pulumi:"pushes"`
	// The name of the pipeline source action where the trigger configuration, such as Git tags, is specified. The trigger configuration will start the pipeline upon the specified change only.
	SourceActionName pulumi.StringInput `pulumi:"sourceActionName"`
}

func (PipelineTriggerGitConfigurationArgs) ElementType

func (PipelineTriggerGitConfigurationArgs) ToPipelineTriggerGitConfigurationOutput

func (i PipelineTriggerGitConfigurationArgs) ToPipelineTriggerGitConfigurationOutput() PipelineTriggerGitConfigurationOutput

func (PipelineTriggerGitConfigurationArgs) ToPipelineTriggerGitConfigurationOutputWithContext

func (i PipelineTriggerGitConfigurationArgs) ToPipelineTriggerGitConfigurationOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationOutput

type PipelineTriggerGitConfigurationInput

type PipelineTriggerGitConfigurationInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationOutput() PipelineTriggerGitConfigurationOutput
	ToPipelineTriggerGitConfigurationOutputWithContext(context.Context) PipelineTriggerGitConfigurationOutput
}

PipelineTriggerGitConfigurationInput is an input type that accepts PipelineTriggerGitConfigurationArgs and PipelineTriggerGitConfigurationOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationInput` via:

PipelineTriggerGitConfigurationArgs{...}

type PipelineTriggerGitConfigurationOutput

type PipelineTriggerGitConfigurationOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationOutput) ElementType

func (PipelineTriggerGitConfigurationOutput) PullRequests

The field where the repository event that will start the pipeline is specified as pull requests. A `pullRequest` block is documented below.

func (PipelineTriggerGitConfigurationOutput) Pushes

The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. A `push` block is documented below.

func (PipelineTriggerGitConfigurationOutput) SourceActionName

The name of the pipeline source action where the trigger configuration, such as Git tags, is specified. The trigger configuration will start the pipeline upon the specified change only.

func (PipelineTriggerGitConfigurationOutput) ToPipelineTriggerGitConfigurationOutput

func (o PipelineTriggerGitConfigurationOutput) ToPipelineTriggerGitConfigurationOutput() PipelineTriggerGitConfigurationOutput

func (PipelineTriggerGitConfigurationOutput) ToPipelineTriggerGitConfigurationOutputWithContext

func (o PipelineTriggerGitConfigurationOutput) ToPipelineTriggerGitConfigurationOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationOutput

type PipelineTriggerGitConfigurationPullRequest

type PipelineTriggerGitConfigurationPullRequest struct {
	// The field that specifies to filter on branches for the pull request trigger configuration. A `branches` block is documented below.
	Branches *PipelineTriggerGitConfigurationPullRequestBranches `pulumi:"branches"`
	// A list that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration. Possible values are `OPEN`, ` UPDATED  ` and `CLOSED`.
	Events []string `pulumi:"events"`
	// The field that specifies to filter on file paths for the pull request trigger configuration. A `filePaths` block is documented below.
	FilePaths *PipelineTriggerGitConfigurationPullRequestFilePaths `pulumi:"filePaths"`
}

type PipelineTriggerGitConfigurationPullRequestArgs

type PipelineTriggerGitConfigurationPullRequestArgs struct {
	// The field that specifies to filter on branches for the pull request trigger configuration. A `branches` block is documented below.
	Branches PipelineTriggerGitConfigurationPullRequestBranchesPtrInput `pulumi:"branches"`
	// A list that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration. Possible values are `OPEN`, ` UPDATED  ` and `CLOSED`.
	Events pulumi.StringArrayInput `pulumi:"events"`
	// The field that specifies to filter on file paths for the pull request trigger configuration. A `filePaths` block is documented below.
	FilePaths PipelineTriggerGitConfigurationPullRequestFilePathsPtrInput `pulumi:"filePaths"`
}

func (PipelineTriggerGitConfigurationPullRequestArgs) ElementType

func (PipelineTriggerGitConfigurationPullRequestArgs) ToPipelineTriggerGitConfigurationPullRequestOutput

func (i PipelineTriggerGitConfigurationPullRequestArgs) ToPipelineTriggerGitConfigurationPullRequestOutput() PipelineTriggerGitConfigurationPullRequestOutput

func (PipelineTriggerGitConfigurationPullRequestArgs) ToPipelineTriggerGitConfigurationPullRequestOutputWithContext

func (i PipelineTriggerGitConfigurationPullRequestArgs) ToPipelineTriggerGitConfigurationPullRequestOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestOutput

type PipelineTriggerGitConfigurationPullRequestArray

type PipelineTriggerGitConfigurationPullRequestArray []PipelineTriggerGitConfigurationPullRequestInput

func (PipelineTriggerGitConfigurationPullRequestArray) ElementType

func (PipelineTriggerGitConfigurationPullRequestArray) ToPipelineTriggerGitConfigurationPullRequestArrayOutput

func (i PipelineTriggerGitConfigurationPullRequestArray) ToPipelineTriggerGitConfigurationPullRequestArrayOutput() PipelineTriggerGitConfigurationPullRequestArrayOutput

func (PipelineTriggerGitConfigurationPullRequestArray) ToPipelineTriggerGitConfigurationPullRequestArrayOutputWithContext

func (i PipelineTriggerGitConfigurationPullRequestArray) ToPipelineTriggerGitConfigurationPullRequestArrayOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestArrayOutput

type PipelineTriggerGitConfigurationPullRequestArrayInput

type PipelineTriggerGitConfigurationPullRequestArrayInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPullRequestArrayOutput() PipelineTriggerGitConfigurationPullRequestArrayOutput
	ToPipelineTriggerGitConfigurationPullRequestArrayOutputWithContext(context.Context) PipelineTriggerGitConfigurationPullRequestArrayOutput
}

PipelineTriggerGitConfigurationPullRequestArrayInput is an input type that accepts PipelineTriggerGitConfigurationPullRequestArray and PipelineTriggerGitConfigurationPullRequestArrayOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPullRequestArrayInput` via:

PipelineTriggerGitConfigurationPullRequestArray{ PipelineTriggerGitConfigurationPullRequestArgs{...} }

type PipelineTriggerGitConfigurationPullRequestArrayOutput

type PipelineTriggerGitConfigurationPullRequestArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPullRequestArrayOutput) ElementType

func (PipelineTriggerGitConfigurationPullRequestArrayOutput) Index

func (PipelineTriggerGitConfigurationPullRequestArrayOutput) ToPipelineTriggerGitConfigurationPullRequestArrayOutput

func (PipelineTriggerGitConfigurationPullRequestArrayOutput) ToPipelineTriggerGitConfigurationPullRequestArrayOutputWithContext

func (o PipelineTriggerGitConfigurationPullRequestArrayOutput) ToPipelineTriggerGitConfigurationPullRequestArrayOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestArrayOutput

type PipelineTriggerGitConfigurationPullRequestBranches

type PipelineTriggerGitConfigurationPullRequestBranches struct {
	// A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerGitConfigurationPullRequestBranchesArgs

type PipelineTriggerGitConfigurationPullRequestBranchesArgs struct {
	// A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerGitConfigurationPullRequestBranchesArgs) ElementType

func (PipelineTriggerGitConfigurationPullRequestBranchesArgs) ToPipelineTriggerGitConfigurationPullRequestBranchesOutput

func (PipelineTriggerGitConfigurationPullRequestBranchesArgs) ToPipelineTriggerGitConfigurationPullRequestBranchesOutputWithContext

func (i PipelineTriggerGitConfigurationPullRequestBranchesArgs) ToPipelineTriggerGitConfigurationPullRequestBranchesOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestBranchesOutput

func (PipelineTriggerGitConfigurationPullRequestBranchesArgs) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutput

func (i PipelineTriggerGitConfigurationPullRequestBranchesArgs) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutput() PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput

func (PipelineTriggerGitConfigurationPullRequestBranchesArgs) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutputWithContext

func (i PipelineTriggerGitConfigurationPullRequestBranchesArgs) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput

type PipelineTriggerGitConfigurationPullRequestBranchesInput

type PipelineTriggerGitConfigurationPullRequestBranchesInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPullRequestBranchesOutput() PipelineTriggerGitConfigurationPullRequestBranchesOutput
	ToPipelineTriggerGitConfigurationPullRequestBranchesOutputWithContext(context.Context) PipelineTriggerGitConfigurationPullRequestBranchesOutput
}

PipelineTriggerGitConfigurationPullRequestBranchesInput is an input type that accepts PipelineTriggerGitConfigurationPullRequestBranchesArgs and PipelineTriggerGitConfigurationPullRequestBranchesOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPullRequestBranchesInput` via:

PipelineTriggerGitConfigurationPullRequestBranchesArgs{...}

type PipelineTriggerGitConfigurationPullRequestBranchesOutput

type PipelineTriggerGitConfigurationPullRequestBranchesOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPullRequestBranchesOutput) ElementType

func (PipelineTriggerGitConfigurationPullRequestBranchesOutput) Excludes

A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPullRequestBranchesOutput) Includes

A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPullRequestBranchesOutput) ToPipelineTriggerGitConfigurationPullRequestBranchesOutput

func (PipelineTriggerGitConfigurationPullRequestBranchesOutput) ToPipelineTriggerGitConfigurationPullRequestBranchesOutputWithContext

func (o PipelineTriggerGitConfigurationPullRequestBranchesOutput) ToPipelineTriggerGitConfigurationPullRequestBranchesOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestBranchesOutput

func (PipelineTriggerGitConfigurationPullRequestBranchesOutput) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutput

func (PipelineTriggerGitConfigurationPullRequestBranchesOutput) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPullRequestBranchesOutput) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput

type PipelineTriggerGitConfigurationPullRequestBranchesPtrInput

type PipelineTriggerGitConfigurationPullRequestBranchesPtrInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutput() PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput
	ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutputWithContext(context.Context) PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput
}

PipelineTriggerGitConfigurationPullRequestBranchesPtrInput is an input type that accepts PipelineTriggerGitConfigurationPullRequestBranchesArgs, PipelineTriggerGitConfigurationPullRequestBranchesPtr and PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPullRequestBranchesPtrInput` via:

        PipelineTriggerGitConfigurationPullRequestBranchesArgs{...}

or:

        nil

type PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput

type PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput) Elem

func (PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput) ElementType

func (PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput) Excludes

A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput) Includes

A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutput

func (PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput) ToPipelineTriggerGitConfigurationPullRequestBranchesPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestBranchesPtrOutput

type PipelineTriggerGitConfigurationPullRequestFilePaths

type PipelineTriggerGitConfigurationPullRequestFilePaths struct {
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerGitConfigurationPullRequestFilePathsArgs

type PipelineTriggerGitConfigurationPullRequestFilePathsArgs struct {
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerGitConfigurationPullRequestFilePathsArgs) ElementType

func (PipelineTriggerGitConfigurationPullRequestFilePathsArgs) ToPipelineTriggerGitConfigurationPullRequestFilePathsOutput

func (PipelineTriggerGitConfigurationPullRequestFilePathsArgs) ToPipelineTriggerGitConfigurationPullRequestFilePathsOutputWithContext

func (i PipelineTriggerGitConfigurationPullRequestFilePathsArgs) ToPipelineTriggerGitConfigurationPullRequestFilePathsOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestFilePathsOutput

func (PipelineTriggerGitConfigurationPullRequestFilePathsArgs) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput

func (i PipelineTriggerGitConfigurationPullRequestFilePathsArgs) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput() PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput

func (PipelineTriggerGitConfigurationPullRequestFilePathsArgs) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutputWithContext

func (i PipelineTriggerGitConfigurationPullRequestFilePathsArgs) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput

type PipelineTriggerGitConfigurationPullRequestFilePathsInput

type PipelineTriggerGitConfigurationPullRequestFilePathsInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPullRequestFilePathsOutput() PipelineTriggerGitConfigurationPullRequestFilePathsOutput
	ToPipelineTriggerGitConfigurationPullRequestFilePathsOutputWithContext(context.Context) PipelineTriggerGitConfigurationPullRequestFilePathsOutput
}

PipelineTriggerGitConfigurationPullRequestFilePathsInput is an input type that accepts PipelineTriggerGitConfigurationPullRequestFilePathsArgs and PipelineTriggerGitConfigurationPullRequestFilePathsOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPullRequestFilePathsInput` via:

PipelineTriggerGitConfigurationPullRequestFilePathsArgs{...}

type PipelineTriggerGitConfigurationPullRequestFilePathsOutput

type PipelineTriggerGitConfigurationPullRequestFilePathsOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPullRequestFilePathsOutput) ElementType

func (PipelineTriggerGitConfigurationPullRequestFilePathsOutput) Excludes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPullRequestFilePathsOutput) Includes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPullRequestFilePathsOutput) ToPipelineTriggerGitConfigurationPullRequestFilePathsOutput

func (PipelineTriggerGitConfigurationPullRequestFilePathsOutput) ToPipelineTriggerGitConfigurationPullRequestFilePathsOutputWithContext

func (o PipelineTriggerGitConfigurationPullRequestFilePathsOutput) ToPipelineTriggerGitConfigurationPullRequestFilePathsOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestFilePathsOutput

func (PipelineTriggerGitConfigurationPullRequestFilePathsOutput) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput

func (PipelineTriggerGitConfigurationPullRequestFilePathsOutput) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPullRequestFilePathsOutput) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput

type PipelineTriggerGitConfigurationPullRequestFilePathsPtrInput

type PipelineTriggerGitConfigurationPullRequestFilePathsPtrInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput() PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput
	ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutputWithContext(context.Context) PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput
}

PipelineTriggerGitConfigurationPullRequestFilePathsPtrInput is an input type that accepts PipelineTriggerGitConfigurationPullRequestFilePathsArgs, PipelineTriggerGitConfigurationPullRequestFilePathsPtr and PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPullRequestFilePathsPtrInput` via:

        PipelineTriggerGitConfigurationPullRequestFilePathsArgs{...}

or:

        nil

type PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput

type PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput) Elem

func (PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput) ElementType

func (PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput) Excludes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput) Includes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput

func (PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput) ToPipelineTriggerGitConfigurationPullRequestFilePathsPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestFilePathsPtrOutput

type PipelineTriggerGitConfigurationPullRequestInput

type PipelineTriggerGitConfigurationPullRequestInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPullRequestOutput() PipelineTriggerGitConfigurationPullRequestOutput
	ToPipelineTriggerGitConfigurationPullRequestOutputWithContext(context.Context) PipelineTriggerGitConfigurationPullRequestOutput
}

PipelineTriggerGitConfigurationPullRequestInput is an input type that accepts PipelineTriggerGitConfigurationPullRequestArgs and PipelineTriggerGitConfigurationPullRequestOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPullRequestInput` via:

PipelineTriggerGitConfigurationPullRequestArgs{...}

type PipelineTriggerGitConfigurationPullRequestOutput

type PipelineTriggerGitConfigurationPullRequestOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPullRequestOutput) Branches

The field that specifies to filter on branches for the pull request trigger configuration. A `branches` block is documented below.

func (PipelineTriggerGitConfigurationPullRequestOutput) ElementType

func (PipelineTriggerGitConfigurationPullRequestOutput) Events

A list that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration. Possible values are `OPEN`, ` UPDATED ` and `CLOSED`.

func (PipelineTriggerGitConfigurationPullRequestOutput) FilePaths

The field that specifies to filter on file paths for the pull request trigger configuration. A `filePaths` block is documented below.

func (PipelineTriggerGitConfigurationPullRequestOutput) ToPipelineTriggerGitConfigurationPullRequestOutput

func (o PipelineTriggerGitConfigurationPullRequestOutput) ToPipelineTriggerGitConfigurationPullRequestOutput() PipelineTriggerGitConfigurationPullRequestOutput

func (PipelineTriggerGitConfigurationPullRequestOutput) ToPipelineTriggerGitConfigurationPullRequestOutputWithContext

func (o PipelineTriggerGitConfigurationPullRequestOutput) ToPipelineTriggerGitConfigurationPullRequestOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPullRequestOutput

type PipelineTriggerGitConfigurationPush

type PipelineTriggerGitConfigurationPush struct {
	// The field that specifies to filter on branches for the push trigger configuration. A `branches` block is documented below.
	Branches *PipelineTriggerGitConfigurationPushBranches `pulumi:"branches"`
	// The field that specifies to filter on file paths for the push trigger configuration. A `filePaths` block is documented below.
	FilePaths *PipelineTriggerGitConfigurationPushFilePaths `pulumi:"filePaths"`
	// The field that contains the details for the Git tags trigger configuration. A `tags` block is documented below.
	Tags *PipelineTriggerGitConfigurationPushTags `pulumi:"tags"`
}

type PipelineTriggerGitConfigurationPushArgs

type PipelineTriggerGitConfigurationPushArgs struct {
	// The field that specifies to filter on branches for the push trigger configuration. A `branches` block is documented below.
	Branches PipelineTriggerGitConfigurationPushBranchesPtrInput `pulumi:"branches"`
	// The field that specifies to filter on file paths for the push trigger configuration. A `filePaths` block is documented below.
	FilePaths PipelineTriggerGitConfigurationPushFilePathsPtrInput `pulumi:"filePaths"`
	// The field that contains the details for the Git tags trigger configuration. A `tags` block is documented below.
	Tags PipelineTriggerGitConfigurationPushTagsPtrInput `pulumi:"tags"`
}

func (PipelineTriggerGitConfigurationPushArgs) ElementType

func (PipelineTriggerGitConfigurationPushArgs) ToPipelineTriggerGitConfigurationPushOutput

func (i PipelineTriggerGitConfigurationPushArgs) ToPipelineTriggerGitConfigurationPushOutput() PipelineTriggerGitConfigurationPushOutput

func (PipelineTriggerGitConfigurationPushArgs) ToPipelineTriggerGitConfigurationPushOutputWithContext

func (i PipelineTriggerGitConfigurationPushArgs) ToPipelineTriggerGitConfigurationPushOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushOutput

type PipelineTriggerGitConfigurationPushArray

type PipelineTriggerGitConfigurationPushArray []PipelineTriggerGitConfigurationPushInput

func (PipelineTriggerGitConfigurationPushArray) ElementType

func (PipelineTriggerGitConfigurationPushArray) ToPipelineTriggerGitConfigurationPushArrayOutput

func (i PipelineTriggerGitConfigurationPushArray) ToPipelineTriggerGitConfigurationPushArrayOutput() PipelineTriggerGitConfigurationPushArrayOutput

func (PipelineTriggerGitConfigurationPushArray) ToPipelineTriggerGitConfigurationPushArrayOutputWithContext

func (i PipelineTriggerGitConfigurationPushArray) ToPipelineTriggerGitConfigurationPushArrayOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushArrayOutput

type PipelineTriggerGitConfigurationPushArrayInput

type PipelineTriggerGitConfigurationPushArrayInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPushArrayOutput() PipelineTriggerGitConfigurationPushArrayOutput
	ToPipelineTriggerGitConfigurationPushArrayOutputWithContext(context.Context) PipelineTriggerGitConfigurationPushArrayOutput
}

PipelineTriggerGitConfigurationPushArrayInput is an input type that accepts PipelineTriggerGitConfigurationPushArray and PipelineTriggerGitConfigurationPushArrayOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPushArrayInput` via:

PipelineTriggerGitConfigurationPushArray{ PipelineTriggerGitConfigurationPushArgs{...} }

type PipelineTriggerGitConfigurationPushArrayOutput

type PipelineTriggerGitConfigurationPushArrayOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPushArrayOutput) ElementType

func (PipelineTriggerGitConfigurationPushArrayOutput) Index

func (PipelineTriggerGitConfigurationPushArrayOutput) ToPipelineTriggerGitConfigurationPushArrayOutput

func (o PipelineTriggerGitConfigurationPushArrayOutput) ToPipelineTriggerGitConfigurationPushArrayOutput() PipelineTriggerGitConfigurationPushArrayOutput

func (PipelineTriggerGitConfigurationPushArrayOutput) ToPipelineTriggerGitConfigurationPushArrayOutputWithContext

func (o PipelineTriggerGitConfigurationPushArrayOutput) ToPipelineTriggerGitConfigurationPushArrayOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushArrayOutput

type PipelineTriggerGitConfigurationPushBranches

type PipelineTriggerGitConfigurationPushBranches struct {
	// A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerGitConfigurationPushBranchesArgs

type PipelineTriggerGitConfigurationPushBranchesArgs struct {
	// A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerGitConfigurationPushBranchesArgs) ElementType

func (PipelineTriggerGitConfigurationPushBranchesArgs) ToPipelineTriggerGitConfigurationPushBranchesOutput

func (i PipelineTriggerGitConfigurationPushBranchesArgs) ToPipelineTriggerGitConfigurationPushBranchesOutput() PipelineTriggerGitConfigurationPushBranchesOutput

func (PipelineTriggerGitConfigurationPushBranchesArgs) ToPipelineTriggerGitConfigurationPushBranchesOutputWithContext

func (i PipelineTriggerGitConfigurationPushBranchesArgs) ToPipelineTriggerGitConfigurationPushBranchesOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushBranchesOutput

func (PipelineTriggerGitConfigurationPushBranchesArgs) ToPipelineTriggerGitConfigurationPushBranchesPtrOutput

func (i PipelineTriggerGitConfigurationPushBranchesArgs) ToPipelineTriggerGitConfigurationPushBranchesPtrOutput() PipelineTriggerGitConfigurationPushBranchesPtrOutput

func (PipelineTriggerGitConfigurationPushBranchesArgs) ToPipelineTriggerGitConfigurationPushBranchesPtrOutputWithContext

func (i PipelineTriggerGitConfigurationPushBranchesArgs) ToPipelineTriggerGitConfigurationPushBranchesPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushBranchesPtrOutput

type PipelineTriggerGitConfigurationPushBranchesInput

type PipelineTriggerGitConfigurationPushBranchesInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPushBranchesOutput() PipelineTriggerGitConfigurationPushBranchesOutput
	ToPipelineTriggerGitConfigurationPushBranchesOutputWithContext(context.Context) PipelineTriggerGitConfigurationPushBranchesOutput
}

PipelineTriggerGitConfigurationPushBranchesInput is an input type that accepts PipelineTriggerGitConfigurationPushBranchesArgs and PipelineTriggerGitConfigurationPushBranchesOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPushBranchesInput` via:

PipelineTriggerGitConfigurationPushBranchesArgs{...}

type PipelineTriggerGitConfigurationPushBranchesOutput

type PipelineTriggerGitConfigurationPushBranchesOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPushBranchesOutput) ElementType

func (PipelineTriggerGitConfigurationPushBranchesOutput) Excludes

A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPushBranchesOutput) Includes

A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPushBranchesOutput) ToPipelineTriggerGitConfigurationPushBranchesOutput

func (o PipelineTriggerGitConfigurationPushBranchesOutput) ToPipelineTriggerGitConfigurationPushBranchesOutput() PipelineTriggerGitConfigurationPushBranchesOutput

func (PipelineTriggerGitConfigurationPushBranchesOutput) ToPipelineTriggerGitConfigurationPushBranchesOutputWithContext

func (o PipelineTriggerGitConfigurationPushBranchesOutput) ToPipelineTriggerGitConfigurationPushBranchesOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushBranchesOutput

func (PipelineTriggerGitConfigurationPushBranchesOutput) ToPipelineTriggerGitConfigurationPushBranchesPtrOutput

func (o PipelineTriggerGitConfigurationPushBranchesOutput) ToPipelineTriggerGitConfigurationPushBranchesPtrOutput() PipelineTriggerGitConfigurationPushBranchesPtrOutput

func (PipelineTriggerGitConfigurationPushBranchesOutput) ToPipelineTriggerGitConfigurationPushBranchesPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPushBranchesOutput) ToPipelineTriggerGitConfigurationPushBranchesPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushBranchesPtrOutput

type PipelineTriggerGitConfigurationPushBranchesPtrInput

type PipelineTriggerGitConfigurationPushBranchesPtrInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPushBranchesPtrOutput() PipelineTriggerGitConfigurationPushBranchesPtrOutput
	ToPipelineTriggerGitConfigurationPushBranchesPtrOutputWithContext(context.Context) PipelineTriggerGitConfigurationPushBranchesPtrOutput
}

PipelineTriggerGitConfigurationPushBranchesPtrInput is an input type that accepts PipelineTriggerGitConfigurationPushBranchesArgs, PipelineTriggerGitConfigurationPushBranchesPtr and PipelineTriggerGitConfigurationPushBranchesPtrOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPushBranchesPtrInput` via:

        PipelineTriggerGitConfigurationPushBranchesArgs{...}

or:

        nil

type PipelineTriggerGitConfigurationPushBranchesPtrOutput

type PipelineTriggerGitConfigurationPushBranchesPtrOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPushBranchesPtrOutput) Elem

func (PipelineTriggerGitConfigurationPushBranchesPtrOutput) ElementType

func (PipelineTriggerGitConfigurationPushBranchesPtrOutput) Excludes

A list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPushBranchesPtrOutput) Includes

A list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPushBranchesPtrOutput) ToPipelineTriggerGitConfigurationPushBranchesPtrOutput

func (PipelineTriggerGitConfigurationPushBranchesPtrOutput) ToPipelineTriggerGitConfigurationPushBranchesPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPushBranchesPtrOutput) ToPipelineTriggerGitConfigurationPushBranchesPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushBranchesPtrOutput

type PipelineTriggerGitConfigurationPushFilePaths

type PipelineTriggerGitConfigurationPushFilePaths struct {
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerGitConfigurationPushFilePathsArgs

type PipelineTriggerGitConfigurationPushFilePathsArgs struct {
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerGitConfigurationPushFilePathsArgs) ElementType

func (PipelineTriggerGitConfigurationPushFilePathsArgs) ToPipelineTriggerGitConfigurationPushFilePathsOutput

func (i PipelineTriggerGitConfigurationPushFilePathsArgs) ToPipelineTriggerGitConfigurationPushFilePathsOutput() PipelineTriggerGitConfigurationPushFilePathsOutput

func (PipelineTriggerGitConfigurationPushFilePathsArgs) ToPipelineTriggerGitConfigurationPushFilePathsOutputWithContext

func (i PipelineTriggerGitConfigurationPushFilePathsArgs) ToPipelineTriggerGitConfigurationPushFilePathsOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushFilePathsOutput

func (PipelineTriggerGitConfigurationPushFilePathsArgs) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutput

func (i PipelineTriggerGitConfigurationPushFilePathsArgs) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutput() PipelineTriggerGitConfigurationPushFilePathsPtrOutput

func (PipelineTriggerGitConfigurationPushFilePathsArgs) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutputWithContext

func (i PipelineTriggerGitConfigurationPushFilePathsArgs) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushFilePathsPtrOutput

type PipelineTriggerGitConfigurationPushFilePathsInput

type PipelineTriggerGitConfigurationPushFilePathsInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPushFilePathsOutput() PipelineTriggerGitConfigurationPushFilePathsOutput
	ToPipelineTriggerGitConfigurationPushFilePathsOutputWithContext(context.Context) PipelineTriggerGitConfigurationPushFilePathsOutput
}

PipelineTriggerGitConfigurationPushFilePathsInput is an input type that accepts PipelineTriggerGitConfigurationPushFilePathsArgs and PipelineTriggerGitConfigurationPushFilePathsOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPushFilePathsInput` via:

PipelineTriggerGitConfigurationPushFilePathsArgs{...}

type PipelineTriggerGitConfigurationPushFilePathsOutput

type PipelineTriggerGitConfigurationPushFilePathsOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPushFilePathsOutput) ElementType

func (PipelineTriggerGitConfigurationPushFilePathsOutput) Excludes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPushFilePathsOutput) Includes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPushFilePathsOutput) ToPipelineTriggerGitConfigurationPushFilePathsOutput

func (o PipelineTriggerGitConfigurationPushFilePathsOutput) ToPipelineTriggerGitConfigurationPushFilePathsOutput() PipelineTriggerGitConfigurationPushFilePathsOutput

func (PipelineTriggerGitConfigurationPushFilePathsOutput) ToPipelineTriggerGitConfigurationPushFilePathsOutputWithContext

func (o PipelineTriggerGitConfigurationPushFilePathsOutput) ToPipelineTriggerGitConfigurationPushFilePathsOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushFilePathsOutput

func (PipelineTriggerGitConfigurationPushFilePathsOutput) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutput

func (o PipelineTriggerGitConfigurationPushFilePathsOutput) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutput() PipelineTriggerGitConfigurationPushFilePathsPtrOutput

func (PipelineTriggerGitConfigurationPushFilePathsOutput) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPushFilePathsOutput) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushFilePathsPtrOutput

type PipelineTriggerGitConfigurationPushFilePathsPtrInput

type PipelineTriggerGitConfigurationPushFilePathsPtrInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPushFilePathsPtrOutput() PipelineTriggerGitConfigurationPushFilePathsPtrOutput
	ToPipelineTriggerGitConfigurationPushFilePathsPtrOutputWithContext(context.Context) PipelineTriggerGitConfigurationPushFilePathsPtrOutput
}

PipelineTriggerGitConfigurationPushFilePathsPtrInput is an input type that accepts PipelineTriggerGitConfigurationPushFilePathsArgs, PipelineTriggerGitConfigurationPushFilePathsPtr and PipelineTriggerGitConfigurationPushFilePathsPtrOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPushFilePathsPtrInput` via:

        PipelineTriggerGitConfigurationPushFilePathsArgs{...}

or:

        nil

type PipelineTriggerGitConfigurationPushFilePathsPtrOutput

type PipelineTriggerGitConfigurationPushFilePathsPtrOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPushFilePathsPtrOutput) Elem

func (PipelineTriggerGitConfigurationPushFilePathsPtrOutput) ElementType

func (PipelineTriggerGitConfigurationPushFilePathsPtrOutput) Excludes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPushFilePathsPtrOutput) Includes

A list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPushFilePathsPtrOutput) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutput

func (PipelineTriggerGitConfigurationPushFilePathsPtrOutput) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPushFilePathsPtrOutput) ToPipelineTriggerGitConfigurationPushFilePathsPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushFilePathsPtrOutput

type PipelineTriggerGitConfigurationPushInput

type PipelineTriggerGitConfigurationPushInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPushOutput() PipelineTriggerGitConfigurationPushOutput
	ToPipelineTriggerGitConfigurationPushOutputWithContext(context.Context) PipelineTriggerGitConfigurationPushOutput
}

PipelineTriggerGitConfigurationPushInput is an input type that accepts PipelineTriggerGitConfigurationPushArgs and PipelineTriggerGitConfigurationPushOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPushInput` via:

PipelineTriggerGitConfigurationPushArgs{...}

type PipelineTriggerGitConfigurationPushOutput

type PipelineTriggerGitConfigurationPushOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPushOutput) Branches

The field that specifies to filter on branches for the push trigger configuration. A `branches` block is documented below.

func (PipelineTriggerGitConfigurationPushOutput) ElementType

func (PipelineTriggerGitConfigurationPushOutput) FilePaths

The field that specifies to filter on file paths for the push trigger configuration. A `filePaths` block is documented below.

func (PipelineTriggerGitConfigurationPushOutput) Tags

The field that contains the details for the Git tags trigger configuration. A `tags` block is documented below.

func (PipelineTriggerGitConfigurationPushOutput) ToPipelineTriggerGitConfigurationPushOutput

func (o PipelineTriggerGitConfigurationPushOutput) ToPipelineTriggerGitConfigurationPushOutput() PipelineTriggerGitConfigurationPushOutput

func (PipelineTriggerGitConfigurationPushOutput) ToPipelineTriggerGitConfigurationPushOutputWithContext

func (o PipelineTriggerGitConfigurationPushOutput) ToPipelineTriggerGitConfigurationPushOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushOutput

type PipelineTriggerGitConfigurationPushTags

type PipelineTriggerGitConfigurationPushTags struct {
	// A list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.
	Excludes []string `pulumi:"excludes"`
	// A list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
	Includes []string `pulumi:"includes"`
}

type PipelineTriggerGitConfigurationPushTagsArgs

type PipelineTriggerGitConfigurationPushTagsArgs struct {
	// A list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.
	Excludes pulumi.StringArrayInput `pulumi:"excludes"`
	// A list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
	Includes pulumi.StringArrayInput `pulumi:"includes"`
}

func (PipelineTriggerGitConfigurationPushTagsArgs) ElementType

func (PipelineTriggerGitConfigurationPushTagsArgs) ToPipelineTriggerGitConfigurationPushTagsOutput

func (i PipelineTriggerGitConfigurationPushTagsArgs) ToPipelineTriggerGitConfigurationPushTagsOutput() PipelineTriggerGitConfigurationPushTagsOutput

func (PipelineTriggerGitConfigurationPushTagsArgs) ToPipelineTriggerGitConfigurationPushTagsOutputWithContext

func (i PipelineTriggerGitConfigurationPushTagsArgs) ToPipelineTriggerGitConfigurationPushTagsOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushTagsOutput

func (PipelineTriggerGitConfigurationPushTagsArgs) ToPipelineTriggerGitConfigurationPushTagsPtrOutput

func (i PipelineTriggerGitConfigurationPushTagsArgs) ToPipelineTriggerGitConfigurationPushTagsPtrOutput() PipelineTriggerGitConfigurationPushTagsPtrOutput

func (PipelineTriggerGitConfigurationPushTagsArgs) ToPipelineTriggerGitConfigurationPushTagsPtrOutputWithContext

func (i PipelineTriggerGitConfigurationPushTagsArgs) ToPipelineTriggerGitConfigurationPushTagsPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushTagsPtrOutput

type PipelineTriggerGitConfigurationPushTagsInput

type PipelineTriggerGitConfigurationPushTagsInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPushTagsOutput() PipelineTriggerGitConfigurationPushTagsOutput
	ToPipelineTriggerGitConfigurationPushTagsOutputWithContext(context.Context) PipelineTriggerGitConfigurationPushTagsOutput
}

PipelineTriggerGitConfigurationPushTagsInput is an input type that accepts PipelineTriggerGitConfigurationPushTagsArgs and PipelineTriggerGitConfigurationPushTagsOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPushTagsInput` via:

PipelineTriggerGitConfigurationPushTagsArgs{...}

type PipelineTriggerGitConfigurationPushTagsOutput

type PipelineTriggerGitConfigurationPushTagsOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPushTagsOutput) ElementType

func (PipelineTriggerGitConfigurationPushTagsOutput) Excludes

A list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPushTagsOutput) Includes

A list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPushTagsOutput) ToPipelineTriggerGitConfigurationPushTagsOutput

func (o PipelineTriggerGitConfigurationPushTagsOutput) ToPipelineTriggerGitConfigurationPushTagsOutput() PipelineTriggerGitConfigurationPushTagsOutput

func (PipelineTriggerGitConfigurationPushTagsOutput) ToPipelineTriggerGitConfigurationPushTagsOutputWithContext

func (o PipelineTriggerGitConfigurationPushTagsOutput) ToPipelineTriggerGitConfigurationPushTagsOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushTagsOutput

func (PipelineTriggerGitConfigurationPushTagsOutput) ToPipelineTriggerGitConfigurationPushTagsPtrOutput

func (o PipelineTriggerGitConfigurationPushTagsOutput) ToPipelineTriggerGitConfigurationPushTagsPtrOutput() PipelineTriggerGitConfigurationPushTagsPtrOutput

func (PipelineTriggerGitConfigurationPushTagsOutput) ToPipelineTriggerGitConfigurationPushTagsPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPushTagsOutput) ToPipelineTriggerGitConfigurationPushTagsPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushTagsPtrOutput

type PipelineTriggerGitConfigurationPushTagsPtrInput

type PipelineTriggerGitConfigurationPushTagsPtrInput interface {
	pulumi.Input

	ToPipelineTriggerGitConfigurationPushTagsPtrOutput() PipelineTriggerGitConfigurationPushTagsPtrOutput
	ToPipelineTriggerGitConfigurationPushTagsPtrOutputWithContext(context.Context) PipelineTriggerGitConfigurationPushTagsPtrOutput
}

PipelineTriggerGitConfigurationPushTagsPtrInput is an input type that accepts PipelineTriggerGitConfigurationPushTagsArgs, PipelineTriggerGitConfigurationPushTagsPtr and PipelineTriggerGitConfigurationPushTagsPtrOutput values. You can construct a concrete instance of `PipelineTriggerGitConfigurationPushTagsPtrInput` via:

        PipelineTriggerGitConfigurationPushTagsArgs{...}

or:

        nil

type PipelineTriggerGitConfigurationPushTagsPtrOutput

type PipelineTriggerGitConfigurationPushTagsPtrOutput struct{ *pulumi.OutputState }

func (PipelineTriggerGitConfigurationPushTagsPtrOutput) Elem

func (PipelineTriggerGitConfigurationPushTagsPtrOutput) ElementType

func (PipelineTriggerGitConfigurationPushTagsPtrOutput) Excludes

A list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.

func (PipelineTriggerGitConfigurationPushTagsPtrOutput) Includes

A list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.

func (PipelineTriggerGitConfigurationPushTagsPtrOutput) ToPipelineTriggerGitConfigurationPushTagsPtrOutput

func (o PipelineTriggerGitConfigurationPushTagsPtrOutput) ToPipelineTriggerGitConfigurationPushTagsPtrOutput() PipelineTriggerGitConfigurationPushTagsPtrOutput

func (PipelineTriggerGitConfigurationPushTagsPtrOutput) ToPipelineTriggerGitConfigurationPushTagsPtrOutputWithContext

func (o PipelineTriggerGitConfigurationPushTagsPtrOutput) ToPipelineTriggerGitConfigurationPushTagsPtrOutputWithContext(ctx context.Context) PipelineTriggerGitConfigurationPushTagsPtrOutput

type PipelineTriggerInput

type PipelineTriggerInput interface {
	pulumi.Input

	ToPipelineTriggerOutput() PipelineTriggerOutput
	ToPipelineTriggerOutputWithContext(context.Context) PipelineTriggerOutput
}

PipelineTriggerInput is an input type that accepts PipelineTriggerArgs and PipelineTriggerOutput values. You can construct a concrete instance of `PipelineTriggerInput` via:

PipelineTriggerArgs{...}

type PipelineTriggerOutput

type PipelineTriggerOutput struct{ *pulumi.OutputState }

func (PipelineTriggerOutput) ElementType

func (PipelineTriggerOutput) ElementType() reflect.Type

func (PipelineTriggerOutput) GitConfiguration

Provides the filter criteria and the source stage for the repository event that starts the pipeline. For more information, refer to the [AWS documentation](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-filter.html). A `gitConfiguration` block is documented below.

func (PipelineTriggerOutput) ProviderType

func (o PipelineTriggerOutput) ProviderType() pulumi.StringOutput

The source provider for the event. Possible value is `CodeStarSourceConnection`.

func (PipelineTriggerOutput) ToPipelineTriggerOutput

func (o PipelineTriggerOutput) ToPipelineTriggerOutput() PipelineTriggerOutput

func (PipelineTriggerOutput) ToPipelineTriggerOutputWithContext

func (o PipelineTriggerOutput) ToPipelineTriggerOutputWithContext(ctx context.Context) PipelineTriggerOutput

type PipelineVariable

type PipelineVariable struct {
	// The default value of a pipeline-level variable.
	DefaultValue *string `pulumi:"defaultValue"`
	// The description of a pipeline-level variable.
	Description *string `pulumi:"description"`
	// The name of a pipeline-level variable.
	Name string `pulumi:"name"`
}

type PipelineVariableArgs

type PipelineVariableArgs struct {
	// The default value of a pipeline-level variable.
	DefaultValue pulumi.StringPtrInput `pulumi:"defaultValue"`
	// The description of a pipeline-level variable.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// The name of a pipeline-level variable.
	Name pulumi.StringInput `pulumi:"name"`
}

func (PipelineVariableArgs) ElementType

func (PipelineVariableArgs) ElementType() reflect.Type

func (PipelineVariableArgs) ToPipelineVariableOutput

func (i PipelineVariableArgs) ToPipelineVariableOutput() PipelineVariableOutput

func (PipelineVariableArgs) ToPipelineVariableOutputWithContext

func (i PipelineVariableArgs) ToPipelineVariableOutputWithContext(ctx context.Context) PipelineVariableOutput

type PipelineVariableArray

type PipelineVariableArray []PipelineVariableInput

func (PipelineVariableArray) ElementType

func (PipelineVariableArray) ElementType() reflect.Type

func (PipelineVariableArray) ToPipelineVariableArrayOutput

func (i PipelineVariableArray) ToPipelineVariableArrayOutput() PipelineVariableArrayOutput

func (PipelineVariableArray) ToPipelineVariableArrayOutputWithContext

func (i PipelineVariableArray) ToPipelineVariableArrayOutputWithContext(ctx context.Context) PipelineVariableArrayOutput

type PipelineVariableArrayInput

type PipelineVariableArrayInput interface {
	pulumi.Input

	ToPipelineVariableArrayOutput() PipelineVariableArrayOutput
	ToPipelineVariableArrayOutputWithContext(context.Context) PipelineVariableArrayOutput
}

PipelineVariableArrayInput is an input type that accepts PipelineVariableArray and PipelineVariableArrayOutput values. You can construct a concrete instance of `PipelineVariableArrayInput` via:

PipelineVariableArray{ PipelineVariableArgs{...} }

type PipelineVariableArrayOutput

type PipelineVariableArrayOutput struct{ *pulumi.OutputState }

func (PipelineVariableArrayOutput) ElementType

func (PipelineVariableArrayOutput) Index

func (PipelineVariableArrayOutput) ToPipelineVariableArrayOutput

func (o PipelineVariableArrayOutput) ToPipelineVariableArrayOutput() PipelineVariableArrayOutput

func (PipelineVariableArrayOutput) ToPipelineVariableArrayOutputWithContext

func (o PipelineVariableArrayOutput) ToPipelineVariableArrayOutputWithContext(ctx context.Context) PipelineVariableArrayOutput

type PipelineVariableInput

type PipelineVariableInput interface {
	pulumi.Input

	ToPipelineVariableOutput() PipelineVariableOutput
	ToPipelineVariableOutputWithContext(context.Context) PipelineVariableOutput
}

PipelineVariableInput is an input type that accepts PipelineVariableArgs and PipelineVariableOutput values. You can construct a concrete instance of `PipelineVariableInput` via:

PipelineVariableArgs{...}

type PipelineVariableOutput

type PipelineVariableOutput struct{ *pulumi.OutputState }

func (PipelineVariableOutput) DefaultValue

The default value of a pipeline-level variable.

func (PipelineVariableOutput) Description

The description of a pipeline-level variable.

func (PipelineVariableOutput) ElementType

func (PipelineVariableOutput) ElementType() reflect.Type

func (PipelineVariableOutput) Name

The name of a pipeline-level variable.

func (PipelineVariableOutput) ToPipelineVariableOutput

func (o PipelineVariableOutput) ToPipelineVariableOutput() PipelineVariableOutput

func (PipelineVariableOutput) ToPipelineVariableOutputWithContext

func (o PipelineVariableOutput) ToPipelineVariableOutputWithContext(ctx context.Context) PipelineVariableOutput

type Webhook

type Webhook struct {
	pulumi.CustomResourceState

	// The CodePipeline webhook's ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The type of authentication  to use. One of `IP`, `GITHUB_HMAC`, or `UNAUTHENTICATED`.
	Authentication pulumi.StringOutput `pulumi:"authentication"`
	// An `auth` block. Required for `IP` and `GITHUB_HMAC`. Auth blocks are documented below.
	AuthenticationConfiguration WebhookAuthenticationConfigurationPtrOutput `pulumi:"authenticationConfiguration"`
	// One or more `filter` blocks. Filter blocks are documented below.
	Filters WebhookFilterArrayOutput `pulumi:"filters"`
	// The name of the webhook.
	Name pulumi.StringOutput `pulumi:"name"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// The name of the action in a pipeline you want to connect to the webhook. The action must be from the source (first) stage of the pipeline.
	TargetAction pulumi.StringOutput `pulumi:"targetAction"`
	// The name of the pipeline.
	TargetPipeline pulumi.StringOutput `pulumi:"targetPipeline"`
	// The CodePipeline webhook's URL. POST events to this endpoint to trigger the target.
	Url pulumi.StringOutput `pulumi:"url"`
}

Provides a CodePipeline Webhook.

## Import

Using `pulumi import`, import CodePipeline Webhooks using their ARN. For example:

```sh $ pulumi import aws:codepipeline/webhook:Webhook example arn:aws:codepipeline:us-west-2:123456789012:webhook:example ```

func GetWebhook

func GetWebhook(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *WebhookState, opts ...pulumi.ResourceOption) (*Webhook, error)

GetWebhook gets an existing Webhook resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewWebhook

func NewWebhook(ctx *pulumi.Context,
	name string, args *WebhookArgs, opts ...pulumi.ResourceOption) (*Webhook, error)

NewWebhook registers a new resource with the given unique name, arguments, and options.

func (*Webhook) ElementType

func (*Webhook) ElementType() reflect.Type

func (*Webhook) ToWebhookOutput

func (i *Webhook) ToWebhookOutput() WebhookOutput

func (*Webhook) ToWebhookOutputWithContext

func (i *Webhook) ToWebhookOutputWithContext(ctx context.Context) WebhookOutput

type WebhookArgs

type WebhookArgs struct {
	// The type of authentication  to use. One of `IP`, `GITHUB_HMAC`, or `UNAUTHENTICATED`.
	Authentication pulumi.StringInput
	// An `auth` block. Required for `IP` and `GITHUB_HMAC`. Auth blocks are documented below.
	AuthenticationConfiguration WebhookAuthenticationConfigurationPtrInput
	// One or more `filter` blocks. Filter blocks are documented below.
	Filters WebhookFilterArrayInput
	// The name of the webhook.
	Name pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// The name of the action in a pipeline you want to connect to the webhook. The action must be from the source (first) stage of the pipeline.
	TargetAction pulumi.StringInput
	// The name of the pipeline.
	TargetPipeline pulumi.StringInput
}

The set of arguments for constructing a Webhook resource.

func (WebhookArgs) ElementType

func (WebhookArgs) ElementType() reflect.Type

type WebhookArray

type WebhookArray []WebhookInput

func (WebhookArray) ElementType

func (WebhookArray) ElementType() reflect.Type

func (WebhookArray) ToWebhookArrayOutput

func (i WebhookArray) ToWebhookArrayOutput() WebhookArrayOutput

func (WebhookArray) ToWebhookArrayOutputWithContext

func (i WebhookArray) ToWebhookArrayOutputWithContext(ctx context.Context) WebhookArrayOutput

type WebhookArrayInput

type WebhookArrayInput interface {
	pulumi.Input

	ToWebhookArrayOutput() WebhookArrayOutput
	ToWebhookArrayOutputWithContext(context.Context) WebhookArrayOutput
}

WebhookArrayInput is an input type that accepts WebhookArray and WebhookArrayOutput values. You can construct a concrete instance of `WebhookArrayInput` via:

WebhookArray{ WebhookArgs{...} }

type WebhookArrayOutput

type WebhookArrayOutput struct{ *pulumi.OutputState }

func (WebhookArrayOutput) ElementType

func (WebhookArrayOutput) ElementType() reflect.Type

func (WebhookArrayOutput) Index

func (WebhookArrayOutput) ToWebhookArrayOutput

func (o WebhookArrayOutput) ToWebhookArrayOutput() WebhookArrayOutput

func (WebhookArrayOutput) ToWebhookArrayOutputWithContext

func (o WebhookArrayOutput) ToWebhookArrayOutputWithContext(ctx context.Context) WebhookArrayOutput

type WebhookAuthenticationConfiguration

type WebhookAuthenticationConfiguration struct {
	// A valid CIDR block for `IP` filtering. Required for `IP`.
	AllowedIpRange *string `pulumi:"allowedIpRange"`
	// The shared secret for the GitHub repository webhook. Set this as `secret` in your `githubRepositoryWebhook`'s `configuration` block. Required for `GITHUB_HMAC`.
	SecretToken *string `pulumi:"secretToken"`
}

type WebhookAuthenticationConfigurationArgs

type WebhookAuthenticationConfigurationArgs struct {
	// A valid CIDR block for `IP` filtering. Required for `IP`.
	AllowedIpRange pulumi.StringPtrInput `pulumi:"allowedIpRange"`
	// The shared secret for the GitHub repository webhook. Set this as `secret` in your `githubRepositoryWebhook`'s `configuration` block. Required for `GITHUB_HMAC`.
	SecretToken pulumi.StringPtrInput `pulumi:"secretToken"`
}

func (WebhookAuthenticationConfigurationArgs) ElementType

func (WebhookAuthenticationConfigurationArgs) ToWebhookAuthenticationConfigurationOutput

func (i WebhookAuthenticationConfigurationArgs) ToWebhookAuthenticationConfigurationOutput() WebhookAuthenticationConfigurationOutput

func (WebhookAuthenticationConfigurationArgs) ToWebhookAuthenticationConfigurationOutputWithContext

func (i WebhookAuthenticationConfigurationArgs) ToWebhookAuthenticationConfigurationOutputWithContext(ctx context.Context) WebhookAuthenticationConfigurationOutput

func (WebhookAuthenticationConfigurationArgs) ToWebhookAuthenticationConfigurationPtrOutput

func (i WebhookAuthenticationConfigurationArgs) ToWebhookAuthenticationConfigurationPtrOutput() WebhookAuthenticationConfigurationPtrOutput

func (WebhookAuthenticationConfigurationArgs) ToWebhookAuthenticationConfigurationPtrOutputWithContext

func (i WebhookAuthenticationConfigurationArgs) ToWebhookAuthenticationConfigurationPtrOutputWithContext(ctx context.Context) WebhookAuthenticationConfigurationPtrOutput

type WebhookAuthenticationConfigurationInput

type WebhookAuthenticationConfigurationInput interface {
	pulumi.Input

	ToWebhookAuthenticationConfigurationOutput() WebhookAuthenticationConfigurationOutput
	ToWebhookAuthenticationConfigurationOutputWithContext(context.Context) WebhookAuthenticationConfigurationOutput
}

WebhookAuthenticationConfigurationInput is an input type that accepts WebhookAuthenticationConfigurationArgs and WebhookAuthenticationConfigurationOutput values. You can construct a concrete instance of `WebhookAuthenticationConfigurationInput` via:

WebhookAuthenticationConfigurationArgs{...}

type WebhookAuthenticationConfigurationOutput

type WebhookAuthenticationConfigurationOutput struct{ *pulumi.OutputState }

func (WebhookAuthenticationConfigurationOutput) AllowedIpRange

A valid CIDR block for `IP` filtering. Required for `IP`.

func (WebhookAuthenticationConfigurationOutput) ElementType

func (WebhookAuthenticationConfigurationOutput) SecretToken

The shared secret for the GitHub repository webhook. Set this as `secret` in your `githubRepositoryWebhook`'s `configuration` block. Required for `GITHUB_HMAC`.

func (WebhookAuthenticationConfigurationOutput) ToWebhookAuthenticationConfigurationOutput

func (o WebhookAuthenticationConfigurationOutput) ToWebhookAuthenticationConfigurationOutput() WebhookAuthenticationConfigurationOutput

func (WebhookAuthenticationConfigurationOutput) ToWebhookAuthenticationConfigurationOutputWithContext

func (o WebhookAuthenticationConfigurationOutput) ToWebhookAuthenticationConfigurationOutputWithContext(ctx context.Context) WebhookAuthenticationConfigurationOutput

func (WebhookAuthenticationConfigurationOutput) ToWebhookAuthenticationConfigurationPtrOutput

func (o WebhookAuthenticationConfigurationOutput) ToWebhookAuthenticationConfigurationPtrOutput() WebhookAuthenticationConfigurationPtrOutput

func (WebhookAuthenticationConfigurationOutput) ToWebhookAuthenticationConfigurationPtrOutputWithContext

func (o WebhookAuthenticationConfigurationOutput) ToWebhookAuthenticationConfigurationPtrOutputWithContext(ctx context.Context) WebhookAuthenticationConfigurationPtrOutput

type WebhookAuthenticationConfigurationPtrInput

type WebhookAuthenticationConfigurationPtrInput interface {
	pulumi.Input

	ToWebhookAuthenticationConfigurationPtrOutput() WebhookAuthenticationConfigurationPtrOutput
	ToWebhookAuthenticationConfigurationPtrOutputWithContext(context.Context) WebhookAuthenticationConfigurationPtrOutput
}

WebhookAuthenticationConfigurationPtrInput is an input type that accepts WebhookAuthenticationConfigurationArgs, WebhookAuthenticationConfigurationPtr and WebhookAuthenticationConfigurationPtrOutput values. You can construct a concrete instance of `WebhookAuthenticationConfigurationPtrInput` via:

        WebhookAuthenticationConfigurationArgs{...}

or:

        nil

type WebhookAuthenticationConfigurationPtrOutput

type WebhookAuthenticationConfigurationPtrOutput struct{ *pulumi.OutputState }

func (WebhookAuthenticationConfigurationPtrOutput) AllowedIpRange

A valid CIDR block for `IP` filtering. Required for `IP`.

func (WebhookAuthenticationConfigurationPtrOutput) Elem

func (WebhookAuthenticationConfigurationPtrOutput) ElementType

func (WebhookAuthenticationConfigurationPtrOutput) SecretToken

The shared secret for the GitHub repository webhook. Set this as `secret` in your `githubRepositoryWebhook`'s `configuration` block. Required for `GITHUB_HMAC`.

func (WebhookAuthenticationConfigurationPtrOutput) ToWebhookAuthenticationConfigurationPtrOutput

func (o WebhookAuthenticationConfigurationPtrOutput) ToWebhookAuthenticationConfigurationPtrOutput() WebhookAuthenticationConfigurationPtrOutput

func (WebhookAuthenticationConfigurationPtrOutput) ToWebhookAuthenticationConfigurationPtrOutputWithContext

func (o WebhookAuthenticationConfigurationPtrOutput) ToWebhookAuthenticationConfigurationPtrOutputWithContext(ctx context.Context) WebhookAuthenticationConfigurationPtrOutput

type WebhookFilter

type WebhookFilter struct {
	// The [JSON path](https://github.com/json-path/JsonPath) to filter on.
	JsonPath string `pulumi:"jsonPath"`
	// The value to match on (e.g., `refs/heads/{Branch}`). See [AWS docs](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_WebhookFilterRule.html) for details.
	MatchEquals string `pulumi:"matchEquals"`
}

type WebhookFilterArgs

type WebhookFilterArgs struct {
	// The [JSON path](https://github.com/json-path/JsonPath) to filter on.
	JsonPath pulumi.StringInput `pulumi:"jsonPath"`
	// The value to match on (e.g., `refs/heads/{Branch}`). See [AWS docs](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_WebhookFilterRule.html) for details.
	MatchEquals pulumi.StringInput `pulumi:"matchEquals"`
}

func (WebhookFilterArgs) ElementType

func (WebhookFilterArgs) ElementType() reflect.Type

func (WebhookFilterArgs) ToWebhookFilterOutput

func (i WebhookFilterArgs) ToWebhookFilterOutput() WebhookFilterOutput

func (WebhookFilterArgs) ToWebhookFilterOutputWithContext

func (i WebhookFilterArgs) ToWebhookFilterOutputWithContext(ctx context.Context) WebhookFilterOutput

type WebhookFilterArray

type WebhookFilterArray []WebhookFilterInput

func (WebhookFilterArray) ElementType

func (WebhookFilterArray) ElementType() reflect.Type

func (WebhookFilterArray) ToWebhookFilterArrayOutput

func (i WebhookFilterArray) ToWebhookFilterArrayOutput() WebhookFilterArrayOutput

func (WebhookFilterArray) ToWebhookFilterArrayOutputWithContext

func (i WebhookFilterArray) ToWebhookFilterArrayOutputWithContext(ctx context.Context) WebhookFilterArrayOutput

type WebhookFilterArrayInput

type WebhookFilterArrayInput interface {
	pulumi.Input

	ToWebhookFilterArrayOutput() WebhookFilterArrayOutput
	ToWebhookFilterArrayOutputWithContext(context.Context) WebhookFilterArrayOutput
}

WebhookFilterArrayInput is an input type that accepts WebhookFilterArray and WebhookFilterArrayOutput values. You can construct a concrete instance of `WebhookFilterArrayInput` via:

WebhookFilterArray{ WebhookFilterArgs{...} }

type WebhookFilterArrayOutput

type WebhookFilterArrayOutput struct{ *pulumi.OutputState }

func (WebhookFilterArrayOutput) ElementType

func (WebhookFilterArrayOutput) ElementType() reflect.Type

func (WebhookFilterArrayOutput) Index

func (WebhookFilterArrayOutput) ToWebhookFilterArrayOutput

func (o WebhookFilterArrayOutput) ToWebhookFilterArrayOutput() WebhookFilterArrayOutput

func (WebhookFilterArrayOutput) ToWebhookFilterArrayOutputWithContext

func (o WebhookFilterArrayOutput) ToWebhookFilterArrayOutputWithContext(ctx context.Context) WebhookFilterArrayOutput

type WebhookFilterInput

type WebhookFilterInput interface {
	pulumi.Input

	ToWebhookFilterOutput() WebhookFilterOutput
	ToWebhookFilterOutputWithContext(context.Context) WebhookFilterOutput
}

WebhookFilterInput is an input type that accepts WebhookFilterArgs and WebhookFilterOutput values. You can construct a concrete instance of `WebhookFilterInput` via:

WebhookFilterArgs{...}

type WebhookFilterOutput

type WebhookFilterOutput struct{ *pulumi.OutputState }

func (WebhookFilterOutput) ElementType

func (WebhookFilterOutput) ElementType() reflect.Type

func (WebhookFilterOutput) JsonPath

The [JSON path](https://github.com/json-path/JsonPath) to filter on.

func (WebhookFilterOutput) MatchEquals

func (o WebhookFilterOutput) MatchEquals() pulumi.StringOutput

The value to match on (e.g., `refs/heads/{Branch}`). See [AWS docs](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_WebhookFilterRule.html) for details.

func (WebhookFilterOutput) ToWebhookFilterOutput

func (o WebhookFilterOutput) ToWebhookFilterOutput() WebhookFilterOutput

func (WebhookFilterOutput) ToWebhookFilterOutputWithContext

func (o WebhookFilterOutput) ToWebhookFilterOutputWithContext(ctx context.Context) WebhookFilterOutput

type WebhookInput

type WebhookInput interface {
	pulumi.Input

	ToWebhookOutput() WebhookOutput
	ToWebhookOutputWithContext(ctx context.Context) WebhookOutput
}

type WebhookMap

type WebhookMap map[string]WebhookInput

func (WebhookMap) ElementType

func (WebhookMap) ElementType() reflect.Type

func (WebhookMap) ToWebhookMapOutput

func (i WebhookMap) ToWebhookMapOutput() WebhookMapOutput

func (WebhookMap) ToWebhookMapOutputWithContext

func (i WebhookMap) ToWebhookMapOutputWithContext(ctx context.Context) WebhookMapOutput

type WebhookMapInput

type WebhookMapInput interface {
	pulumi.Input

	ToWebhookMapOutput() WebhookMapOutput
	ToWebhookMapOutputWithContext(context.Context) WebhookMapOutput
}

WebhookMapInput is an input type that accepts WebhookMap and WebhookMapOutput values. You can construct a concrete instance of `WebhookMapInput` via:

WebhookMap{ "key": WebhookArgs{...} }

type WebhookMapOutput

type WebhookMapOutput struct{ *pulumi.OutputState }

func (WebhookMapOutput) ElementType

func (WebhookMapOutput) ElementType() reflect.Type

func (WebhookMapOutput) MapIndex

func (WebhookMapOutput) ToWebhookMapOutput

func (o WebhookMapOutput) ToWebhookMapOutput() WebhookMapOutput

func (WebhookMapOutput) ToWebhookMapOutputWithContext

func (o WebhookMapOutput) ToWebhookMapOutputWithContext(ctx context.Context) WebhookMapOutput

type WebhookOutput

type WebhookOutput struct{ *pulumi.OutputState }

func (WebhookOutput) Arn

The CodePipeline webhook's ARN.

func (WebhookOutput) Authentication

func (o WebhookOutput) Authentication() pulumi.StringOutput

The type of authentication to use. One of `IP`, `GITHUB_HMAC`, or `UNAUTHENTICATED`.

func (WebhookOutput) AuthenticationConfiguration

func (o WebhookOutput) AuthenticationConfiguration() WebhookAuthenticationConfigurationPtrOutput

An `auth` block. Required for `IP` and `GITHUB_HMAC`. Auth blocks are documented below.

func (WebhookOutput) ElementType

func (WebhookOutput) ElementType() reflect.Type

func (WebhookOutput) Filters

One or more `filter` blocks. Filter blocks are documented below.

func (WebhookOutput) Name

The name of the webhook.

func (WebhookOutput) Region

func (o WebhookOutput) Region() pulumi.StringOutput

Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

func (WebhookOutput) Tags

A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (WebhookOutput) TagsAll

func (o WebhookOutput) TagsAll() pulumi.StringMapOutput

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

func (WebhookOutput) TargetAction

func (o WebhookOutput) TargetAction() pulumi.StringOutput

The name of the action in a pipeline you want to connect to the webhook. The action must be from the source (first) stage of the pipeline.

func (WebhookOutput) TargetPipeline

func (o WebhookOutput) TargetPipeline() pulumi.StringOutput

The name of the pipeline.

func (WebhookOutput) ToWebhookOutput

func (o WebhookOutput) ToWebhookOutput() WebhookOutput

func (WebhookOutput) ToWebhookOutputWithContext

func (o WebhookOutput) ToWebhookOutputWithContext(ctx context.Context) WebhookOutput

func (WebhookOutput) Url

The CodePipeline webhook's URL. POST events to this endpoint to trigger the target.

type WebhookState

type WebhookState struct {
	// The CodePipeline webhook's ARN.
	Arn pulumi.StringPtrInput
	// The type of authentication  to use. One of `IP`, `GITHUB_HMAC`, or `UNAUTHENTICATED`.
	Authentication pulumi.StringPtrInput
	// An `auth` block. Required for `IP` and `GITHUB_HMAC`. Auth blocks are documented below.
	AuthenticationConfiguration WebhookAuthenticationConfigurationPtrInput
	// One or more `filter` blocks. Filter blocks are documented below.
	Filters WebhookFilterArrayInput
	// The name of the webhook.
	Name pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
	// The name of the action in a pipeline you want to connect to the webhook. The action must be from the source (first) stage of the pipeline.
	TargetAction pulumi.StringPtrInput
	// The name of the pipeline.
	TargetPipeline pulumi.StringPtrInput
	// The CodePipeline webhook's URL. POST events to this endpoint to trigger the target.
	Url pulumi.StringPtrInput
}

func (WebhookState) ElementType

func (WebhookState) ElementType() reflect.Type

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL