codepipeline

package
v0.57.0 Latest Latest
Warning

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

 Go to latest Published: Apr 7, 2023 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 category of the custom action, such as a build action or a test action.
	Category pulumi.StringOutput `pulumi:"category"`
	// The configuration properties for the custom action.
	ConfigurationProperties CustomActionTypeConfigurationPropertiesArrayOutput `pulumi:"configurationProperties"`
	// The details of the input artifact for the action, such as its commit ID.
	InputArtifactDetails CustomActionTypeArtifactDetailsOutput `pulumi:"inputArtifactDetails"`
	// The details of the output artifact of the action, such as its commit ID.
	OutputArtifactDetails CustomActionTypeArtifactDetailsOutput `pulumi:"outputArtifactDetails"`
	// The provider of the service used in the custom action, such as AWS CodeDeploy.
	Provider pulumi.StringOutput `pulumi:"provider"`
	// URLs that provide users information about this custom action.
	Settings CustomActionTypeSettingsPtrOutput `pulumi:"settings"`
	// Any tags assigned to the custom action.
	Tags CustomActionTypeTagArrayOutput `pulumi:"tags"`
	// The version identifier of the custom action.
	Version pulumi.StringOutput `pulumi:"version"`
}

The AWS::CodePipeline::CustomActionType resource creates a custom action for activities that aren't included in the CodePipeline default actions, such as running an internally developed build process or a test suite. You can use these custom actions in the stage of a pipeline.

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, such as a build action or a test action.
	Category pulumi.StringInput
	// The configuration properties for the custom action.
	ConfigurationProperties CustomActionTypeConfigurationPropertiesArrayInput
	// The details of the input artifact for the action, such as its commit ID.
	InputArtifactDetails CustomActionTypeArtifactDetailsInput
	// The details of the output artifact of the action, such as its commit ID.
	OutputArtifactDetails CustomActionTypeArtifactDetailsInput
	// The provider of the service used in the custom action, such as AWS CodeDeploy.
	Provider pulumi.StringInput
	// URLs that provide users information about this custom action.
	Settings CustomActionTypeSettingsPtrInput
	// Any tags assigned to the custom action.
	Tags CustomActionTypeTagArrayInput
	// The version identifier of the custom action.
	Version pulumi.StringInput
}

The set of arguments for constructing a CustomActionType resource.

func (CustomActionTypeArgs) ElementType 

func (CustomActionTypeArgs) ElementType() reflect.Type

type CustomActionTypeArtifactDetails 

type CustomActionTypeArtifactDetails struct {
	// The maximum number of artifacts allowed for the action type.
	MaximumCount int `pulumi:"maximumCount"`
	// The minimum number of artifacts allowed for the action type.
	MinimumCount int `pulumi:"minimumCount"`
}

Returns information about the details of an artifact.

type CustomActionTypeArtifactDetailsArgs 

type CustomActionTypeArtifactDetailsArgs struct {
	// The maximum number of artifacts allowed for the action type.
	MaximumCount pulumi.IntInput `pulumi:"maximumCount"`
	// The minimum number of artifacts allowed for the action type.
	MinimumCount pulumi.IntInput `pulumi:"minimumCount"`
}

Returns information about the details of an artifact.

func (CustomActionTypeArtifactDetailsArgs) ElementType 

func (CustomActionTypeArtifactDetailsArgs) ElementType() reflect.Type

func (CustomActionTypeArtifactDetailsArgs) ToCustomActionTypeArtifactDetailsOutput 

func (i CustomActionTypeArtifactDetailsArgs) ToCustomActionTypeArtifactDetailsOutput() CustomActionTypeArtifactDetailsOutput

func (CustomActionTypeArtifactDetailsArgs) ToCustomActionTypeArtifactDetailsOutputWithContext 

func (i CustomActionTypeArtifactDetailsArgs) ToCustomActionTypeArtifactDetailsOutputWithContext(ctx context.Context) CustomActionTypeArtifactDetailsOutput

type CustomActionTypeArtifactDetailsInput 

type CustomActionTypeArtifactDetailsInput interface {
	pulumi.Input

	ToCustomActionTypeArtifactDetailsOutput() CustomActionTypeArtifactDetailsOutput
	ToCustomActionTypeArtifactDetailsOutputWithContext(context.Context) CustomActionTypeArtifactDetailsOutput
}

CustomActionTypeArtifactDetailsInput is an input type that accepts CustomActionTypeArtifactDetailsArgs and CustomActionTypeArtifactDetailsOutput values. You can construct a concrete instance of `CustomActionTypeArtifactDetailsInput` via: 

CustomActionTypeArtifactDetailsArgs{...}

type CustomActionTypeArtifactDetailsOutput 

type CustomActionTypeArtifactDetailsOutput struct{ *pulumi.OutputState }

Returns information about the details of an artifact.

func (CustomActionTypeArtifactDetailsOutput) ElementType 

func (CustomActionTypeArtifactDetailsOutput) ElementType() reflect.Type

func (CustomActionTypeArtifactDetailsOutput) MaximumCount 

func (o CustomActionTypeArtifactDetailsOutput) MaximumCount() pulumi.IntOutput

The maximum number of artifacts allowed for the action type.

func (CustomActionTypeArtifactDetailsOutput) MinimumCount 

func (o CustomActionTypeArtifactDetailsOutput) MinimumCount() pulumi.IntOutput

The minimum number of artifacts allowed for the action type.

func (CustomActionTypeArtifactDetailsOutput) ToCustomActionTypeArtifactDetailsOutput 

func (o CustomActionTypeArtifactDetailsOutput) ToCustomActionTypeArtifactDetailsOutput() CustomActionTypeArtifactDetailsOutput

func (CustomActionTypeArtifactDetailsOutput) ToCustomActionTypeArtifactDetailsOutputWithContext 

func (o CustomActionTypeArtifactDetailsOutput) ToCustomActionTypeArtifactDetailsOutputWithContext(ctx context.Context) CustomActionTypeArtifactDetailsOutput

type CustomActionTypeConfigurationProperties 

type CustomActionTypeConfigurationProperties struct {
	// The description of the action configuration property that is displayed to users.
	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 is used with PollForJobs. When creating a custom action, an action can have up to one queryable property. If it has one, that property must be both required and not secret.If you create a pipeline with a custom action type, and that custom action contains a queryable property, the value for that configuration property is subject to other restrictions. The value must be less than or equal to twenty (20) characters. The value can contain only alphanumeric characters, underscores, and hyphens.
	Queryable *bool `pulumi:"queryable"`
	// Whether the configuration property is a required value.
	Required bool `pulumi:"required"`
	// Whether the configuration property is secret. Secrets are hidden from all calls except for GetJobDetails, GetThirdPartyJobDetails, PollForJobs, and PollForThirdPartyJobs.
	Secret bool `pulumi:"secret"`
	// The type of the configuration property.
	Type *string `pulumi:"type"`
}

The configuration properties for the custom action.

type CustomActionTypeConfigurationPropertiesArgs 

type CustomActionTypeConfigurationPropertiesArgs struct {
	// The description of the action configuration property that is displayed to users.
	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 is used with PollForJobs. When creating a custom action, an action can have up to one queryable property. If it has one, that property must be both required and not secret.If you create a pipeline with a custom action type, and that custom action contains a queryable property, the value for that configuration property is subject to other restrictions. The value must be less than or equal to twenty (20) characters. The value can contain only alphanumeric characters, underscores, and hyphens.
	Queryable pulumi.BoolPtrInput `pulumi:"queryable"`
	// Whether the configuration property is a required value.
	Required pulumi.BoolInput `pulumi:"required"`
	// Whether the configuration property is secret. Secrets are hidden from all calls except for GetJobDetails, GetThirdPartyJobDetails, PollForJobs, and PollForThirdPartyJobs.
	Secret pulumi.BoolInput `pulumi:"secret"`
	// The type of the configuration property.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

The configuration properties for the custom action.

func (CustomActionTypeConfigurationPropertiesArgs) ElementType 

func (CustomActionTypeConfigurationPropertiesArgs) ElementType() reflect.Type

func (CustomActionTypeConfigurationPropertiesArgs) ToCustomActionTypeConfigurationPropertiesOutput 

func (i CustomActionTypeConfigurationPropertiesArgs) ToCustomActionTypeConfigurationPropertiesOutput() CustomActionTypeConfigurationPropertiesOutput

func (CustomActionTypeConfigurationPropertiesArgs) ToCustomActionTypeConfigurationPropertiesOutputWithContext 

func (i CustomActionTypeConfigurationPropertiesArgs) ToCustomActionTypeConfigurationPropertiesOutputWithContext(ctx context.Context) CustomActionTypeConfigurationPropertiesOutput

type CustomActionTypeConfigurationPropertiesArray 

type CustomActionTypeConfigurationPropertiesArray []CustomActionTypeConfigurationPropertiesInput

func (CustomActionTypeConfigurationPropertiesArray) ElementType 

func (CustomActionTypeConfigurationPropertiesArray) ElementType() reflect.Type

func (CustomActionTypeConfigurationPropertiesArray) ToCustomActionTypeConfigurationPropertiesArrayOutput 

func (i CustomActionTypeConfigurationPropertiesArray) ToCustomActionTypeConfigurationPropertiesArrayOutput() CustomActionTypeConfigurationPropertiesArrayOutput

func (CustomActionTypeConfigurationPropertiesArray) ToCustomActionTypeConfigurationPropertiesArrayOutputWithContext 

func (i CustomActionTypeConfigurationPropertiesArray) ToCustomActionTypeConfigurationPropertiesArrayOutputWithContext(ctx context.Context) CustomActionTypeConfigurationPropertiesArrayOutput

type CustomActionTypeConfigurationPropertiesArrayInput 

type CustomActionTypeConfigurationPropertiesArrayInput interface {
	pulumi.Input

	ToCustomActionTypeConfigurationPropertiesArrayOutput() CustomActionTypeConfigurationPropertiesArrayOutput
	ToCustomActionTypeConfigurationPropertiesArrayOutputWithContext(context.Context) CustomActionTypeConfigurationPropertiesArrayOutput
}

CustomActionTypeConfigurationPropertiesArrayInput is an input type that accepts CustomActionTypeConfigurationPropertiesArray and CustomActionTypeConfigurationPropertiesArrayOutput values. You can construct a concrete instance of `CustomActionTypeConfigurationPropertiesArrayInput` via: 

CustomActionTypeConfigurationPropertiesArray{ CustomActionTypeConfigurationPropertiesArgs{...} }

type CustomActionTypeConfigurationPropertiesArrayOutput 

type CustomActionTypeConfigurationPropertiesArrayOutput struct{ *pulumi.OutputState }

func (CustomActionTypeConfigurationPropertiesArrayOutput) ElementType 

func (CustomActionTypeConfigurationPropertiesArrayOutput) ElementType() reflect.Type

func (CustomActionTypeConfigurationPropertiesArrayOutput) Index 

func (o CustomActionTypeConfigurationPropertiesArrayOutput) Index(i pulumi.IntInput) CustomActionTypeConfigurationPropertiesOutput

func (CustomActionTypeConfigurationPropertiesArrayOutput) ToCustomActionTypeConfigurationPropertiesArrayOutput 

func (o CustomActionTypeConfigurationPropertiesArrayOutput) ToCustomActionTypeConfigurationPropertiesArrayOutput() CustomActionTypeConfigurationPropertiesArrayOutput

func (CustomActionTypeConfigurationPropertiesArrayOutput) ToCustomActionTypeConfigurationPropertiesArrayOutputWithContext 

func (o CustomActionTypeConfigurationPropertiesArrayOutput) ToCustomActionTypeConfigurationPropertiesArrayOutputWithContext(ctx context.Context) CustomActionTypeConfigurationPropertiesArrayOutput

type CustomActionTypeConfigurationPropertiesInput 

type CustomActionTypeConfigurationPropertiesInput interface {
	pulumi.Input

	ToCustomActionTypeConfigurationPropertiesOutput() CustomActionTypeConfigurationPropertiesOutput
	ToCustomActionTypeConfigurationPropertiesOutputWithContext(context.Context) CustomActionTypeConfigurationPropertiesOutput
}

CustomActionTypeConfigurationPropertiesInput is an input type that accepts CustomActionTypeConfigurationPropertiesArgs and CustomActionTypeConfigurationPropertiesOutput values. You can construct a concrete instance of `CustomActionTypeConfigurationPropertiesInput` via: 

CustomActionTypeConfigurationPropertiesArgs{...}

type CustomActionTypeConfigurationPropertiesOutput 

type CustomActionTypeConfigurationPropertiesOutput struct{ *pulumi.OutputState }

The configuration properties for the custom action.

func (CustomActionTypeConfigurationPropertiesOutput) Description 

func (o CustomActionTypeConfigurationPropertiesOutput) Description() pulumi.StringPtrOutput

The description of the action configuration property that is displayed to users.

func (CustomActionTypeConfigurationPropertiesOutput) ElementType 

func (CustomActionTypeConfigurationPropertiesOutput) ElementType() reflect.Type

func (CustomActionTypeConfigurationPropertiesOutput) Key 

func (o CustomActionTypeConfigurationPropertiesOutput) Key() pulumi.BoolOutput

Whether the configuration property is a key.

func (CustomActionTypeConfigurationPropertiesOutput) Name 

func (o CustomActionTypeConfigurationPropertiesOutput) Name() pulumi.StringOutput

The name of the action configuration property.

func (CustomActionTypeConfigurationPropertiesOutput) Queryable 

func (o CustomActionTypeConfigurationPropertiesOutput) Queryable() pulumi.BoolPtrOutput

Indicates that the property is used with PollForJobs. When creating a custom action, an action can have up to one queryable property. If it has one, that property must be both required and not secret.If you create a pipeline with a custom action type, and that custom action contains a queryable property, the value for that configuration property is subject to other restrictions. The value must be less than or equal to twenty (20) characters. The value can contain only alphanumeric characters, underscores, and hyphens.

func (CustomActionTypeConfigurationPropertiesOutput) Required 

func (o CustomActionTypeConfigurationPropertiesOutput) Required() pulumi.BoolOutput

Whether the configuration property is a required value.

func (CustomActionTypeConfigurationPropertiesOutput) Secret 

func (o CustomActionTypeConfigurationPropertiesOutput) Secret() pulumi.BoolOutput

Whether the configuration property is secret. Secrets are hidden from all calls except for GetJobDetails, GetThirdPartyJobDetails, PollForJobs, and PollForThirdPartyJobs.

func (CustomActionTypeConfigurationPropertiesOutput) ToCustomActionTypeConfigurationPropertiesOutput 

func (o CustomActionTypeConfigurationPropertiesOutput) ToCustomActionTypeConfigurationPropertiesOutput() CustomActionTypeConfigurationPropertiesOutput

func (CustomActionTypeConfigurationPropertiesOutput) ToCustomActionTypeConfigurationPropertiesOutputWithContext 

func (o CustomActionTypeConfigurationPropertiesOutput) ToCustomActionTypeConfigurationPropertiesOutputWithContext(ctx context.Context) CustomActionTypeConfigurationPropertiesOutput

func (CustomActionTypeConfigurationPropertiesOutput) Type 

func (o CustomActionTypeConfigurationPropertiesOutput) Type() pulumi.StringPtrOutput

The type of the configuration property.

type CustomActionTypeInput 

type CustomActionTypeInput interface {
	pulumi.Input

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

type CustomActionTypeOutput 

type CustomActionTypeOutput struct{ *pulumi.OutputState }

func (CustomActionTypeOutput) Category added in v0.17.0 

func (o CustomActionTypeOutput) Category() pulumi.StringOutput

The category of the custom action, such as a build action or a test action.

func (CustomActionTypeOutput) ConfigurationProperties added in v0.17.0 

func (o CustomActionTypeOutput) ConfigurationProperties() CustomActionTypeConfigurationPropertiesArrayOutput

The configuration properties for the custom action.

func (CustomActionTypeOutput) ElementType 

func (CustomActionTypeOutput) ElementType() reflect.Type

func (CustomActionTypeOutput) InputArtifactDetails added in v0.17.0 

func (o CustomActionTypeOutput) InputArtifactDetails() CustomActionTypeArtifactDetailsOutput

The details of the input artifact for the action, such as its commit ID.

func (CustomActionTypeOutput) OutputArtifactDetails added in v0.17.0 

func (o CustomActionTypeOutput) OutputArtifactDetails() CustomActionTypeArtifactDetailsOutput

The details of the output artifact of the action, such as its commit ID.

func (CustomActionTypeOutput) Provider added in v0.17.0 

func (o CustomActionTypeOutput) Provider() pulumi.StringOutput

The provider of the service used in the custom action, such as AWS CodeDeploy.

func (CustomActionTypeOutput) Settings added in v0.17.0 

func (o CustomActionTypeOutput) Settings() CustomActionTypeSettingsPtrOutput

URLs that provide users information about this custom action.

func (CustomActionTypeOutput) Tags added in v0.17.0 

func (o CustomActionTypeOutput) Tags() CustomActionTypeTagArrayOutput

Any tags assigned to the custom action.

func (CustomActionTypeOutput) ToCustomActionTypeOutput 

func (o CustomActionTypeOutput) ToCustomActionTypeOutput() CustomActionTypeOutput

func (CustomActionTypeOutput) ToCustomActionTypeOutputWithContext 

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

func (CustomActionTypeOutput) Version added in v0.17.0 

func (o CustomActionTypeOutput) Version() pulumi.StringOutput

The version identifier of the custom action.

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, such as the configuration page for an AWS CodeDeploy deployment group. This link is provided as part of the action display in the pipeline.
	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, such as the console page for AWS CodeDeploy. This link is shown on the pipeline view page in the AWS CodePipeline console and provides a link to the execution entity of the external action.
	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"`
}

Settings is a property of the AWS::CodePipeline::CustomActionType resource that provides URLs that users can access to view information about the CodePipeline custom action.

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, such as the configuration page for an AWS CodeDeploy deployment group. This link is provided as part of the action display in the pipeline.
	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, such as the console page for AWS CodeDeploy. This link is shown on the pipeline view page in the AWS CodePipeline console and provides a link to the execution entity of the external action.
	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"`
}

Settings is a property of the AWS::CodePipeline::CustomActionType resource that provides URLs that users can access to view information about the CodePipeline custom action.

func (CustomActionTypeSettingsArgs) ElementType 

func (CustomActionTypeSettingsArgs) ElementType() reflect.Type

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 }

Settings is a property of the AWS::CodePipeline::CustomActionType resource that provides URLs that users can access to view information about the CodePipeline custom action.

func (CustomActionTypeSettingsOutput) ElementType 

func (CustomActionTypeSettingsOutput) ElementType() reflect.Type

func (CustomActionTypeSettingsOutput) EntityUrlTemplate 

func (o CustomActionTypeSettingsOutput) EntityUrlTemplate() pulumi.StringPtrOutput

The URL returned to the AWS CodePipeline console that provides a deep link to the resources of the external system, such as the configuration page for an AWS CodeDeploy deployment group. This link is provided as part of the action display in the pipeline.

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, such as the console page for AWS CodeDeploy. This link is shown on the pipeline view page in the AWS CodePipeline console and provides a link to the execution entity of the external action.

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

func CustomActionTypeSettingsPtr 

func CustomActionTypeSettingsPtr(v *CustomActionTypeSettingsArgs) CustomActionTypeSettingsPtrInput

type CustomActionTypeSettingsPtrOutput 

type CustomActionTypeSettingsPtrOutput struct{ *pulumi.OutputState }

func (CustomActionTypeSettingsPtrOutput) Elem 

func (o CustomActionTypeSettingsPtrOutput) Elem() CustomActionTypeSettingsOutput

func (CustomActionTypeSettingsPtrOutput) ElementType 

func (CustomActionTypeSettingsPtrOutput) ElementType() reflect.Type

func (CustomActionTypeSettingsPtrOutput) EntityUrlTemplate 

func (o CustomActionTypeSettingsPtrOutput) EntityUrlTemplate() pulumi.StringPtrOutput

The URL returned to the AWS CodePipeline console that provides a deep link to the resources of the external system, such as the configuration page for an AWS CodeDeploy deployment group. This link is provided as part of the action display in the pipeline.

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, such as the console page for AWS CodeDeploy. This link is shown on the pipeline view page in the AWS CodePipeline console and provides a link to the execution entity of the external action.

func (CustomActionTypeSettingsPtrOutput) RevisionUrlTemplate 

func (o CustomActionTypeSettingsPtrOutput) 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 (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 {
}

func (CustomActionTypeState) ElementType 

func (CustomActionTypeState) ElementType() reflect.Type

type CustomActionTypeTag 

type CustomActionTypeTag struct {
	Key   string `pulumi:"key"`
	Value string `pulumi:"value"`
}

type CustomActionTypeTagArgs 

type CustomActionTypeTagArgs struct {
	Key   pulumi.StringInput `pulumi:"key"`
	Value pulumi.StringInput `pulumi:"value"`
}

func (CustomActionTypeTagArgs) ElementType 

func (CustomActionTypeTagArgs) ElementType() reflect.Type

func (CustomActionTypeTagArgs) ToCustomActionTypeTagOutput 

func (i CustomActionTypeTagArgs) ToCustomActionTypeTagOutput() CustomActionTypeTagOutput

func (CustomActionTypeTagArgs) ToCustomActionTypeTagOutputWithContext 

func (i CustomActionTypeTagArgs) ToCustomActionTypeTagOutputWithContext(ctx context.Context) CustomActionTypeTagOutput

type CustomActionTypeTagArray 

type CustomActionTypeTagArray []CustomActionTypeTagInput

func (CustomActionTypeTagArray) ElementType 

func (CustomActionTypeTagArray) ElementType() reflect.Type

func (CustomActionTypeTagArray) ToCustomActionTypeTagArrayOutput 

func (i CustomActionTypeTagArray) ToCustomActionTypeTagArrayOutput() CustomActionTypeTagArrayOutput

func (CustomActionTypeTagArray) ToCustomActionTypeTagArrayOutputWithContext 

func (i CustomActionTypeTagArray) ToCustomActionTypeTagArrayOutputWithContext(ctx context.Context) CustomActionTypeTagArrayOutput

type CustomActionTypeTagArrayInput 

type CustomActionTypeTagArrayInput interface {
	pulumi.Input

	ToCustomActionTypeTagArrayOutput() CustomActionTypeTagArrayOutput
	ToCustomActionTypeTagArrayOutputWithContext(context.Context) CustomActionTypeTagArrayOutput
}

CustomActionTypeTagArrayInput is an input type that accepts CustomActionTypeTagArray and CustomActionTypeTagArrayOutput values. You can construct a concrete instance of `CustomActionTypeTagArrayInput` via: 

CustomActionTypeTagArray{ CustomActionTypeTagArgs{...} }

type CustomActionTypeTagArrayOutput 

type CustomActionTypeTagArrayOutput struct{ *pulumi.OutputState }

func (CustomActionTypeTagArrayOutput) ElementType 

func (CustomActionTypeTagArrayOutput) ElementType() reflect.Type

func (CustomActionTypeTagArrayOutput) Index 

func (o CustomActionTypeTagArrayOutput) Index(i pulumi.IntInput) CustomActionTypeTagOutput

func (CustomActionTypeTagArrayOutput) ToCustomActionTypeTagArrayOutput 

func (o CustomActionTypeTagArrayOutput) ToCustomActionTypeTagArrayOutput() CustomActionTypeTagArrayOutput

func (CustomActionTypeTagArrayOutput) ToCustomActionTypeTagArrayOutputWithContext 

func (o CustomActionTypeTagArrayOutput) ToCustomActionTypeTagArrayOutputWithContext(ctx context.Context) CustomActionTypeTagArrayOutput

type CustomActionTypeTagInput 

type CustomActionTypeTagInput interface {
	pulumi.Input

	ToCustomActionTypeTagOutput() CustomActionTypeTagOutput
	ToCustomActionTypeTagOutputWithContext(context.Context) CustomActionTypeTagOutput
}

CustomActionTypeTagInput is an input type that accepts CustomActionTypeTagArgs and CustomActionTypeTagOutput values. You can construct a concrete instance of `CustomActionTypeTagInput` via: 

CustomActionTypeTagArgs{...}

type CustomActionTypeTagOutput 

type CustomActionTypeTagOutput struct{ *pulumi.OutputState }

func (CustomActionTypeTagOutput) ElementType 

func (CustomActionTypeTagOutput) ElementType() reflect.Type

func (CustomActionTypeTagOutput) Key 

func (o CustomActionTypeTagOutput) Key() pulumi.StringOutput

func (CustomActionTypeTagOutput) ToCustomActionTypeTagOutput 

func (o CustomActionTypeTagOutput) ToCustomActionTypeTagOutput() CustomActionTypeTagOutput

func (CustomActionTypeTagOutput) ToCustomActionTypeTagOutputWithContext 

func (o CustomActionTypeTagOutput) ToCustomActionTypeTagOutputWithContext(ctx context.Context) CustomActionTypeTagOutput

func (CustomActionTypeTagOutput) Value 

func (o CustomActionTypeTagOutput) Value() pulumi.StringOutput

type LookupCustomActionTypeArgs added in v0.12.0 

type LookupCustomActionTypeArgs struct {
	// The category of the custom action, such as a build action or a test action.
	Category string `pulumi:"category"`
	// The provider of the service used in the custom action, such as AWS CodeDeploy.
	Provider string `pulumi:"provider"`
	// The version identifier of the custom action.
	Version string `pulumi:"version"`
}

type LookupCustomActionTypeOutputArgs added in v0.12.0 

type LookupCustomActionTypeOutputArgs struct {
	// The category of the custom action, such as a build action or a test action.
	Category pulumi.StringInput `pulumi:"category"`
	// The provider of the service used in the custom action, such as AWS CodeDeploy.
	Provider pulumi.StringInput `pulumi:"provider"`
	// The version identifier of the custom action.
	Version pulumi.StringInput `pulumi:"version"`
}

func (LookupCustomActionTypeOutputArgs) ElementType added in v0.12.0 

func (LookupCustomActionTypeOutputArgs) ElementType() reflect.Type

type LookupCustomActionTypeResult added in v0.12.0 

type LookupCustomActionTypeResult struct {
	Id *string `pulumi:"id"`
	// Any tags assigned to the custom action.
	Tags []CustomActionTypeTag `pulumi:"tags"`
}

func LookupCustomActionType added in v0.12.0 

func LookupCustomActionType(ctx *pulumi.Context, args *LookupCustomActionTypeArgs, opts ...pulumi.InvokeOption) (*LookupCustomActionTypeResult, error)

The AWS::CodePipeline::CustomActionType resource creates a custom action for activities that aren't included in the CodePipeline default actions, such as running an internally developed build process or a test suite. You can use these custom actions in the stage of a pipeline.

type LookupCustomActionTypeResultOutput added in v0.12.0 

type LookupCustomActionTypeResultOutput struct{ *pulumi.OutputState }

func LookupCustomActionTypeOutput added in v0.12.0 

func LookupCustomActionTypeOutput(ctx *pulumi.Context, args LookupCustomActionTypeOutputArgs, opts ...pulumi.InvokeOption) LookupCustomActionTypeResultOutput

func (LookupCustomActionTypeResultOutput) ElementType added in v0.12.0 

func (LookupCustomActionTypeResultOutput) ElementType() reflect.Type

func (LookupCustomActionTypeResultOutput) Id added in v0.12.0 

func (o LookupCustomActionTypeResultOutput) Id() pulumi.StringPtrOutput

func (LookupCustomActionTypeResultOutput) Tags added in v0.12.0 

func (o LookupCustomActionTypeResultOutput) Tags() CustomActionTypeTagArrayOutput

Any tags assigned to the custom action.

func (LookupCustomActionTypeResultOutput) ToLookupCustomActionTypeResultOutput added in v0.12.0 

func (o LookupCustomActionTypeResultOutput) ToLookupCustomActionTypeResultOutput() LookupCustomActionTypeResultOutput

func (LookupCustomActionTypeResultOutput) ToLookupCustomActionTypeResultOutputWithContext added in v0.12.0 

func (o LookupCustomActionTypeResultOutput) ToLookupCustomActionTypeResultOutputWithContext(ctx context.Context) LookupCustomActionTypeResultOutput

type LookupPipelineArgs added in v0.12.0 

type LookupPipelineArgs struct {
	Id string `pulumi:"id"`
}

type LookupPipelineOutputArgs added in v0.12.0 

type LookupPipelineOutputArgs struct {
	Id pulumi.StringInput `pulumi:"id"`
}

func (LookupPipelineOutputArgs) ElementType added in v0.12.0 

func (LookupPipelineOutputArgs) ElementType() reflect.Type

type LookupPipelineResult added in v0.12.0 

type LookupPipelineResult struct {
	ArtifactStore                  *PipelineArtifactStore     `pulumi:"artifactStore"`
	ArtifactStores                 []PipelineArtifactStoreMap `pulumi:"artifactStores"`
	DisableInboundStageTransitions []PipelineStageTransition  `pulumi:"disableInboundStageTransitions"`
	Id                             *string                    `pulumi:"id"`
	RestartExecutionOnUpdate       *bool                      `pulumi:"restartExecutionOnUpdate"`
	RoleArn                        *string                    `pulumi:"roleArn"`
	Stages                         []PipelineStageDeclaration `pulumi:"stages"`
	Tags                           []PipelineTag              `pulumi:"tags"`
	Version                        *string                    `pulumi:"version"`
}

func LookupPipeline added in v0.12.0 

func LookupPipeline(ctx *pulumi.Context, args *LookupPipelineArgs, opts ...pulumi.InvokeOption) (*LookupPipelineResult, error)

Resource Type definition for AWS::CodePipeline::Pipeline

type LookupPipelineResultOutput added in v0.12.0 

type LookupPipelineResultOutput struct{ *pulumi.OutputState }

func LookupPipelineOutput added in v0.12.0 

func LookupPipelineOutput(ctx *pulumi.Context, args LookupPipelineOutputArgs, opts ...pulumi.InvokeOption) LookupPipelineResultOutput

func (LookupPipelineResultOutput) ArtifactStore added in v0.12.0 

func (o LookupPipelineResultOutput) ArtifactStore() PipelineArtifactStorePtrOutput

func (LookupPipelineResultOutput) ArtifactStores added in v0.12.0 

func (o LookupPipelineResultOutput) ArtifactStores() PipelineArtifactStoreMapArrayOutput

func (LookupPipelineResultOutput) DisableInboundStageTransitions added in v0.12.0 

func (o LookupPipelineResultOutput) DisableInboundStageTransitions() PipelineStageTransitionArrayOutput

func (LookupPipelineResultOutput) ElementType added in v0.12.0 

func (LookupPipelineResultOutput) ElementType() reflect.Type

func (LookupPipelineResultOutput) Id added in v0.12.0 

func (o LookupPipelineResultOutput) Id() pulumi.StringPtrOutput

func (LookupPipelineResultOutput) RestartExecutionOnUpdate added in v0.12.0 

func (o LookupPipelineResultOutput) RestartExecutionOnUpdate() pulumi.BoolPtrOutput

func (LookupPipelineResultOutput) RoleArn added in v0.12.0 

func (o LookupPipelineResultOutput) RoleArn() pulumi.StringPtrOutput

func (LookupPipelineResultOutput) Stages added in v0.12.0 

func (o LookupPipelineResultOutput) Stages() PipelineStageDeclarationArrayOutput

func (LookupPipelineResultOutput) Tags added in v0.12.0 

func (o LookupPipelineResultOutput) Tags() PipelineTagArrayOutput

func (LookupPipelineResultOutput) ToLookupPipelineResultOutput added in v0.12.0 

func (o LookupPipelineResultOutput) ToLookupPipelineResultOutput() LookupPipelineResultOutput

func (LookupPipelineResultOutput) ToLookupPipelineResultOutputWithContext added in v0.12.0 

func (o LookupPipelineResultOutput) ToLookupPipelineResultOutputWithContext(ctx context.Context) LookupPipelineResultOutput

func (LookupPipelineResultOutput) Version added in v0.12.0 

func (o LookupPipelineResultOutput) Version() pulumi.StringPtrOutput

type LookupWebhookArgs added in v0.12.0 

type LookupWebhookArgs struct {
	Id string `pulumi:"id"`
}

type LookupWebhookOutputArgs added in v0.12.0 

type LookupWebhookOutputArgs struct {
	Id pulumi.StringInput `pulumi:"id"`
}

func (LookupWebhookOutputArgs) ElementType added in v0.12.0 

func (LookupWebhookOutputArgs) ElementType() reflect.Type

type LookupWebhookResult added in v0.12.0 

type LookupWebhookResult struct {
	Authentication              *string                   `pulumi:"authentication"`
	AuthenticationConfiguration *WebhookAuthConfiguration `pulumi:"authenticationConfiguration"`
	Filters                     []WebhookFilterRule       `pulumi:"filters"`
	Id                          *string                   `pulumi:"id"`
	RegisterWithThirdParty      *bool                     `pulumi:"registerWithThirdParty"`
	TargetAction                *string                   `pulumi:"targetAction"`
	TargetPipeline              *string                   `pulumi:"targetPipeline"`
	TargetPipelineVersion       *int                      `pulumi:"targetPipelineVersion"`
	Url                         *string                   `pulumi:"url"`
}

func LookupWebhook added in v0.12.0 

func LookupWebhook(ctx *pulumi.Context, args *LookupWebhookArgs, opts ...pulumi.InvokeOption) (*LookupWebhookResult, error)

Resource Type definition for AWS::CodePipeline::Webhook

type LookupWebhookResultOutput added in v0.12.0 

type LookupWebhookResultOutput struct{ *pulumi.OutputState }

func LookupWebhookOutput added in v0.12.0 

func LookupWebhookOutput(ctx *pulumi.Context, args LookupWebhookOutputArgs, opts ...pulumi.InvokeOption) LookupWebhookResultOutput

func (LookupWebhookResultOutput) Authentication added in v0.12.0 

func (o LookupWebhookResultOutput) Authentication() pulumi.StringPtrOutput

func (LookupWebhookResultOutput) AuthenticationConfiguration added in v0.12.0 

func (o LookupWebhookResultOutput) AuthenticationConfiguration() WebhookAuthConfigurationPtrOutput

func (LookupWebhookResultOutput) ElementType added in v0.12.0 

func (LookupWebhookResultOutput) ElementType() reflect.Type

func (LookupWebhookResultOutput) Filters added in v0.12.0 

func (o LookupWebhookResultOutput) Filters() WebhookFilterRuleArrayOutput

func (LookupWebhookResultOutput) Id added in v0.12.0 

func (o LookupWebhookResultOutput) Id() pulumi.StringPtrOutput

func (LookupWebhookResultOutput) RegisterWithThirdParty added in v0.12.0 

func (o LookupWebhookResultOutput) RegisterWithThirdParty() pulumi.BoolPtrOutput

func (LookupWebhookResultOutput) TargetAction added in v0.12.0 

func (o LookupWebhookResultOutput) TargetAction() pulumi.StringPtrOutput

func (LookupWebhookResultOutput) TargetPipeline added in v0.12.0 

func (o LookupWebhookResultOutput) TargetPipeline() pulumi.StringPtrOutput

func (LookupWebhookResultOutput) TargetPipelineVersion added in v0.12.0 

func (o LookupWebhookResultOutput) TargetPipelineVersion() pulumi.IntPtrOutput

func (LookupWebhookResultOutput) ToLookupWebhookResultOutput added in v0.12.0 

func (o LookupWebhookResultOutput) ToLookupWebhookResultOutput() LookupWebhookResultOutput

func (LookupWebhookResultOutput) ToLookupWebhookResultOutputWithContext added in v0.12.0 

func (o LookupWebhookResultOutput) ToLookupWebhookResultOutputWithContext(ctx context.Context) LookupWebhookResultOutput

func (LookupWebhookResultOutput) Url added in v0.12.0 

func (o LookupWebhookResultOutput) Url() pulumi.StringPtrOutput

type Pipeline deprecated 

type Pipeline struct {
	pulumi.CustomResourceState

	ArtifactStore                  PipelineArtifactStorePtrOutput      `pulumi:"artifactStore"`
	ArtifactStores                 PipelineArtifactStoreMapArrayOutput `pulumi:"artifactStores"`
	DisableInboundStageTransitions PipelineStageTransitionArrayOutput  `pulumi:"disableInboundStageTransitions"`
	Name                           pulumi.StringPtrOutput              `pulumi:"name"`
	RestartExecutionOnUpdate       pulumi.BoolPtrOutput                `pulumi:"restartExecutionOnUpdate"`
	RoleArn                        pulumi.StringOutput                 `pulumi:"roleArn"`
	Stages                         PipelineStageDeclarationArrayOutput `pulumi:"stages"`
	Tags                           PipelineTagArrayOutput              `pulumi:"tags"`
	Version                        pulumi.StringOutput                 `pulumi:"version"`
}

Resource Type definition for AWS::CodePipeline::Pipeline

Deprecated: Pipeline is not yet supported by AWS Native, so its creation will currently fail. Please use the classic AWS provider, if possible.

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 PipelineActionDeclaration 

type PipelineActionDeclaration struct {
	ActionTypeId    PipelineActionTypeId     `pulumi:"actionTypeId"`
	Configuration   interface{}              `pulumi:"configuration"`
	InputArtifacts  []PipelineInputArtifact  `pulumi:"inputArtifacts"`
	Name            string                   `pulumi:"name"`
	Namespace       *string                  `pulumi:"namespace"`
	OutputArtifacts []PipelineOutputArtifact `pulumi:"outputArtifacts"`
	Region          *string                  `pulumi:"region"`
	RoleArn         *string                  `pulumi:"roleArn"`
	RunOrder        *int                     `pulumi:"runOrder"`
}

type PipelineActionDeclarationArgs 

type PipelineActionDeclarationArgs struct {
	ActionTypeId    PipelineActionTypeIdInput        `pulumi:"actionTypeId"`
	Configuration   pulumi.Input                     `pulumi:"configuration"`
	InputArtifacts  PipelineInputArtifactArrayInput  `pulumi:"inputArtifacts"`
	Name            pulumi.StringInput               `pulumi:"name"`
	Namespace       pulumi.StringPtrInput            `pulumi:"namespace"`
	OutputArtifacts PipelineOutputArtifactArrayInput `pulumi:"outputArtifacts"`
	Region          pulumi.StringPtrInput            `pulumi:"region"`
	RoleArn         pulumi.StringPtrInput            `pulumi:"roleArn"`
	RunOrder        pulumi.IntPtrInput               `pulumi:"runOrder"`
}

func (PipelineActionDeclarationArgs) ElementType 

func (PipelineActionDeclarationArgs) ElementType() reflect.Type

func (PipelineActionDeclarationArgs) ToPipelineActionDeclarationOutput 

func (i PipelineActionDeclarationArgs) ToPipelineActionDeclarationOutput() PipelineActionDeclarationOutput

func (PipelineActionDeclarationArgs) ToPipelineActionDeclarationOutputWithContext 

func (i PipelineActionDeclarationArgs) ToPipelineActionDeclarationOutputWithContext(ctx context.Context) PipelineActionDeclarationOutput

type PipelineActionDeclarationArray 

type PipelineActionDeclarationArray []PipelineActionDeclarationInput

func (PipelineActionDeclarationArray) ElementType 

func (PipelineActionDeclarationArray) ElementType() reflect.Type

func (PipelineActionDeclarationArray) ToPipelineActionDeclarationArrayOutput 

func (i PipelineActionDeclarationArray) ToPipelineActionDeclarationArrayOutput() PipelineActionDeclarationArrayOutput

func (PipelineActionDeclarationArray) ToPipelineActionDeclarationArrayOutputWithContext 

func (i PipelineActionDeclarationArray) ToPipelineActionDeclarationArrayOutputWithContext(ctx context.Context) PipelineActionDeclarationArrayOutput

type PipelineActionDeclarationArrayInput 

type PipelineActionDeclarationArrayInput interface {
	pulumi.Input

	ToPipelineActionDeclarationArrayOutput() PipelineActionDeclarationArrayOutput
	ToPipelineActionDeclarationArrayOutputWithContext(context.Context) PipelineActionDeclarationArrayOutput
}

PipelineActionDeclarationArrayInput is an input type that accepts PipelineActionDeclarationArray and PipelineActionDeclarationArrayOutput values. You can construct a concrete instance of `PipelineActionDeclarationArrayInput` via: 

PipelineActionDeclarationArray{ PipelineActionDeclarationArgs{...} }

type PipelineActionDeclarationArrayOutput 

type PipelineActionDeclarationArrayOutput struct{ *pulumi.OutputState }

func (PipelineActionDeclarationArrayOutput) ElementType 

func (PipelineActionDeclarationArrayOutput) ElementType() reflect.Type

func (PipelineActionDeclarationArrayOutput) Index 

func (o PipelineActionDeclarationArrayOutput) Index(i pulumi.IntInput) PipelineActionDeclarationOutput

func (PipelineActionDeclarationArrayOutput) ToPipelineActionDeclarationArrayOutput 

func (o PipelineActionDeclarationArrayOutput) ToPipelineActionDeclarationArrayOutput() PipelineActionDeclarationArrayOutput

func (PipelineActionDeclarationArrayOutput) ToPipelineActionDeclarationArrayOutputWithContext 

func (o PipelineActionDeclarationArrayOutput) ToPipelineActionDeclarationArrayOutputWithContext(ctx context.Context) PipelineActionDeclarationArrayOutput

type PipelineActionDeclarationInput 

type PipelineActionDeclarationInput interface {
	pulumi.Input

	ToPipelineActionDeclarationOutput() PipelineActionDeclarationOutput
	ToPipelineActionDeclarationOutputWithContext(context.Context) PipelineActionDeclarationOutput
}

PipelineActionDeclarationInput is an input type that accepts PipelineActionDeclarationArgs and PipelineActionDeclarationOutput values. You can construct a concrete instance of `PipelineActionDeclarationInput` via: 

PipelineActionDeclarationArgs{...}

type PipelineActionDeclarationOutput 

type PipelineActionDeclarationOutput struct{ *pulumi.OutputState }

func (PipelineActionDeclarationOutput) ActionTypeId 

func (o PipelineActionDeclarationOutput) ActionTypeId() PipelineActionTypeIdOutput

func (PipelineActionDeclarationOutput) Configuration 

func (o PipelineActionDeclarationOutput) Configuration() pulumi.AnyOutput

func (PipelineActionDeclarationOutput) ElementType 

func (PipelineActionDeclarationOutput) ElementType() reflect.Type

func (PipelineActionDeclarationOutput) InputArtifacts 

func (o PipelineActionDeclarationOutput) InputArtifacts() PipelineInputArtifactArrayOutput

func (PipelineActionDeclarationOutput) Name 

func (o PipelineActionDeclarationOutput) Name() pulumi.StringOutput

func (PipelineActionDeclarationOutput) Namespace 

func (o PipelineActionDeclarationOutput) Namespace() pulumi.StringPtrOutput

func (PipelineActionDeclarationOutput) OutputArtifacts 

func (o PipelineActionDeclarationOutput) OutputArtifacts() PipelineOutputArtifactArrayOutput

func (PipelineActionDeclarationOutput) Region 

func (o PipelineActionDeclarationOutput) Region() pulumi.StringPtrOutput

func (PipelineActionDeclarationOutput) RoleArn 

func (o PipelineActionDeclarationOutput) RoleArn() pulumi.StringPtrOutput

func (PipelineActionDeclarationOutput) RunOrder 

func (o PipelineActionDeclarationOutput) RunOrder() pulumi.IntPtrOutput

func (PipelineActionDeclarationOutput) ToPipelineActionDeclarationOutput 

func (o PipelineActionDeclarationOutput) ToPipelineActionDeclarationOutput() PipelineActionDeclarationOutput

func (PipelineActionDeclarationOutput) ToPipelineActionDeclarationOutputWithContext 

func (o PipelineActionDeclarationOutput) ToPipelineActionDeclarationOutputWithContext(ctx context.Context) PipelineActionDeclarationOutput

type PipelineActionTypeId 

type PipelineActionTypeId struct {
	Category string `pulumi:"category"`
	Owner    string `pulumi:"owner"`
	Provider string `pulumi:"provider"`
	Version  string `pulumi:"version"`
}

type PipelineActionTypeIdArgs 

type PipelineActionTypeIdArgs struct {
	Category pulumi.StringInput `pulumi:"category"`
	Owner    pulumi.StringInput `pulumi:"owner"`
	Provider pulumi.StringInput `pulumi:"provider"`
	Version  pulumi.StringInput `pulumi:"version"`
}

func (PipelineActionTypeIdArgs) ElementType 

func (PipelineActionTypeIdArgs) ElementType() reflect.Type

func (PipelineActionTypeIdArgs) ToPipelineActionTypeIdOutput 

func (i PipelineActionTypeIdArgs) ToPipelineActionTypeIdOutput() PipelineActionTypeIdOutput

func (PipelineActionTypeIdArgs) ToPipelineActionTypeIdOutputWithContext 

func (i PipelineActionTypeIdArgs) ToPipelineActionTypeIdOutputWithContext(ctx context.Context) PipelineActionTypeIdOutput

type PipelineActionTypeIdInput 

type PipelineActionTypeIdInput interface {
	pulumi.Input

	ToPipelineActionTypeIdOutput() PipelineActionTypeIdOutput
	ToPipelineActionTypeIdOutputWithContext(context.Context) PipelineActionTypeIdOutput
}

PipelineActionTypeIdInput is an input type that accepts PipelineActionTypeIdArgs and PipelineActionTypeIdOutput values. You can construct a concrete instance of `PipelineActionTypeIdInput` via: 

PipelineActionTypeIdArgs{...}

type PipelineActionTypeIdOutput 

type PipelineActionTypeIdOutput struct{ *pulumi.OutputState }

func (PipelineActionTypeIdOutput) Category 

func (o PipelineActionTypeIdOutput) Category() pulumi.StringOutput

func (PipelineActionTypeIdOutput) ElementType 

func (PipelineActionTypeIdOutput) ElementType() reflect.Type

func (PipelineActionTypeIdOutput) Owner 

func (o PipelineActionTypeIdOutput) Owner() pulumi.StringOutput

func (PipelineActionTypeIdOutput) Provider 

func (o PipelineActionTypeIdOutput) Provider() pulumi.StringOutput

func (PipelineActionTypeIdOutput) ToPipelineActionTypeIdOutput 

func (o PipelineActionTypeIdOutput) ToPipelineActionTypeIdOutput() PipelineActionTypeIdOutput

func (PipelineActionTypeIdOutput) ToPipelineActionTypeIdOutputWithContext 

func (o PipelineActionTypeIdOutput) ToPipelineActionTypeIdOutputWithContext(ctx context.Context) PipelineActionTypeIdOutput

func (PipelineActionTypeIdOutput) Version 

func (o PipelineActionTypeIdOutput) Version() pulumi.StringOutput

type PipelineArgs 

type PipelineArgs struct {
	ArtifactStore                  PipelineArtifactStorePtrInput
	ArtifactStores                 PipelineArtifactStoreMapArrayInput
	DisableInboundStageTransitions PipelineStageTransitionArrayInput
	Name                           pulumi.StringPtrInput
	RestartExecutionOnUpdate       pulumi.BoolPtrInput
	RoleArn                        pulumi.StringInput
	Stages                         PipelineStageDeclarationArrayInput
	Tags                           PipelineTagArrayInput
}

The set of arguments for constructing a Pipeline resource.

func (PipelineArgs) ElementType 

func (PipelineArgs) ElementType() reflect.Type

type PipelineArtifactStore 

type PipelineArtifactStore struct {
	EncryptionKey *PipelineEncryptionKey `pulumi:"encryptionKey"`
	Location      string                 `pulumi:"location"`
	Type          string                 `pulumi:"type"`
}

type PipelineArtifactStoreArgs 

type PipelineArtifactStoreArgs struct {
	EncryptionKey PipelineEncryptionKeyPtrInput `pulumi:"encryptionKey"`
	Location      pulumi.StringInput            `pulumi:"location"`
	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

func (PipelineArtifactStoreArgs) ToPipelineArtifactStorePtrOutput 

func (i PipelineArtifactStoreArgs) ToPipelineArtifactStorePtrOutput() PipelineArtifactStorePtrOutput

func (PipelineArtifactStoreArgs) ToPipelineArtifactStorePtrOutputWithContext 

func (i PipelineArtifactStoreArgs) ToPipelineArtifactStorePtrOutputWithContext(ctx context.Context) PipelineArtifactStorePtrOutput

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 PipelineArtifactStoreMap 

type PipelineArtifactStoreMap struct {
	ArtifactStore PipelineArtifactStore `pulumi:"artifactStore"`
	Region        string                `pulumi:"region"`
}

type PipelineArtifactStoreMapArgs 

type PipelineArtifactStoreMapArgs struct {
	ArtifactStore PipelineArtifactStoreInput `pulumi:"artifactStore"`
	Region        pulumi.StringInput         `pulumi:"region"`
}

func (PipelineArtifactStoreMapArgs) ElementType 

func (PipelineArtifactStoreMapArgs) ElementType() reflect.Type

func (PipelineArtifactStoreMapArgs) ToPipelineArtifactStoreMapOutput 

func (i PipelineArtifactStoreMapArgs) ToPipelineArtifactStoreMapOutput() PipelineArtifactStoreMapOutput

func (PipelineArtifactStoreMapArgs) ToPipelineArtifactStoreMapOutputWithContext 

func (i PipelineArtifactStoreMapArgs) ToPipelineArtifactStoreMapOutputWithContext(ctx context.Context) PipelineArtifactStoreMapOutput

type PipelineArtifactStoreMapArray 

type PipelineArtifactStoreMapArray []PipelineArtifactStoreMapInput

func (PipelineArtifactStoreMapArray) ElementType 

func (PipelineArtifactStoreMapArray) ElementType() reflect.Type

func (PipelineArtifactStoreMapArray) ToPipelineArtifactStoreMapArrayOutput 

func (i PipelineArtifactStoreMapArray) ToPipelineArtifactStoreMapArrayOutput() PipelineArtifactStoreMapArrayOutput

func (PipelineArtifactStoreMapArray) ToPipelineArtifactStoreMapArrayOutputWithContext 

func (i PipelineArtifactStoreMapArray) ToPipelineArtifactStoreMapArrayOutputWithContext(ctx context.Context) PipelineArtifactStoreMapArrayOutput

type PipelineArtifactStoreMapArrayInput 

type PipelineArtifactStoreMapArrayInput interface {
	pulumi.Input

	ToPipelineArtifactStoreMapArrayOutput() PipelineArtifactStoreMapArrayOutput
	ToPipelineArtifactStoreMapArrayOutputWithContext(context.Context) PipelineArtifactStoreMapArrayOutput
}

PipelineArtifactStoreMapArrayInput is an input type that accepts PipelineArtifactStoreMapArray and PipelineArtifactStoreMapArrayOutput values. You can construct a concrete instance of `PipelineArtifactStoreMapArrayInput` via: 

PipelineArtifactStoreMapArray{ PipelineArtifactStoreMapArgs{...} }

type PipelineArtifactStoreMapArrayOutput 

type PipelineArtifactStoreMapArrayOutput struct{ *pulumi.OutputState }

func (PipelineArtifactStoreMapArrayOutput) ElementType 

func (PipelineArtifactStoreMapArrayOutput) ElementType() reflect.Type

func (PipelineArtifactStoreMapArrayOutput) Index 

func (o PipelineArtifactStoreMapArrayOutput) Index(i pulumi.IntInput) PipelineArtifactStoreMapOutput

func (PipelineArtifactStoreMapArrayOutput) ToPipelineArtifactStoreMapArrayOutput 

func (o PipelineArtifactStoreMapArrayOutput) ToPipelineArtifactStoreMapArrayOutput() PipelineArtifactStoreMapArrayOutput

func (PipelineArtifactStoreMapArrayOutput) ToPipelineArtifactStoreMapArrayOutputWithContext 

func (o PipelineArtifactStoreMapArrayOutput) ToPipelineArtifactStoreMapArrayOutputWithContext(ctx context.Context) PipelineArtifactStoreMapArrayOutput

type PipelineArtifactStoreMapInput 

type PipelineArtifactStoreMapInput interface {
	pulumi.Input

	ToPipelineArtifactStoreMapOutput() PipelineArtifactStoreMapOutput
	ToPipelineArtifactStoreMapOutputWithContext(context.Context) PipelineArtifactStoreMapOutput
}

PipelineArtifactStoreMapInput is an input type that accepts PipelineArtifactStoreMap and PipelineArtifactStoreMapOutput values. You can construct a concrete instance of `PipelineArtifactStoreMapInput` via: 

PipelineArtifactStoreMap{ "key": PipelineArtifactStoreArgs{...} }

type PipelineArtifactStoreMapOutput 

type PipelineArtifactStoreMapOutput struct{ *pulumi.OutputState }

func (PipelineArtifactStoreMapOutput) ArtifactStore 

func (o PipelineArtifactStoreMapOutput) ArtifactStore() PipelineArtifactStoreOutput

func (PipelineArtifactStoreMapOutput) ElementType 

func (PipelineArtifactStoreMapOutput) ElementType() reflect.Type

func (PipelineArtifactStoreMapOutput) Region 

func (o PipelineArtifactStoreMapOutput) Region() pulumi.StringOutput

func (PipelineArtifactStoreMapOutput) ToPipelineArtifactStoreMapOutput 

func (o PipelineArtifactStoreMapOutput) ToPipelineArtifactStoreMapOutput() PipelineArtifactStoreMapOutput

func (PipelineArtifactStoreMapOutput) ToPipelineArtifactStoreMapOutputWithContext 

func (o PipelineArtifactStoreMapOutput) ToPipelineArtifactStoreMapOutputWithContext(ctx context.Context) PipelineArtifactStoreMapOutput

type PipelineArtifactStoreOutput 

type PipelineArtifactStoreOutput struct{ *pulumi.OutputState }

func (PipelineArtifactStoreOutput) ElementType 

func (PipelineArtifactStoreOutput) ElementType() reflect.Type

func (PipelineArtifactStoreOutput) EncryptionKey 

func (o PipelineArtifactStoreOutput) EncryptionKey() PipelineEncryptionKeyPtrOutput

func (PipelineArtifactStoreOutput) Location 

func (o PipelineArtifactStoreOutput) Location() pulumi.StringOutput

func (PipelineArtifactStoreOutput) ToPipelineArtifactStoreOutput 

func (o PipelineArtifactStoreOutput) ToPipelineArtifactStoreOutput() PipelineArtifactStoreOutput

func (PipelineArtifactStoreOutput) ToPipelineArtifactStoreOutputWithContext 

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

func (PipelineArtifactStoreOutput) ToPipelineArtifactStorePtrOutput 

func (o PipelineArtifactStoreOutput) ToPipelineArtifactStorePtrOutput() PipelineArtifactStorePtrOutput

func (PipelineArtifactStoreOutput) ToPipelineArtifactStorePtrOutputWithContext 

func (o PipelineArtifactStoreOutput) ToPipelineArtifactStorePtrOutputWithContext(ctx context.Context) PipelineArtifactStorePtrOutput

func (PipelineArtifactStoreOutput) Type 

func (o PipelineArtifactStoreOutput) Type() pulumi.StringOutput

type PipelineArtifactStorePtrInput 

type PipelineArtifactStorePtrInput interface {
	pulumi.Input

	ToPipelineArtifactStorePtrOutput() PipelineArtifactStorePtrOutput
	ToPipelineArtifactStorePtrOutputWithContext(context.Context) PipelineArtifactStorePtrOutput
}

PipelineArtifactStorePtrInput is an input type that accepts PipelineArtifactStoreArgs, PipelineArtifactStorePtr and PipelineArtifactStorePtrOutput values. You can construct a concrete instance of `PipelineArtifactStorePtrInput` via: 

        PipelineArtifactStoreArgs{...}

or:

        nil

func PipelineArtifactStorePtr 

func PipelineArtifactStorePtr(v *PipelineArtifactStoreArgs) PipelineArtifactStorePtrInput

type PipelineArtifactStorePtrOutput 

type PipelineArtifactStorePtrOutput struct{ *pulumi.OutputState }

func (PipelineArtifactStorePtrOutput) Elem 

func (o PipelineArtifactStorePtrOutput) Elem() PipelineArtifactStoreOutput

func (PipelineArtifactStorePtrOutput) ElementType 

func (PipelineArtifactStorePtrOutput) ElementType() reflect.Type

func (PipelineArtifactStorePtrOutput) EncryptionKey 

func (o PipelineArtifactStorePtrOutput) EncryptionKey() PipelineEncryptionKeyPtrOutput

func (PipelineArtifactStorePtrOutput) Location 

func (o PipelineArtifactStorePtrOutput) Location() pulumi.StringPtrOutput

func (PipelineArtifactStorePtrOutput) ToPipelineArtifactStorePtrOutput 

func (o PipelineArtifactStorePtrOutput) ToPipelineArtifactStorePtrOutput() PipelineArtifactStorePtrOutput

func (PipelineArtifactStorePtrOutput) ToPipelineArtifactStorePtrOutputWithContext 

func (o PipelineArtifactStorePtrOutput) ToPipelineArtifactStorePtrOutputWithContext(ctx context.Context) PipelineArtifactStorePtrOutput

func (PipelineArtifactStorePtrOutput) Type 

func (o PipelineArtifactStorePtrOutput) Type() pulumi.StringPtrOutput

type PipelineBlockerDeclaration 

type PipelineBlockerDeclaration struct {
	Name string `pulumi:"name"`
	Type string `pulumi:"type"`
}

type PipelineBlockerDeclarationArgs 

type PipelineBlockerDeclarationArgs struct {
	Name pulumi.StringInput `pulumi:"name"`
	Type pulumi.StringInput `pulumi:"type"`
}

func (PipelineBlockerDeclarationArgs) ElementType 

func (PipelineBlockerDeclarationArgs) ElementType() reflect.Type

func (PipelineBlockerDeclarationArgs) ToPipelineBlockerDeclarationOutput 

func (i PipelineBlockerDeclarationArgs) ToPipelineBlockerDeclarationOutput() PipelineBlockerDeclarationOutput

func (PipelineBlockerDeclarationArgs) ToPipelineBlockerDeclarationOutputWithContext 

func (i PipelineBlockerDeclarationArgs) ToPipelineBlockerDeclarationOutputWithContext(ctx context.Context) PipelineBlockerDeclarationOutput

type PipelineBlockerDeclarationArray 

type PipelineBlockerDeclarationArray []PipelineBlockerDeclarationInput

func (PipelineBlockerDeclarationArray) ElementType 

func (PipelineBlockerDeclarationArray) ElementType() reflect.Type

func (PipelineBlockerDeclarationArray) ToPipelineBlockerDeclarationArrayOutput 

func (i PipelineBlockerDeclarationArray) ToPipelineBlockerDeclarationArrayOutput() PipelineBlockerDeclarationArrayOutput

func (PipelineBlockerDeclarationArray) ToPipelineBlockerDeclarationArrayOutputWithContext 

func (i PipelineBlockerDeclarationArray) ToPipelineBlockerDeclarationArrayOutputWithContext(ctx context.Context) PipelineBlockerDeclarationArrayOutput

type PipelineBlockerDeclarationArrayInput 

type PipelineBlockerDeclarationArrayInput interface {
	pulumi.Input

	ToPipelineBlockerDeclarationArrayOutput() PipelineBlockerDeclarationArrayOutput
	ToPipelineBlockerDeclarationArrayOutputWithContext(context.Context) PipelineBlockerDeclarationArrayOutput
}

PipelineBlockerDeclarationArrayInput is an input type that accepts PipelineBlockerDeclarationArray and PipelineBlockerDeclarationArrayOutput values. You can construct a concrete instance of `PipelineBlockerDeclarationArrayInput` via: 

PipelineBlockerDeclarationArray{ PipelineBlockerDeclarationArgs{...} }

type PipelineBlockerDeclarationArrayOutput 

type PipelineBlockerDeclarationArrayOutput struct{ *pulumi.OutputState }

func (PipelineBlockerDeclarationArrayOutput) ElementType 

func (PipelineBlockerDeclarationArrayOutput) ElementType() reflect.Type

func (PipelineBlockerDeclarationArrayOutput) Index 

func (o PipelineBlockerDeclarationArrayOutput) Index(i pulumi.IntInput) PipelineBlockerDeclarationOutput

func (PipelineBlockerDeclarationArrayOutput) ToPipelineBlockerDeclarationArrayOutput 

func (o PipelineBlockerDeclarationArrayOutput) ToPipelineBlockerDeclarationArrayOutput() PipelineBlockerDeclarationArrayOutput

func (PipelineBlockerDeclarationArrayOutput) ToPipelineBlockerDeclarationArrayOutputWithContext 

func (o PipelineBlockerDeclarationArrayOutput) ToPipelineBlockerDeclarationArrayOutputWithContext(ctx context.Context) PipelineBlockerDeclarationArrayOutput

type PipelineBlockerDeclarationInput 

type PipelineBlockerDeclarationInput interface {
	pulumi.Input

	ToPipelineBlockerDeclarationOutput() PipelineBlockerDeclarationOutput
	ToPipelineBlockerDeclarationOutputWithContext(context.Context) PipelineBlockerDeclarationOutput
}

PipelineBlockerDeclarationInput is an input type that accepts PipelineBlockerDeclarationArgs and PipelineBlockerDeclarationOutput values. You can construct a concrete instance of `PipelineBlockerDeclarationInput` via: 

PipelineBlockerDeclarationArgs{...}

type PipelineBlockerDeclarationOutput 

type PipelineBlockerDeclarationOutput struct{ *pulumi.OutputState }

func (PipelineBlockerDeclarationOutput) ElementType 

func (PipelineBlockerDeclarationOutput) ElementType() reflect.Type

func (PipelineBlockerDeclarationOutput) Name 

func (o PipelineBlockerDeclarationOutput) Name() pulumi.StringOutput

func (PipelineBlockerDeclarationOutput) ToPipelineBlockerDeclarationOutput 

func (o PipelineBlockerDeclarationOutput) ToPipelineBlockerDeclarationOutput() PipelineBlockerDeclarationOutput

func (PipelineBlockerDeclarationOutput) ToPipelineBlockerDeclarationOutputWithContext 

func (o PipelineBlockerDeclarationOutput) ToPipelineBlockerDeclarationOutputWithContext(ctx context.Context) PipelineBlockerDeclarationOutput

func (PipelineBlockerDeclarationOutput) Type 

func (o PipelineBlockerDeclarationOutput) Type() pulumi.StringOutput

type PipelineEncryptionKey 

type PipelineEncryptionKey struct {
	Id   string `pulumi:"id"`
	Type string `pulumi:"type"`
}

type PipelineEncryptionKeyArgs 

type PipelineEncryptionKeyArgs struct {
	Id   pulumi.StringInput `pulumi:"id"`
	Type pulumi.StringInput `pulumi:"type"`
}

func (PipelineEncryptionKeyArgs) ElementType 

func (PipelineEncryptionKeyArgs) ElementType() reflect.Type

func (PipelineEncryptionKeyArgs) ToPipelineEncryptionKeyOutput 

func (i PipelineEncryptionKeyArgs) ToPipelineEncryptionKeyOutput() PipelineEncryptionKeyOutput

func (PipelineEncryptionKeyArgs) ToPipelineEncryptionKeyOutputWithContext 

func (i PipelineEncryptionKeyArgs) ToPipelineEncryptionKeyOutputWithContext(ctx context.Context) PipelineEncryptionKeyOutput

func (PipelineEncryptionKeyArgs) ToPipelineEncryptionKeyPtrOutput 

func (i PipelineEncryptionKeyArgs) ToPipelineEncryptionKeyPtrOutput() PipelineEncryptionKeyPtrOutput

func (PipelineEncryptionKeyArgs) ToPipelineEncryptionKeyPtrOutputWithContext 

func (i PipelineEncryptionKeyArgs) ToPipelineEncryptionKeyPtrOutputWithContext(ctx context.Context) PipelineEncryptionKeyPtrOutput

type PipelineEncryptionKeyInput 

type PipelineEncryptionKeyInput interface {
	pulumi.Input

	ToPipelineEncryptionKeyOutput() PipelineEncryptionKeyOutput
	ToPipelineEncryptionKeyOutputWithContext(context.Context) PipelineEncryptionKeyOutput
}

PipelineEncryptionKeyInput is an input type that accepts PipelineEncryptionKeyArgs and PipelineEncryptionKeyOutput values. You can construct a concrete instance of `PipelineEncryptionKeyInput` via: 

PipelineEncryptionKeyArgs{...}

type PipelineEncryptionKeyOutput 

type PipelineEncryptionKeyOutput struct{ *pulumi.OutputState }

func (PipelineEncryptionKeyOutput) ElementType 

func (PipelineEncryptionKeyOutput) ElementType() reflect.Type

func (PipelineEncryptionKeyOutput) Id 

func (o PipelineEncryptionKeyOutput) Id() pulumi.StringOutput

func (PipelineEncryptionKeyOutput) ToPipelineEncryptionKeyOutput 

func (o PipelineEncryptionKeyOutput) ToPipelineEncryptionKeyOutput() PipelineEncryptionKeyOutput

func (PipelineEncryptionKeyOutput) ToPipelineEncryptionKeyOutputWithContext 

func (o PipelineEncryptionKeyOutput) ToPipelineEncryptionKeyOutputWithContext(ctx context.Context) PipelineEncryptionKeyOutput

func (PipelineEncryptionKeyOutput) ToPipelineEncryptionKeyPtrOutput 

func (o PipelineEncryptionKeyOutput) ToPipelineEncryptionKeyPtrOutput() PipelineEncryptionKeyPtrOutput

func (PipelineEncryptionKeyOutput) ToPipelineEncryptionKeyPtrOutputWithContext 

func (o PipelineEncryptionKeyOutput) ToPipelineEncryptionKeyPtrOutputWithContext(ctx context.Context) PipelineEncryptionKeyPtrOutput

func (PipelineEncryptionKeyOutput) Type 

func (o PipelineEncryptionKeyOutput) Type() pulumi.StringOutput

type PipelineEncryptionKeyPtrInput 

type PipelineEncryptionKeyPtrInput interface {
	pulumi.Input

	ToPipelineEncryptionKeyPtrOutput() PipelineEncryptionKeyPtrOutput
	ToPipelineEncryptionKeyPtrOutputWithContext(context.Context) PipelineEncryptionKeyPtrOutput
}

PipelineEncryptionKeyPtrInput is an input type that accepts PipelineEncryptionKeyArgs, PipelineEncryptionKeyPtr and PipelineEncryptionKeyPtrOutput values. You can construct a concrete instance of `PipelineEncryptionKeyPtrInput` via: 

        PipelineEncryptionKeyArgs{...}

or:

        nil

func PipelineEncryptionKeyPtr 

func PipelineEncryptionKeyPtr(v *PipelineEncryptionKeyArgs) PipelineEncryptionKeyPtrInput

type PipelineEncryptionKeyPtrOutput 

type PipelineEncryptionKeyPtrOutput struct{ *pulumi.OutputState }

func (PipelineEncryptionKeyPtrOutput) Elem 

func (o PipelineEncryptionKeyPtrOutput) Elem() PipelineEncryptionKeyOutput

func (PipelineEncryptionKeyPtrOutput) ElementType 

func (PipelineEncryptionKeyPtrOutput) ElementType() reflect.Type

func (PipelineEncryptionKeyPtrOutput) Id 

func (o PipelineEncryptionKeyPtrOutput) Id() pulumi.StringPtrOutput

func (PipelineEncryptionKeyPtrOutput) ToPipelineEncryptionKeyPtrOutput 

func (o PipelineEncryptionKeyPtrOutput) ToPipelineEncryptionKeyPtrOutput() PipelineEncryptionKeyPtrOutput

func (PipelineEncryptionKeyPtrOutput) ToPipelineEncryptionKeyPtrOutputWithContext 

func (o PipelineEncryptionKeyPtrOutput) ToPipelineEncryptionKeyPtrOutputWithContext(ctx context.Context) PipelineEncryptionKeyPtrOutput

func (PipelineEncryptionKeyPtrOutput) Type 

func (o PipelineEncryptionKeyPtrOutput) Type() pulumi.StringPtrOutput

type PipelineInput 

type PipelineInput interface {
	pulumi.Input

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

type PipelineInputArtifact 

type PipelineInputArtifact struct {
	Name string `pulumi:"name"`
}

type PipelineInputArtifactArgs 

type PipelineInputArtifactArgs struct {
	Name pulumi.StringInput `pulumi:"name"`
}

func (PipelineInputArtifactArgs) ElementType 

func (PipelineInputArtifactArgs) ElementType() reflect.Type

func (PipelineInputArtifactArgs) ToPipelineInputArtifactOutput 

func (i PipelineInputArtifactArgs) ToPipelineInputArtifactOutput() PipelineInputArtifactOutput

func (PipelineInputArtifactArgs) ToPipelineInputArtifactOutputWithContext 

func (i PipelineInputArtifactArgs) ToPipelineInputArtifactOutputWithContext(ctx context.Context) PipelineInputArtifactOutput

type PipelineInputArtifactArray 

type PipelineInputArtifactArray []PipelineInputArtifactInput

func (PipelineInputArtifactArray) ElementType 

func (PipelineInputArtifactArray) ElementType() reflect.Type

func (PipelineInputArtifactArray) ToPipelineInputArtifactArrayOutput 

func (i PipelineInputArtifactArray) ToPipelineInputArtifactArrayOutput() PipelineInputArtifactArrayOutput

func (PipelineInputArtifactArray) ToPipelineInputArtifactArrayOutputWithContext 

func (i PipelineInputArtifactArray) ToPipelineInputArtifactArrayOutputWithContext(ctx context.Context) PipelineInputArtifactArrayOutput

type PipelineInputArtifactArrayInput 

type PipelineInputArtifactArrayInput interface {
	pulumi.Input

	ToPipelineInputArtifactArrayOutput() PipelineInputArtifactArrayOutput
	ToPipelineInputArtifactArrayOutputWithContext(context.Context) PipelineInputArtifactArrayOutput
}

PipelineInputArtifactArrayInput is an input type that accepts PipelineInputArtifactArray and PipelineInputArtifactArrayOutput values. You can construct a concrete instance of `PipelineInputArtifactArrayInput` via: 

PipelineInputArtifactArray{ PipelineInputArtifactArgs{...} }

type PipelineInputArtifactArrayOutput 

type PipelineInputArtifactArrayOutput struct{ *pulumi.OutputState }

func (PipelineInputArtifactArrayOutput) ElementType 

func (PipelineInputArtifactArrayOutput) ElementType() reflect.Type

func (PipelineInputArtifactArrayOutput) Index 

func (o PipelineInputArtifactArrayOutput) Index(i pulumi.IntInput) PipelineInputArtifactOutput

func (PipelineInputArtifactArrayOutput) ToPipelineInputArtifactArrayOutput 

func (o PipelineInputArtifactArrayOutput) ToPipelineInputArtifactArrayOutput() PipelineInputArtifactArrayOutput

func (PipelineInputArtifactArrayOutput) ToPipelineInputArtifactArrayOutputWithContext 

func (o PipelineInputArtifactArrayOutput) ToPipelineInputArtifactArrayOutputWithContext(ctx context.Context) PipelineInputArtifactArrayOutput

type PipelineInputArtifactInput 

type PipelineInputArtifactInput interface {
	pulumi.Input

	ToPipelineInputArtifactOutput() PipelineInputArtifactOutput
	ToPipelineInputArtifactOutputWithContext(context.Context) PipelineInputArtifactOutput
}

PipelineInputArtifactInput is an input type that accepts PipelineInputArtifactArgs and PipelineInputArtifactOutput values. You can construct a concrete instance of `PipelineInputArtifactInput` via: 

PipelineInputArtifactArgs{...}

type PipelineInputArtifactOutput 

type PipelineInputArtifactOutput struct{ *pulumi.OutputState }

func (PipelineInputArtifactOutput) ElementType 

func (PipelineInputArtifactOutput) ElementType() reflect.Type

func (PipelineInputArtifactOutput) Name 

func (o PipelineInputArtifactOutput) Name() pulumi.StringOutput

func (PipelineInputArtifactOutput) ToPipelineInputArtifactOutput 

func (o PipelineInputArtifactOutput) ToPipelineInputArtifactOutput() PipelineInputArtifactOutput

func (PipelineInputArtifactOutput) ToPipelineInputArtifactOutputWithContext 

func (o PipelineInputArtifactOutput) ToPipelineInputArtifactOutputWithContext(ctx context.Context) PipelineInputArtifactOutput

type PipelineOutput 

type PipelineOutput struct{ *pulumi.OutputState }

func (PipelineOutput) ArtifactStore added in v0.17.0 

func (o PipelineOutput) ArtifactStore() PipelineArtifactStorePtrOutput

func (PipelineOutput) ArtifactStores added in v0.17.0 

func (o PipelineOutput) ArtifactStores() PipelineArtifactStoreMapArrayOutput

func (PipelineOutput) DisableInboundStageTransitions added in v0.17.0 

func (o PipelineOutput) DisableInboundStageTransitions() PipelineStageTransitionArrayOutput

func (PipelineOutput) ElementType 

func (PipelineOutput) ElementType() reflect.Type

func (PipelineOutput) Name added in v0.17.0 

func (o PipelineOutput) Name() pulumi.StringPtrOutput

func (PipelineOutput) RestartExecutionOnUpdate added in v0.17.0 

func (o PipelineOutput) RestartExecutionOnUpdate() pulumi.BoolPtrOutput

func (PipelineOutput) RoleArn added in v0.17.0 

func (o PipelineOutput) RoleArn() pulumi.StringOutput

func (PipelineOutput) Stages added in v0.17.0 

func (o PipelineOutput) Stages() PipelineStageDeclarationArrayOutput

func (PipelineOutput) Tags added in v0.17.0 

func (o PipelineOutput) Tags() PipelineTagArrayOutput

func (PipelineOutput) ToPipelineOutput 

func (o PipelineOutput) ToPipelineOutput() PipelineOutput

func (PipelineOutput) ToPipelineOutputWithContext 

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

func (PipelineOutput) Version added in v0.17.0 

func (o PipelineOutput) Version() pulumi.StringOutput

type PipelineOutputArtifact 

type PipelineOutputArtifact struct {
	Name string `pulumi:"name"`
}

type PipelineOutputArtifactArgs 

type PipelineOutputArtifactArgs struct {
	Name pulumi.StringInput `pulumi:"name"`
}

func (PipelineOutputArtifactArgs) ElementType 

func (PipelineOutputArtifactArgs) ElementType() reflect.Type

func (PipelineOutputArtifactArgs) ToPipelineOutputArtifactOutput 

func (i PipelineOutputArtifactArgs) ToPipelineOutputArtifactOutput() PipelineOutputArtifactOutput

func (PipelineOutputArtifactArgs) ToPipelineOutputArtifactOutputWithContext 

func (i PipelineOutputArtifactArgs) ToPipelineOutputArtifactOutputWithContext(ctx context.Context) PipelineOutputArtifactOutput

type PipelineOutputArtifactArray 

type PipelineOutputArtifactArray []PipelineOutputArtifactInput

func (PipelineOutputArtifactArray) ElementType 

func (PipelineOutputArtifactArray) ElementType() reflect.Type

func (PipelineOutputArtifactArray) ToPipelineOutputArtifactArrayOutput 

func (i PipelineOutputArtifactArray) ToPipelineOutputArtifactArrayOutput() PipelineOutputArtifactArrayOutput

func (PipelineOutputArtifactArray) ToPipelineOutputArtifactArrayOutputWithContext 

func (i PipelineOutputArtifactArray) ToPipelineOutputArtifactArrayOutputWithContext(ctx context.Context) PipelineOutputArtifactArrayOutput

type PipelineOutputArtifactArrayInput 

type PipelineOutputArtifactArrayInput interface {
	pulumi.Input

	ToPipelineOutputArtifactArrayOutput() PipelineOutputArtifactArrayOutput
	ToPipelineOutputArtifactArrayOutputWithContext(context.Context) PipelineOutputArtifactArrayOutput
}

PipelineOutputArtifactArrayInput is an input type that accepts PipelineOutputArtifactArray and PipelineOutputArtifactArrayOutput values. You can construct a concrete instance of `PipelineOutputArtifactArrayInput` via: 

PipelineOutputArtifactArray{ PipelineOutputArtifactArgs{...} }

type PipelineOutputArtifactArrayOutput 

type PipelineOutputArtifactArrayOutput struct{ *pulumi.OutputState }

func (PipelineOutputArtifactArrayOutput) ElementType 

func (PipelineOutputArtifactArrayOutput) ElementType() reflect.Type

func (PipelineOutputArtifactArrayOutput) Index 

func (o PipelineOutputArtifactArrayOutput) Index(i pulumi.IntInput) PipelineOutputArtifactOutput

func (PipelineOutputArtifactArrayOutput) ToPipelineOutputArtifactArrayOutput 

func (o PipelineOutputArtifactArrayOutput) ToPipelineOutputArtifactArrayOutput() PipelineOutputArtifactArrayOutput

func (PipelineOutputArtifactArrayOutput) ToPipelineOutputArtifactArrayOutputWithContext 

func (o PipelineOutputArtifactArrayOutput) ToPipelineOutputArtifactArrayOutputWithContext(ctx context.Context) PipelineOutputArtifactArrayOutput

type PipelineOutputArtifactInput 

type PipelineOutputArtifactInput interface {
	pulumi.Input

	ToPipelineOutputArtifactOutput() PipelineOutputArtifactOutput
	ToPipelineOutputArtifactOutputWithContext(context.Context) PipelineOutputArtifactOutput
}

PipelineOutputArtifactInput is an input type that accepts PipelineOutputArtifactArgs and PipelineOutputArtifactOutput values. You can construct a concrete instance of `PipelineOutputArtifactInput` via: 

PipelineOutputArtifactArgs{...}

type PipelineOutputArtifactOutput 

type PipelineOutputArtifactOutput struct{ *pulumi.OutputState }

func (PipelineOutputArtifactOutput) ElementType 

func (PipelineOutputArtifactOutput) ElementType() reflect.Type

func (PipelineOutputArtifactOutput) Name 

func (o PipelineOutputArtifactOutput) Name() pulumi.StringOutput

func (PipelineOutputArtifactOutput) ToPipelineOutputArtifactOutput 

func (o PipelineOutputArtifactOutput) ToPipelineOutputArtifactOutput() PipelineOutputArtifactOutput

func (PipelineOutputArtifactOutput) ToPipelineOutputArtifactOutputWithContext 

func (o PipelineOutputArtifactOutput) ToPipelineOutputArtifactOutputWithContext(ctx context.Context) PipelineOutputArtifactOutput

type PipelineStageDeclaration 

type PipelineStageDeclaration struct {
	Actions  []PipelineActionDeclaration  `pulumi:"actions"`
	Blockers []PipelineBlockerDeclaration `pulumi:"blockers"`
	Name     string                       `pulumi:"name"`
}

type PipelineStageDeclarationArgs 

type PipelineStageDeclarationArgs struct {
	Actions  PipelineActionDeclarationArrayInput  `pulumi:"actions"`
	Blockers PipelineBlockerDeclarationArrayInput `pulumi:"blockers"`
	Name     pulumi.StringInput                   `pulumi:"name"`
}

func (PipelineStageDeclarationArgs) ElementType 

func (PipelineStageDeclarationArgs) ElementType() reflect.Type

func (PipelineStageDeclarationArgs) ToPipelineStageDeclarationOutput 

func (i PipelineStageDeclarationArgs) ToPipelineStageDeclarationOutput() PipelineStageDeclarationOutput

func (PipelineStageDeclarationArgs) ToPipelineStageDeclarationOutputWithContext 

func (i PipelineStageDeclarationArgs) ToPipelineStageDeclarationOutputWithContext(ctx context.Context) PipelineStageDeclarationOutput

type PipelineStageDeclarationArray 

type PipelineStageDeclarationArray []PipelineStageDeclarationInput

func (PipelineStageDeclarationArray) ElementType 

func (PipelineStageDeclarationArray) ElementType() reflect.Type

func (PipelineStageDeclarationArray) ToPipelineStageDeclarationArrayOutput 

func (i PipelineStageDeclarationArray) ToPipelineStageDeclarationArrayOutput() PipelineStageDeclarationArrayOutput

func (PipelineStageDeclarationArray) ToPipelineStageDeclarationArrayOutputWithContext 

func (i PipelineStageDeclarationArray) ToPipelineStageDeclarationArrayOutputWithContext(ctx context.Context) PipelineStageDeclarationArrayOutput

type PipelineStageDeclarationArrayInput 

type PipelineStageDeclarationArrayInput interface {
	pulumi.Input

	ToPipelineStageDeclarationArrayOutput() PipelineStageDeclarationArrayOutput
	ToPipelineStageDeclarationArrayOutputWithContext(context.Context) PipelineStageDeclarationArrayOutput
}

PipelineStageDeclarationArrayInput is an input type that accepts PipelineStageDeclarationArray and PipelineStageDeclarationArrayOutput values. You can construct a concrete instance of `PipelineStageDeclarationArrayInput` via: 

PipelineStageDeclarationArray{ PipelineStageDeclarationArgs{...} }

type PipelineStageDeclarationArrayOutput 

type PipelineStageDeclarationArrayOutput struct{ *pulumi.OutputState }

func (PipelineStageDeclarationArrayOutput) ElementType 

func (PipelineStageDeclarationArrayOutput) ElementType() reflect.Type

func (PipelineStageDeclarationArrayOutput) Index 

func (o PipelineStageDeclarationArrayOutput) Index(i pulumi.IntInput) PipelineStageDeclarationOutput

func (PipelineStageDeclarationArrayOutput) ToPipelineStageDeclarationArrayOutput 

func (o PipelineStageDeclarationArrayOutput) ToPipelineStageDeclarationArrayOutput() PipelineStageDeclarationArrayOutput

func (PipelineStageDeclarationArrayOutput) ToPipelineStageDeclarationArrayOutputWithContext 

func (o PipelineStageDeclarationArrayOutput) ToPipelineStageDeclarationArrayOutputWithContext(ctx context.Context) PipelineStageDeclarationArrayOutput

type PipelineStageDeclarationInput 

type PipelineStageDeclarationInput interface {
	pulumi.Input

	ToPipelineStageDeclarationOutput() PipelineStageDeclarationOutput
	ToPipelineStageDeclarationOutputWithContext(context.Context) PipelineStageDeclarationOutput
}

PipelineStageDeclarationInput is an input type that accepts PipelineStageDeclarationArgs and PipelineStageDeclarationOutput values. You can construct a concrete instance of `PipelineStageDeclarationInput` via: 

PipelineStageDeclarationArgs{...}

type PipelineStageDeclarationOutput 

type PipelineStageDeclarationOutput struct{ *pulumi.OutputState }

func (PipelineStageDeclarationOutput) Actions 

func (o PipelineStageDeclarationOutput) Actions() PipelineActionDeclarationArrayOutput

func (PipelineStageDeclarationOutput) Blockers 

func (o PipelineStageDeclarationOutput) Blockers() PipelineBlockerDeclarationArrayOutput

func (PipelineStageDeclarationOutput) ElementType 

func (PipelineStageDeclarationOutput) ElementType() reflect.Type

func (PipelineStageDeclarationOutput) Name 

func (o PipelineStageDeclarationOutput) Name() pulumi.StringOutput

func (PipelineStageDeclarationOutput) ToPipelineStageDeclarationOutput 

func (o PipelineStageDeclarationOutput) ToPipelineStageDeclarationOutput() PipelineStageDeclarationOutput

func (PipelineStageDeclarationOutput) ToPipelineStageDeclarationOutputWithContext 

func (o PipelineStageDeclarationOutput) ToPipelineStageDeclarationOutputWithContext(ctx context.Context) PipelineStageDeclarationOutput

type PipelineStageTransition 

type PipelineStageTransition struct {
	Reason    string `pulumi:"reason"`
	StageName string `pulumi:"stageName"`
}

type PipelineStageTransitionArgs 

type PipelineStageTransitionArgs struct {
	Reason    pulumi.StringInput `pulumi:"reason"`
	StageName pulumi.StringInput `pulumi:"stageName"`
}

func (PipelineStageTransitionArgs) ElementType 

func (PipelineStageTransitionArgs) ElementType() reflect.Type

func (PipelineStageTransitionArgs) ToPipelineStageTransitionOutput 

func (i PipelineStageTransitionArgs) ToPipelineStageTransitionOutput() PipelineStageTransitionOutput

func (PipelineStageTransitionArgs) ToPipelineStageTransitionOutputWithContext 

func (i PipelineStageTransitionArgs) ToPipelineStageTransitionOutputWithContext(ctx context.Context) PipelineStageTransitionOutput

type PipelineStageTransitionArray 

type PipelineStageTransitionArray []PipelineStageTransitionInput

func (PipelineStageTransitionArray) ElementType 

func (PipelineStageTransitionArray) ElementType() reflect.Type

func (PipelineStageTransitionArray) ToPipelineStageTransitionArrayOutput 

func (i PipelineStageTransitionArray) ToPipelineStageTransitionArrayOutput() PipelineStageTransitionArrayOutput

func (PipelineStageTransitionArray) ToPipelineStageTransitionArrayOutputWithContext 

func (i PipelineStageTransitionArray) ToPipelineStageTransitionArrayOutputWithContext(ctx context.Context) PipelineStageTransitionArrayOutput

type PipelineStageTransitionArrayInput 

type PipelineStageTransitionArrayInput interface {
	pulumi.Input

	ToPipelineStageTransitionArrayOutput() PipelineStageTransitionArrayOutput
	ToPipelineStageTransitionArrayOutputWithContext(context.Context) PipelineStageTransitionArrayOutput
}

PipelineStageTransitionArrayInput is an input type that accepts PipelineStageTransitionArray and PipelineStageTransitionArrayOutput values. You can construct a concrete instance of `PipelineStageTransitionArrayInput` via: 

PipelineStageTransitionArray{ PipelineStageTransitionArgs{...} }

type PipelineStageTransitionArrayOutput 

type PipelineStageTransitionArrayOutput struct{ *pulumi.OutputState }

func (PipelineStageTransitionArrayOutput) ElementType 

func (PipelineStageTransitionArrayOutput) ElementType() reflect.Type

func (PipelineStageTransitionArrayOutput) Index 

func (o PipelineStageTransitionArrayOutput) Index(i pulumi.IntInput) PipelineStageTransitionOutput

func (PipelineStageTransitionArrayOutput) ToPipelineStageTransitionArrayOutput 

func (o PipelineStageTransitionArrayOutput) ToPipelineStageTransitionArrayOutput() PipelineStageTransitionArrayOutput

func (PipelineStageTransitionArrayOutput) ToPipelineStageTransitionArrayOutputWithContext 

func (o PipelineStageTransitionArrayOutput) ToPipelineStageTransitionArrayOutputWithContext(ctx context.Context) PipelineStageTransitionArrayOutput

type PipelineStageTransitionInput 

type PipelineStageTransitionInput interface {
	pulumi.Input

	ToPipelineStageTransitionOutput() PipelineStageTransitionOutput
	ToPipelineStageTransitionOutputWithContext(context.Context) PipelineStageTransitionOutput
}

PipelineStageTransitionInput is an input type that accepts PipelineStageTransitionArgs and PipelineStageTransitionOutput values. You can construct a concrete instance of `PipelineStageTransitionInput` via: 

PipelineStageTransitionArgs{...}

type PipelineStageTransitionOutput 

type PipelineStageTransitionOutput struct{ *pulumi.OutputState }

func (PipelineStageTransitionOutput) ElementType 

func (PipelineStageTransitionOutput) ElementType() reflect.Type

func (PipelineStageTransitionOutput) Reason 

func (o PipelineStageTransitionOutput) Reason() pulumi.StringOutput

func (PipelineStageTransitionOutput) StageName 

func (o PipelineStageTransitionOutput) StageName() pulumi.StringOutput

func (PipelineStageTransitionOutput) ToPipelineStageTransitionOutput 

func (o PipelineStageTransitionOutput) ToPipelineStageTransitionOutput() PipelineStageTransitionOutput

func (PipelineStageTransitionOutput) ToPipelineStageTransitionOutputWithContext 

func (o PipelineStageTransitionOutput) ToPipelineStageTransitionOutputWithContext(ctx context.Context) PipelineStageTransitionOutput

type PipelineState 

type PipelineState struct {
}

func (PipelineState) ElementType 

func (PipelineState) ElementType() reflect.Type

type PipelineTag 

type PipelineTag struct {
	Key   string `pulumi:"key"`
	Value string `pulumi:"value"`
}

type PipelineTagArgs 

type PipelineTagArgs struct {
	Key   pulumi.StringInput `pulumi:"key"`
	Value pulumi.StringInput `pulumi:"value"`
}

func (PipelineTagArgs) ElementType 

func (PipelineTagArgs) ElementType() reflect.Type

func (PipelineTagArgs) ToPipelineTagOutput 

func (i PipelineTagArgs) ToPipelineTagOutput() PipelineTagOutput

func (PipelineTagArgs) ToPipelineTagOutputWithContext 

func (i PipelineTagArgs) ToPipelineTagOutputWithContext(ctx context.Context) PipelineTagOutput

type PipelineTagArray 

type PipelineTagArray []PipelineTagInput

func (PipelineTagArray) ElementType 

func (PipelineTagArray) ElementType() reflect.Type

func (PipelineTagArray) ToPipelineTagArrayOutput 

func (i PipelineTagArray) ToPipelineTagArrayOutput() PipelineTagArrayOutput

func (PipelineTagArray) ToPipelineTagArrayOutputWithContext 

func (i PipelineTagArray) ToPipelineTagArrayOutputWithContext(ctx context.Context) PipelineTagArrayOutput

type PipelineTagArrayInput 

type PipelineTagArrayInput interface {
	pulumi.Input

	ToPipelineTagArrayOutput() PipelineTagArrayOutput
	ToPipelineTagArrayOutputWithContext(context.Context) PipelineTagArrayOutput
}

PipelineTagArrayInput is an input type that accepts PipelineTagArray and PipelineTagArrayOutput values. You can construct a concrete instance of `PipelineTagArrayInput` via: 

PipelineTagArray{ PipelineTagArgs{...} }

type PipelineTagArrayOutput 

type PipelineTagArrayOutput struct{ *pulumi.OutputState }

func (PipelineTagArrayOutput) ElementType 

func (PipelineTagArrayOutput) ElementType() reflect.Type

func (PipelineTagArrayOutput) Index 

func (o PipelineTagArrayOutput) Index(i pulumi.IntInput) PipelineTagOutput

func (PipelineTagArrayOutput) ToPipelineTagArrayOutput 

func (o PipelineTagArrayOutput) ToPipelineTagArrayOutput() PipelineTagArrayOutput

func (PipelineTagArrayOutput) ToPipelineTagArrayOutputWithContext 

func (o PipelineTagArrayOutput) ToPipelineTagArrayOutputWithContext(ctx context.Context) PipelineTagArrayOutput

type PipelineTagInput 

type PipelineTagInput interface {
	pulumi.Input

	ToPipelineTagOutput() PipelineTagOutput
	ToPipelineTagOutputWithContext(context.Context) PipelineTagOutput
}

PipelineTagInput is an input type that accepts PipelineTagArgs and PipelineTagOutput values. You can construct a concrete instance of `PipelineTagInput` via: 

PipelineTagArgs{...}

type PipelineTagOutput 

type PipelineTagOutput struct{ *pulumi.OutputState }

func (PipelineTagOutput) ElementType 

func (PipelineTagOutput) ElementType() reflect.Type

func (PipelineTagOutput) Key 

func (o PipelineTagOutput) Key() pulumi.StringOutput

func (PipelineTagOutput) ToPipelineTagOutput 

func (o PipelineTagOutput) ToPipelineTagOutput() PipelineTagOutput

func (PipelineTagOutput) ToPipelineTagOutputWithContext 

func (o PipelineTagOutput) ToPipelineTagOutputWithContext(ctx context.Context) PipelineTagOutput

func (PipelineTagOutput) Value 

func (o PipelineTagOutput) Value() pulumi.StringOutput

type Webhook deprecated 

type Webhook struct {
	pulumi.CustomResourceState

	Authentication              pulumi.StringOutput            `pulumi:"authentication"`
	AuthenticationConfiguration WebhookAuthConfigurationOutput `pulumi:"authenticationConfiguration"`
	Filters                     WebhookFilterRuleArrayOutput   `pulumi:"filters"`
	Name                        pulumi.StringPtrOutput         `pulumi:"name"`
	RegisterWithThirdParty      pulumi.BoolPtrOutput           `pulumi:"registerWithThirdParty"`
	TargetAction                pulumi.StringOutput            `pulumi:"targetAction"`
	TargetPipeline              pulumi.StringOutput            `pulumi:"targetPipeline"`
	TargetPipelineVersion       pulumi.IntOutput               `pulumi:"targetPipelineVersion"`
	Url                         pulumi.StringOutput            `pulumi:"url"`
}

Resource Type definition for AWS::CodePipeline::Webhook

Deprecated: Webhook is not yet supported by AWS Native, so its creation will currently fail. Please use the classic AWS provider, if possible.

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 {
	Authentication              pulumi.StringInput
	AuthenticationConfiguration WebhookAuthConfigurationInput
	Filters                     WebhookFilterRuleArrayInput
	Name                        pulumi.StringPtrInput
	RegisterWithThirdParty      pulumi.BoolPtrInput
	TargetAction                pulumi.StringInput
	TargetPipeline              pulumi.StringInput
	TargetPipelineVersion       pulumi.IntInput
}

The set of arguments for constructing a Webhook resource.

func (WebhookArgs) ElementType 

func (WebhookArgs) ElementType() reflect.Type

type WebhookAuthConfiguration added in v0.2.0 

type WebhookAuthConfiguration struct {
	AllowedIPRange *string `pulumi:"allowedIPRange"`
	SecretToken    *string `pulumi:"secretToken"`
}

type WebhookAuthConfigurationArgs added in v0.2.0 

type WebhookAuthConfigurationArgs struct {
	AllowedIPRange pulumi.StringPtrInput `pulumi:"allowedIPRange"`
	SecretToken    pulumi.StringPtrInput `pulumi:"secretToken"`
}

func (WebhookAuthConfigurationArgs) ElementType added in v0.2.0 

func (WebhookAuthConfigurationArgs) ElementType() reflect.Type

func (WebhookAuthConfigurationArgs) ToWebhookAuthConfigurationOutput added in v0.2.0 

func (i WebhookAuthConfigurationArgs) ToWebhookAuthConfigurationOutput() WebhookAuthConfigurationOutput

func (WebhookAuthConfigurationArgs) ToWebhookAuthConfigurationOutputWithContext added in v0.2.0 

func (i WebhookAuthConfigurationArgs) ToWebhookAuthConfigurationOutputWithContext(ctx context.Context) WebhookAuthConfigurationOutput

type WebhookAuthConfigurationInput added in v0.2.0 

type WebhookAuthConfigurationInput interface {
	pulumi.Input

	ToWebhookAuthConfigurationOutput() WebhookAuthConfigurationOutput
	ToWebhookAuthConfigurationOutputWithContext(context.Context) WebhookAuthConfigurationOutput
}

WebhookAuthConfigurationInput is an input type that accepts WebhookAuthConfigurationArgs and WebhookAuthConfigurationOutput values. You can construct a concrete instance of `WebhookAuthConfigurationInput` via: 

WebhookAuthConfigurationArgs{...}

type WebhookAuthConfigurationOutput added in v0.2.0 

type WebhookAuthConfigurationOutput struct{ *pulumi.OutputState }

func (WebhookAuthConfigurationOutput) AllowedIPRange added in v0.2.0 

func (o WebhookAuthConfigurationOutput) AllowedIPRange() pulumi.StringPtrOutput

func (WebhookAuthConfigurationOutput) ElementType added in v0.2.0 

func (WebhookAuthConfigurationOutput) ElementType() reflect.Type

func (WebhookAuthConfigurationOutput) SecretToken added in v0.2.0 

func (o WebhookAuthConfigurationOutput) SecretToken() pulumi.StringPtrOutput

func (WebhookAuthConfigurationOutput) ToWebhookAuthConfigurationOutput added in v0.2.0 

func (o WebhookAuthConfigurationOutput) ToWebhookAuthConfigurationOutput() WebhookAuthConfigurationOutput

func (WebhookAuthConfigurationOutput) ToWebhookAuthConfigurationOutputWithContext added in v0.2.0 

func (o WebhookAuthConfigurationOutput) ToWebhookAuthConfigurationOutputWithContext(ctx context.Context) WebhookAuthConfigurationOutput

type WebhookAuthConfigurationPtrOutput added in v0.2.0 

type WebhookAuthConfigurationPtrOutput struct{ *pulumi.OutputState }

func (WebhookAuthConfigurationPtrOutput) AllowedIPRange added in v0.2.0 

func (o WebhookAuthConfigurationPtrOutput) AllowedIPRange() pulumi.StringPtrOutput

func (WebhookAuthConfigurationPtrOutput) Elem added in v0.2.0 

func (o WebhookAuthConfigurationPtrOutput) Elem() WebhookAuthConfigurationOutput

func (WebhookAuthConfigurationPtrOutput) ElementType added in v0.2.0 

func (WebhookAuthConfigurationPtrOutput) ElementType() reflect.Type

func (WebhookAuthConfigurationPtrOutput) SecretToken added in v0.2.0 

func (o WebhookAuthConfigurationPtrOutput) SecretToken() pulumi.StringPtrOutput

func (WebhookAuthConfigurationPtrOutput) ToWebhookAuthConfigurationPtrOutput added in v0.2.0 

func (o WebhookAuthConfigurationPtrOutput) ToWebhookAuthConfigurationPtrOutput() WebhookAuthConfigurationPtrOutput

func (WebhookAuthConfigurationPtrOutput) ToWebhookAuthConfigurationPtrOutputWithContext added in v0.2.0 

func (o WebhookAuthConfigurationPtrOutput) ToWebhookAuthConfigurationPtrOutputWithContext(ctx context.Context) WebhookAuthConfigurationPtrOutput

type WebhookFilterRule added in v0.2.0 

type WebhookFilterRule struct {
	JsonPath    string  `pulumi:"jsonPath"`
	MatchEquals *string `pulumi:"matchEquals"`
}

type WebhookFilterRuleArgs added in v0.2.0 

type WebhookFilterRuleArgs struct {
	JsonPath    pulumi.StringInput    `pulumi:"jsonPath"`
	MatchEquals pulumi.StringPtrInput `pulumi:"matchEquals"`
}

func (WebhookFilterRuleArgs) ElementType added in v0.2.0 

func (WebhookFilterRuleArgs) ElementType() reflect.Type

func (WebhookFilterRuleArgs) ToWebhookFilterRuleOutput added in v0.2.0 

func (i WebhookFilterRuleArgs) ToWebhookFilterRuleOutput() WebhookFilterRuleOutput

func (WebhookFilterRuleArgs) ToWebhookFilterRuleOutputWithContext added in v0.2.0 

func (i WebhookFilterRuleArgs) ToWebhookFilterRuleOutputWithContext(ctx context.Context) WebhookFilterRuleOutput

type WebhookFilterRuleArray added in v0.2.0 

type WebhookFilterRuleArray []WebhookFilterRuleInput

func (WebhookFilterRuleArray) ElementType added in v0.2.0 

func (WebhookFilterRuleArray) ElementType() reflect.Type

func (WebhookFilterRuleArray) ToWebhookFilterRuleArrayOutput added in v0.2.0 

func (i WebhookFilterRuleArray) ToWebhookFilterRuleArrayOutput() WebhookFilterRuleArrayOutput

func (WebhookFilterRuleArray) ToWebhookFilterRuleArrayOutputWithContext added in v0.2.0 

func (i WebhookFilterRuleArray) ToWebhookFilterRuleArrayOutputWithContext(ctx context.Context) WebhookFilterRuleArrayOutput

type WebhookFilterRuleArrayInput added in v0.2.0 

type WebhookFilterRuleArrayInput interface {
	pulumi.Input

	ToWebhookFilterRuleArrayOutput() WebhookFilterRuleArrayOutput
	ToWebhookFilterRuleArrayOutputWithContext(context.Context) WebhookFilterRuleArrayOutput
}

WebhookFilterRuleArrayInput is an input type that accepts WebhookFilterRuleArray and WebhookFilterRuleArrayOutput values. You can construct a concrete instance of `WebhookFilterRuleArrayInput` via: 

WebhookFilterRuleArray{ WebhookFilterRuleArgs{...} }

type WebhookFilterRuleArrayOutput added in v0.2.0 

type WebhookFilterRuleArrayOutput struct{ *pulumi.OutputState }

func (WebhookFilterRuleArrayOutput) ElementType added in v0.2.0 

func (WebhookFilterRuleArrayOutput) ElementType() reflect.Type

func (WebhookFilterRuleArrayOutput) Index added in v0.2.0 

func (o WebhookFilterRuleArrayOutput) Index(i pulumi.IntInput) WebhookFilterRuleOutput

func (WebhookFilterRuleArrayOutput) ToWebhookFilterRuleArrayOutput added in v0.2.0 

func (o WebhookFilterRuleArrayOutput) ToWebhookFilterRuleArrayOutput() WebhookFilterRuleArrayOutput

func (WebhookFilterRuleArrayOutput) ToWebhookFilterRuleArrayOutputWithContext added in v0.2.0 

func (o WebhookFilterRuleArrayOutput) ToWebhookFilterRuleArrayOutputWithContext(ctx context.Context) WebhookFilterRuleArrayOutput

type WebhookFilterRuleInput added in v0.2.0 

type WebhookFilterRuleInput interface {
	pulumi.Input

	ToWebhookFilterRuleOutput() WebhookFilterRuleOutput
	ToWebhookFilterRuleOutputWithContext(context.Context) WebhookFilterRuleOutput
}

WebhookFilterRuleInput is an input type that accepts WebhookFilterRuleArgs and WebhookFilterRuleOutput values. You can construct a concrete instance of `WebhookFilterRuleInput` via: 

WebhookFilterRuleArgs{...}

type WebhookFilterRuleOutput added in v0.2.0 

type WebhookFilterRuleOutput struct{ *pulumi.OutputState }

func (WebhookFilterRuleOutput) ElementType added in v0.2.0 

func (WebhookFilterRuleOutput) ElementType() reflect.Type

func (WebhookFilterRuleOutput) JsonPath added in v0.2.0 

func (o WebhookFilterRuleOutput) JsonPath() pulumi.StringOutput

func (WebhookFilterRuleOutput) MatchEquals added in v0.2.0 

func (o WebhookFilterRuleOutput) MatchEquals() pulumi.StringPtrOutput

func (WebhookFilterRuleOutput) ToWebhookFilterRuleOutput added in v0.2.0 

func (o WebhookFilterRuleOutput) ToWebhookFilterRuleOutput() WebhookFilterRuleOutput

func (WebhookFilterRuleOutput) ToWebhookFilterRuleOutputWithContext added in v0.2.0 

func (o WebhookFilterRuleOutput) ToWebhookFilterRuleOutputWithContext(ctx context.Context) WebhookFilterRuleOutput

type WebhookInput 

type WebhookInput interface {
	pulumi.Input

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

type WebhookOutput 

type WebhookOutput struct{ *pulumi.OutputState }

func (WebhookOutput) Authentication added in v0.17.0 

func (o WebhookOutput) Authentication() pulumi.StringOutput

func (WebhookOutput) AuthenticationConfiguration added in v0.17.0 

func (o WebhookOutput) AuthenticationConfiguration() WebhookAuthConfigurationOutput

func (WebhookOutput) ElementType 

func (WebhookOutput) ElementType() reflect.Type

func (WebhookOutput) Filters added in v0.17.0 

func (o WebhookOutput) Filters() WebhookFilterRuleArrayOutput

func (WebhookOutput) Name added in v0.17.0 

func (o WebhookOutput) Name() pulumi.StringPtrOutput

func (WebhookOutput) RegisterWithThirdParty added in v0.17.0 

func (o WebhookOutput) RegisterWithThirdParty() pulumi.BoolPtrOutput

func (WebhookOutput) TargetAction added in v0.17.0 

func (o WebhookOutput) TargetAction() pulumi.StringOutput

func (WebhookOutput) TargetPipeline added in v0.17.0 

func (o WebhookOutput) TargetPipeline() pulumi.StringOutput

func (WebhookOutput) TargetPipelineVersion added in v0.17.0 

func (o WebhookOutput) TargetPipelineVersion() pulumi.IntOutput

func (WebhookOutput) ToWebhookOutput 

func (o WebhookOutput) ToWebhookOutput() WebhookOutput

func (WebhookOutput) ToWebhookOutputWithContext 

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

func (WebhookOutput) Url added in v0.17.0 

func (o WebhookOutput) Url() pulumi.StringOutput

type WebhookState 

type WebhookState struct {
}

func (WebhookState) ElementType 

func (WebhookState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.