pulumiTypes.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package ecr

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

var _ = internal.GetEnvOrDefault

type RegistryScanningConfigurationRule struct {
	// One or more repository filter blocks, containing a `filter` (required string filtering repositories, see pattern regex [here](https://docs.aws.amazon.com/AmazonECR/latest/APIReference/API_ScanningRepositoryFilter.html)) and a `filterType` (required string, currently only `WILDCARD` is supported).
	RepositoryFilters []RegistryScanningConfigurationRuleRepositoryFilter `pulumi:"repositoryFilters"`
	// The frequency that scans are performed at for a private registry. Can be `SCAN_ON_PUSH`, `CONTINUOUS_SCAN`, or `MANUAL`.
	ScanFrequency string `pulumi:"scanFrequency"`
}

// RegistryScanningConfigurationRuleInput is an input type that accepts RegistryScanningConfigurationRuleArgs and RegistryScanningConfigurationRuleOutput values.
// You can construct a concrete instance of `RegistryScanningConfigurationRuleInput` via:
//
//	RegistryScanningConfigurationRuleArgs{...}
type RegistryScanningConfigurationRuleInput interface {
	pulumi.Input

	ToRegistryScanningConfigurationRuleOutput() RegistryScanningConfigurationRuleOutput
	ToRegistryScanningConfigurationRuleOutputWithContext(context.Context) RegistryScanningConfigurationRuleOutput
}

type RegistryScanningConfigurationRuleArgs struct {
	// One or more repository filter blocks, containing a `filter` (required string filtering repositories, see pattern regex [here](https://docs.aws.amazon.com/AmazonECR/latest/APIReference/API_ScanningRepositoryFilter.html)) and a `filterType` (required string, currently only `WILDCARD` is supported).
	RepositoryFilters RegistryScanningConfigurationRuleRepositoryFilterArrayInput `pulumi:"repositoryFilters"`
	// The frequency that scans are performed at for a private registry. Can be `SCAN_ON_PUSH`, `CONTINUOUS_SCAN`, or `MANUAL`.
	ScanFrequency pulumi.StringInput `pulumi:"scanFrequency"`
}

func (RegistryScanningConfigurationRuleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RegistryScanningConfigurationRule)(nil)).Elem()
}

func (i RegistryScanningConfigurationRuleArgs) ToRegistryScanningConfigurationRuleOutput() RegistryScanningConfigurationRuleOutput {
	return i.ToRegistryScanningConfigurationRuleOutputWithContext(context.Background())
}

func (i RegistryScanningConfigurationRuleArgs) ToRegistryScanningConfigurationRuleOutputWithContext(ctx context.Context) RegistryScanningConfigurationRuleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RegistryScanningConfigurationRuleOutput)
}

// RegistryScanningConfigurationRuleArrayInput is an input type that accepts RegistryScanningConfigurationRuleArray and RegistryScanningConfigurationRuleArrayOutput values.
// You can construct a concrete instance of `RegistryScanningConfigurationRuleArrayInput` via:
//
//	RegistryScanningConfigurationRuleArray{ RegistryScanningConfigurationRuleArgs{...} }
type RegistryScanningConfigurationRuleArrayInput interface {
	pulumi.Input

	ToRegistryScanningConfigurationRuleArrayOutput() RegistryScanningConfigurationRuleArrayOutput
	ToRegistryScanningConfigurationRuleArrayOutputWithContext(context.Context) RegistryScanningConfigurationRuleArrayOutput
}

type RegistryScanningConfigurationRuleArray []RegistryScanningConfigurationRuleInput

func (RegistryScanningConfigurationRuleArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]RegistryScanningConfigurationRule)(nil)).Elem()
}

func (i RegistryScanningConfigurationRuleArray) ToRegistryScanningConfigurationRuleArrayOutput() RegistryScanningConfigurationRuleArrayOutput {
	return i.ToRegistryScanningConfigurationRuleArrayOutputWithContext(context.Background())
}

func (i RegistryScanningConfigurationRuleArray) ToRegistryScanningConfigurationRuleArrayOutputWithContext(ctx context.Context) RegistryScanningConfigurationRuleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RegistryScanningConfigurationRuleArrayOutput)
}

type RegistryScanningConfigurationRuleOutput struct{ *pulumi.OutputState }

func (RegistryScanningConfigurationRuleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RegistryScanningConfigurationRule)(nil)).Elem()
}

func (o RegistryScanningConfigurationRuleOutput) ToRegistryScanningConfigurationRuleOutput() RegistryScanningConfigurationRuleOutput {
	return o
}

func (o RegistryScanningConfigurationRuleOutput) ToRegistryScanningConfigurationRuleOutputWithContext(ctx context.Context) RegistryScanningConfigurationRuleOutput {
	return o
}

// One or more repository filter blocks, containing a `filter` (required string filtering repositories, see pattern regex [here](https://docs.aws.amazon.com/AmazonECR/latest/APIReference/API_ScanningRepositoryFilter.html)) and a `filterType` (required string, currently only `WILDCARD` is supported).
func (o RegistryScanningConfigurationRuleOutput) RepositoryFilters() RegistryScanningConfigurationRuleRepositoryFilterArrayOutput {
	return o.ApplyT(func(v RegistryScanningConfigurationRule) []RegistryScanningConfigurationRuleRepositoryFilter {
		return v.RepositoryFilters
	}).(RegistryScanningConfigurationRuleRepositoryFilterArrayOutput)
}

// The frequency that scans are performed at for a private registry. Can be `SCAN_ON_PUSH`, `CONTINUOUS_SCAN`, or `MANUAL`.
func (o RegistryScanningConfigurationRuleOutput) ScanFrequency() pulumi.StringOutput {
	return o.ApplyT(func(v RegistryScanningConfigurationRule) string { return v.ScanFrequency }).(pulumi.StringOutput)
}

type RegistryScanningConfigurationRuleArrayOutput struct{ *pulumi.OutputState }

func (RegistryScanningConfigurationRuleArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]RegistryScanningConfigurationRule)(nil)).Elem()
}

func (o RegistryScanningConfigurationRuleArrayOutput) ToRegistryScanningConfigurationRuleArrayOutput() RegistryScanningConfigurationRuleArrayOutput {
	return o
}

func (o RegistryScanningConfigurationRuleArrayOutput) ToRegistryScanningConfigurationRuleArrayOutputWithContext(ctx context.Context) RegistryScanningConfigurationRuleArrayOutput {
	return o
}

func (o RegistryScanningConfigurationRuleArrayOutput) Index(i pulumi.IntInput) RegistryScanningConfigurationRuleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RegistryScanningConfigurationRule {
		return vs[0].([]RegistryScanningConfigurationRule)[vs[1].(int)]
	}).(RegistryScanningConfigurationRuleOutput)
}

type RegistryScanningConfigurationRuleRepositoryFilter struct {
	Filter     string `pulumi:"filter"`
	FilterType string `pulumi:"filterType"`
}

// RegistryScanningConfigurationRuleRepositoryFilterInput is an input type that accepts RegistryScanningConfigurationRuleRepositoryFilterArgs and RegistryScanningConfigurationRuleRepositoryFilterOutput values.
// You can construct a concrete instance of `RegistryScanningConfigurationRuleRepositoryFilterInput` via:
//
//	RegistryScanningConfigurationRuleRepositoryFilterArgs{...}
type RegistryScanningConfigurationRuleRepositoryFilterInput interface {
	pulumi.Input

	ToRegistryScanningConfigurationRuleRepositoryFilterOutput() RegistryScanningConfigurationRuleRepositoryFilterOutput
	ToRegistryScanningConfigurationRuleRepositoryFilterOutputWithContext(context.Context) RegistryScanningConfigurationRuleRepositoryFilterOutput
}

type RegistryScanningConfigurationRuleRepositoryFilterArgs struct {
	Filter     pulumi.StringInput `pulumi:"filter"`
	FilterType pulumi.StringInput `pulumi:"filterType"`
}

func (RegistryScanningConfigurationRuleRepositoryFilterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RegistryScanningConfigurationRuleRepositoryFilter)(nil)).Elem()
}

func (i RegistryScanningConfigurationRuleRepositoryFilterArgs) ToRegistryScanningConfigurationRuleRepositoryFilterOutput() RegistryScanningConfigurationRuleRepositoryFilterOutput {
	return i.ToRegistryScanningConfigurationRuleRepositoryFilterOutputWithContext(context.Background())
}

func (i RegistryScanningConfigurationRuleRepositoryFilterArgs) ToRegistryScanningConfigurationRuleRepositoryFilterOutputWithContext(ctx context.Context) RegistryScanningConfigurationRuleRepositoryFilterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RegistryScanningConfigurationRuleRepositoryFilterOutput)
}

// RegistryScanningConfigurationRuleRepositoryFilterArrayInput is an input type that accepts RegistryScanningConfigurationRuleRepositoryFilterArray and RegistryScanningConfigurationRuleRepositoryFilterArrayOutput values.
// You can construct a concrete instance of `RegistryScanningConfigurationRuleRepositoryFilterArrayInput` via:
//
//	RegistryScanningConfigurationRuleRepositoryFilterArray{ RegistryScanningConfigurationRuleRepositoryFilterArgs{...} }
type RegistryScanningConfigurationRuleRepositoryFilterArrayInput interface {
	pulumi.Input

	ToRegistryScanningConfigurationRuleRepositoryFilterArrayOutput() RegistryScanningConfigurationRuleRepositoryFilterArrayOutput
	ToRegistryScanningConfigurationRuleRepositoryFilterArrayOutputWithContext(context.Context) RegistryScanningConfigurationRuleRepositoryFilterArrayOutput
}

type RegistryScanningConfigurationRuleRepositoryFilterArray []RegistryScanningConfigurationRuleRepositoryFilterInput

func (RegistryScanningConfigurationRuleRepositoryFilterArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]RegistryScanningConfigurationRuleRepositoryFilter)(nil)).Elem()
}

func (i RegistryScanningConfigurationRuleRepositoryFilterArray) ToRegistryScanningConfigurationRuleRepositoryFilterArrayOutput() RegistryScanningConfigurationRuleRepositoryFilterArrayOutput {
	return i.ToRegistryScanningConfigurationRuleRepositoryFilterArrayOutputWithContext(context.Background())
}

func (i RegistryScanningConfigurationRuleRepositoryFilterArray) ToRegistryScanningConfigurationRuleRepositoryFilterArrayOutputWithContext(ctx context.Context) RegistryScanningConfigurationRuleRepositoryFilterArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RegistryScanningConfigurationRuleRepositoryFilterArrayOutput)
}

type RegistryScanningConfigurationRuleRepositoryFilterOutput struct{ *pulumi.OutputState }

func (RegistryScanningConfigurationRuleRepositoryFilterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RegistryScanningConfigurationRuleRepositoryFilter)(nil)).Elem()
}

func (o RegistryScanningConfigurationRuleRepositoryFilterOutput) ToRegistryScanningConfigurationRuleRepositoryFilterOutput() RegistryScanningConfigurationRuleRepositoryFilterOutput {
	return o
}

func (o RegistryScanningConfigurationRuleRepositoryFilterOutput) ToRegistryScanningConfigurationRuleRepositoryFilterOutputWithContext(ctx context.Context) RegistryScanningConfigurationRuleRepositoryFilterOutput {
	return o
}

func (o RegistryScanningConfigurationRuleRepositoryFilterOutput) Filter() pulumi.StringOutput {
	return o.ApplyT(func(v RegistryScanningConfigurationRuleRepositoryFilter) string { return v.Filter }).(pulumi.StringOutput)
}

func (o RegistryScanningConfigurationRuleRepositoryFilterOutput) FilterType() pulumi.StringOutput {
	return o.ApplyT(func(v RegistryScanningConfigurationRuleRepositoryFilter) string { return v.FilterType }).(pulumi.StringOutput)
}

type RegistryScanningConfigurationRuleRepositoryFilterArrayOutput struct{ *pulumi.OutputState }

func (RegistryScanningConfigurationRuleRepositoryFilterArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]RegistryScanningConfigurationRuleRepositoryFilter)(nil)).Elem()
}

func (o RegistryScanningConfigurationRuleRepositoryFilterArrayOutput) ToRegistryScanningConfigurationRuleRepositoryFilterArrayOutput() RegistryScanningConfigurationRuleRepositoryFilterArrayOutput {
	return o
}

func (o RegistryScanningConfigurationRuleRepositoryFilterArrayOutput) ToRegistryScanningConfigurationRuleRepositoryFilterArrayOutputWithContext(ctx context.Context) RegistryScanningConfigurationRuleRepositoryFilterArrayOutput {
	return o
}

func (o RegistryScanningConfigurationRuleRepositoryFilterArrayOutput) Index(i pulumi.IntInput) RegistryScanningConfigurationRuleRepositoryFilterOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RegistryScanningConfigurationRuleRepositoryFilter {
		return vs[0].([]RegistryScanningConfigurationRuleRepositoryFilter)[vs[1].(int)]
	}).(RegistryScanningConfigurationRuleRepositoryFilterOutput)
}

type ReplicationConfigurationReplicationConfiguration struct {
	// The replication rules for a replication configuration. A maximum of 10 are allowed per `replicationConfiguration`. See Rule
	Rules []ReplicationConfigurationReplicationConfigurationRule `pulumi:"rules"`
}

// ReplicationConfigurationReplicationConfigurationInput is an input type that accepts ReplicationConfigurationReplicationConfigurationArgs and ReplicationConfigurationReplicationConfigurationOutput values.
// You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationInput` via:
//
//	ReplicationConfigurationReplicationConfigurationArgs{...}
type ReplicationConfigurationReplicationConfigurationInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationOutput() ReplicationConfigurationReplicationConfigurationOutput
	ToReplicationConfigurationReplicationConfigurationOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationOutput
}

type ReplicationConfigurationReplicationConfigurationArgs struct {
	// The replication rules for a replication configuration. A maximum of 10 are allowed per `replicationConfiguration`. See Rule
	Rules ReplicationConfigurationReplicationConfigurationRuleArrayInput `pulumi:"rules"`
}

func (ReplicationConfigurationReplicationConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ReplicationConfigurationReplicationConfiguration)(nil)).Elem()
}

func (i ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationOutput() ReplicationConfigurationReplicationConfigurationOutput {
	return i.ToReplicationConfigurationReplicationConfigurationOutputWithContext(context.Background())
}

func (i ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReplicationConfigurationReplicationConfigurationOutput)
}

func (i ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationPtrOutput() ReplicationConfigurationReplicationConfigurationPtrOutput {
	return i.ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(context.Background())
}

func (i ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReplicationConfigurationReplicationConfigurationOutput).ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(ctx)
}

// ReplicationConfigurationReplicationConfigurationPtrInput is an input type that accepts ReplicationConfigurationReplicationConfigurationArgs, ReplicationConfigurationReplicationConfigurationPtr and ReplicationConfigurationReplicationConfigurationPtrOutput values.
// You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationPtrInput` via:
//
//	        ReplicationConfigurationReplicationConfigurationArgs{...}
//
//	or:
//
//	        nil
type ReplicationConfigurationReplicationConfigurationPtrInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationPtrOutput() ReplicationConfigurationReplicationConfigurationPtrOutput
	ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationPtrOutput
}

type replicationConfigurationReplicationConfigurationPtrType ReplicationConfigurationReplicationConfigurationArgs

func ReplicationConfigurationReplicationConfigurationPtr(v *ReplicationConfigurationReplicationConfigurationArgs) ReplicationConfigurationReplicationConfigurationPtrInput {
	return (*replicationConfigurationReplicationConfigurationPtrType)(v)
}

func (*replicationConfigurationReplicationConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ReplicationConfigurationReplicationConfiguration)(nil)).Elem()
}

func (i *replicationConfigurationReplicationConfigurationPtrType) ToReplicationConfigurationReplicationConfigurationPtrOutput() ReplicationConfigurationReplicationConfigurationPtrOutput {
	return i.ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(context.Background())
}

func (i *replicationConfigurationReplicationConfigurationPtrType) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReplicationConfigurationReplicationConfigurationPtrOutput)
}

type ReplicationConfigurationReplicationConfigurationOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ReplicationConfigurationReplicationConfiguration)(nil)).Elem()
}

func (o ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationOutput() ReplicationConfigurationReplicationConfigurationOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationPtrOutput() ReplicationConfigurationReplicationConfigurationPtrOutput {
	return o.ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(context.Background())
}

func (o ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ReplicationConfigurationReplicationConfiguration) *ReplicationConfigurationReplicationConfiguration {
		return &v
	}).(ReplicationConfigurationReplicationConfigurationPtrOutput)
}

// The replication rules for a replication configuration. A maximum of 10 are allowed per `replicationConfiguration`. See Rule
func (o ReplicationConfigurationReplicationConfigurationOutput) Rules() ReplicationConfigurationReplicationConfigurationRuleArrayOutput {
	return o.ApplyT(func(v ReplicationConfigurationReplicationConfiguration) []ReplicationConfigurationReplicationConfigurationRule {
		return v.Rules
	}).(ReplicationConfigurationReplicationConfigurationRuleArrayOutput)
}

type ReplicationConfigurationReplicationConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ReplicationConfigurationReplicationConfiguration)(nil)).Elem()
}

func (o ReplicationConfigurationReplicationConfigurationPtrOutput) ToReplicationConfigurationReplicationConfigurationPtrOutput() ReplicationConfigurationReplicationConfigurationPtrOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationPtrOutput) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationPtrOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationPtrOutput) Elem() ReplicationConfigurationReplicationConfigurationOutput {
	return o.ApplyT(func(v *ReplicationConfigurationReplicationConfiguration) ReplicationConfigurationReplicationConfiguration {
		if v != nil {
			return *v
		}
		var ret ReplicationConfigurationReplicationConfiguration
		return ret
	}).(ReplicationConfigurationReplicationConfigurationOutput)
}

// The replication rules for a replication configuration. A maximum of 10 are allowed per `replicationConfiguration`. See Rule
func (o ReplicationConfigurationReplicationConfigurationPtrOutput) Rules() ReplicationConfigurationReplicationConfigurationRuleArrayOutput {
	return o.ApplyT(func(v *ReplicationConfigurationReplicationConfiguration) []ReplicationConfigurationReplicationConfigurationRule {
		if v == nil {
			return nil
		}
		return v.Rules
	}).(ReplicationConfigurationReplicationConfigurationRuleArrayOutput)
}

type ReplicationConfigurationReplicationConfigurationRule struct {
	// the details of a replication destination. A maximum of 25 are allowed per `rule`. See Destination.
	Destinations []ReplicationConfigurationReplicationConfigurationRuleDestination `pulumi:"destinations"`
	// filters for a replication rule. See Repository Filter.
	RepositoryFilters []ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter `pulumi:"repositoryFilters"`
}

// ReplicationConfigurationReplicationConfigurationRuleInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleArgs and ReplicationConfigurationReplicationConfigurationRuleOutput values.
// You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRuleInput` via:
//
//	ReplicationConfigurationReplicationConfigurationRuleArgs{...}
type ReplicationConfigurationReplicationConfigurationRuleInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRuleOutput() ReplicationConfigurationReplicationConfigurationRuleOutput
	ToReplicationConfigurationReplicationConfigurationRuleOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRuleOutput
}

type ReplicationConfigurationReplicationConfigurationRuleArgs struct {
	// the details of a replication destination. A maximum of 25 are allowed per `rule`. See Destination.
	Destinations ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput `pulumi:"destinations"`
	// filters for a replication rule. See Repository Filter.
	RepositoryFilters ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayInput `pulumi:"repositoryFilters"`
}

func (ReplicationConfigurationReplicationConfigurationRuleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRule)(nil)).Elem()
}

func (i ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRuleOutput() ReplicationConfigurationReplicationConfigurationRuleOutput {
	return i.ToReplicationConfigurationReplicationConfigurationRuleOutputWithContext(context.Background())
}

func (i ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRuleOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReplicationConfigurationReplicationConfigurationRuleOutput)
}

// ReplicationConfigurationReplicationConfigurationRuleArrayInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleArray and ReplicationConfigurationReplicationConfigurationRuleArrayOutput values.
// You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRuleArrayInput` via:
//
//	ReplicationConfigurationReplicationConfigurationRuleArray{ ReplicationConfigurationReplicationConfigurationRuleArgs{...} }
type ReplicationConfigurationReplicationConfigurationRuleArrayInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRuleArrayOutput() ReplicationConfigurationReplicationConfigurationRuleArrayOutput
	ToReplicationConfigurationReplicationConfigurationRuleArrayOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRuleArrayOutput
}

type ReplicationConfigurationReplicationConfigurationRuleArray []ReplicationConfigurationReplicationConfigurationRuleInput

func (ReplicationConfigurationReplicationConfigurationRuleArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ReplicationConfigurationReplicationConfigurationRule)(nil)).Elem()
}

func (i ReplicationConfigurationReplicationConfigurationRuleArray) ToReplicationConfigurationReplicationConfigurationRuleArrayOutput() ReplicationConfigurationReplicationConfigurationRuleArrayOutput {
	return i.ToReplicationConfigurationReplicationConfigurationRuleArrayOutputWithContext(context.Background())
}

func (i ReplicationConfigurationReplicationConfigurationRuleArray) ToReplicationConfigurationReplicationConfigurationRuleArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReplicationConfigurationReplicationConfigurationRuleArrayOutput)
}

type ReplicationConfigurationReplicationConfigurationRuleOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRuleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRule)(nil)).Elem()
}

func (o ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRuleOutput() ReplicationConfigurationReplicationConfigurationRuleOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRuleOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleOutput {
	return o
}

// the details of a replication destination. A maximum of 25 are allowed per `rule`. See Destination.
func (o ReplicationConfigurationReplicationConfigurationRuleOutput) Destinations() ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput {
	return o.ApplyT(func(v ReplicationConfigurationReplicationConfigurationRule) []ReplicationConfigurationReplicationConfigurationRuleDestination {
		return v.Destinations
	}).(ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput)
}

// filters for a replication rule. See Repository Filter.
func (o ReplicationConfigurationReplicationConfigurationRuleOutput) RepositoryFilters() ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput {
	return o.ApplyT(func(v ReplicationConfigurationReplicationConfigurationRule) []ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter {
		return v.RepositoryFilters
	}).(ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput)
}

type ReplicationConfigurationReplicationConfigurationRuleArrayOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRuleArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ReplicationConfigurationReplicationConfigurationRule)(nil)).Elem()
}

func (o ReplicationConfigurationReplicationConfigurationRuleArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleArrayOutput() ReplicationConfigurationReplicationConfigurationRuleArrayOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationRuleArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleArrayOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationRuleArrayOutput) Index(i pulumi.IntInput) ReplicationConfigurationReplicationConfigurationRuleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicationConfigurationReplicationConfigurationRule {
		return vs[0].([]ReplicationConfigurationReplicationConfigurationRule)[vs[1].(int)]
	}).(ReplicationConfigurationReplicationConfigurationRuleOutput)
}

type ReplicationConfigurationReplicationConfigurationRuleDestination struct {
	// A Region to replicate to.
	Region string `pulumi:"region"`
	// The account ID of the destination registry to replicate to.
	RegistryId string `pulumi:"registryId"`
}

// ReplicationConfigurationReplicationConfigurationRuleDestinationInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleDestinationArgs and ReplicationConfigurationReplicationConfigurationRuleDestinationOutput values.
// You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRuleDestinationInput` via:
//
//	ReplicationConfigurationReplicationConfigurationRuleDestinationArgs{...}
type ReplicationConfigurationReplicationConfigurationRuleDestinationInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRuleDestinationOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationOutput
	ToReplicationConfigurationReplicationConfigurationRuleDestinationOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationOutput
}

type ReplicationConfigurationReplicationConfigurationRuleDestinationArgs struct {
	// A Region to replicate to.
	Region pulumi.StringInput `pulumi:"region"`
	// The account ID of the destination registry to replicate to.
	RegistryId pulumi.StringInput `pulumi:"registryId"`
}

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleDestination)(nil)).Elem()
}

func (i ReplicationConfigurationReplicationConfigurationRuleDestinationArgs) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationOutput {
	return i.ToReplicationConfigurationReplicationConfigurationRuleDestinationOutputWithContext(context.Background())
}

func (i ReplicationConfigurationReplicationConfigurationRuleDestinationArgs) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReplicationConfigurationReplicationConfigurationRuleDestinationOutput)
}

// ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleDestinationArray and ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput values.
// You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput` via:
//
//	ReplicationConfigurationReplicationConfigurationRuleDestinationArray{ ReplicationConfigurationReplicationConfigurationRuleDestinationArgs{...} }
type ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput
	ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput
}

type ReplicationConfigurationReplicationConfigurationRuleDestinationArray []ReplicationConfigurationReplicationConfigurationRuleDestinationInput

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ReplicationConfigurationReplicationConfigurationRuleDestination)(nil)).Elem()
}

func (i ReplicationConfigurationReplicationConfigurationRuleDestinationArray) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput {
	return i.ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutputWithContext(context.Background())
}

func (i ReplicationConfigurationReplicationConfigurationRuleDestinationArray) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput)
}

type ReplicationConfigurationReplicationConfigurationRuleDestinationOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleDestination)(nil)).Elem()
}

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationOutput {
	return o
}

// A Region to replicate to.
func (o ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) Region() pulumi.StringOutput {
	return o.ApplyT(func(v ReplicationConfigurationReplicationConfigurationRuleDestination) string { return v.Region }).(pulumi.StringOutput)
}

// The account ID of the destination registry to replicate to.
func (o ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) RegistryId() pulumi.StringOutput {
	return o.ApplyT(func(v ReplicationConfigurationReplicationConfigurationRuleDestination) string { return v.RegistryId }).(pulumi.StringOutput)
}

type ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ReplicationConfigurationReplicationConfigurationRuleDestination)(nil)).Elem()
}

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) Index(i pulumi.IntInput) ReplicationConfigurationReplicationConfigurationRuleDestinationOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicationConfigurationReplicationConfigurationRuleDestination {
		return vs[0].([]ReplicationConfigurationReplicationConfigurationRuleDestination)[vs[1].(int)]
	}).(ReplicationConfigurationReplicationConfigurationRuleDestinationOutput)
}

type ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter struct {
	// The repository filter details.
	Filter string `pulumi:"filter"`
	// The repository filter type. The only supported value is `PREFIX_MATCH`, which is a repository name prefix specified with the filter parameter.
	FilterType string `pulumi:"filterType"`
}

// ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArgs and ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput values.
// You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterInput` via:
//
//	ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArgs{...}
type ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput() ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput
	ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput
}

type ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArgs struct {
	// The repository filter details.
	Filter pulumi.StringInput `pulumi:"filter"`
	// The repository filter type. The only supported value is `PREFIX_MATCH`, which is a repository name prefix specified with the filter parameter.
	FilterType pulumi.StringInput `pulumi:"filterType"`
}

func (ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter)(nil)).Elem()
}

func (i ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArgs) ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput() ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput {
	return i.ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutputWithContext(context.Background())
}

func (i ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArgs) ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput)
}

// ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArray and ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput values.
// You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayInput` via:
//
//	ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArray{ ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArgs{...} }
type ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput() ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput
	ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput
}

type ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArray []ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterInput

func (ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter)(nil)).Elem()
}

func (i ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArray) ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput() ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput {
	return i.ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutputWithContext(context.Background())
}

func (i ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArray) ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput)
}

type ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter)(nil)).Elem()
}

func (o ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput) ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput() ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput) ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput {
	return o
}

// The repository filter details.
func (o ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput) Filter() pulumi.StringOutput {
	return o.ApplyT(func(v ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter) string { return v.Filter }).(pulumi.StringOutput)
}

// The repository filter type. The only supported value is `PREFIX_MATCH`, which is a repository name prefix specified with the filter parameter.
func (o ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput) FilterType() pulumi.StringOutput {
	return o.ApplyT(func(v ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter) string {
		return v.FilterType
	}).(pulumi.StringOutput)
}

type ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter)(nil)).Elem()
}

func (o ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput() ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput {
	return o
}

func (o ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput) Index(i pulumi.IntInput) ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter {
		return vs[0].([]ReplicationConfigurationReplicationConfigurationRuleRepositoryFilter)[vs[1].(int)]
	}).(ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput)
}

type RepositoryEncryptionConfiguration struct {
	// The encryption type to use for the repository. Valid values are `AES256` or `KMS`. Defaults to `AES256`.
	EncryptionType *string `pulumi:"encryptionType"`
	// The ARN of the KMS key to use when `encryptionType` is `KMS`. If not specified, uses the default AWS managed key for ECR.
	KmsKey *string `pulumi:"kmsKey"`
}

// RepositoryEncryptionConfigurationInput is an input type that accepts RepositoryEncryptionConfigurationArgs and RepositoryEncryptionConfigurationOutput values.
// You can construct a concrete instance of `RepositoryEncryptionConfigurationInput` via:
//
//	RepositoryEncryptionConfigurationArgs{...}
type RepositoryEncryptionConfigurationInput interface {
	pulumi.Input

	ToRepositoryEncryptionConfigurationOutput() RepositoryEncryptionConfigurationOutput
	ToRepositoryEncryptionConfigurationOutputWithContext(context.Context) RepositoryEncryptionConfigurationOutput
}

type RepositoryEncryptionConfigurationArgs struct {
	// The encryption type to use for the repository. Valid values are `AES256` or `KMS`. Defaults to `AES256`.
	EncryptionType pulumi.StringPtrInput `pulumi:"encryptionType"`
	// The ARN of the KMS key to use when `encryptionType` is `KMS`. If not specified, uses the default AWS managed key for ECR.
	KmsKey pulumi.StringPtrInput `pulumi:"kmsKey"`
}

func (RepositoryEncryptionConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RepositoryEncryptionConfiguration)(nil)).Elem()
}

func (i RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationOutput() RepositoryEncryptionConfigurationOutput {
	return i.ToRepositoryEncryptionConfigurationOutputWithContext(context.Background())
}

func (i RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepositoryEncryptionConfigurationOutput)
}

// RepositoryEncryptionConfigurationArrayInput is an input type that accepts RepositoryEncryptionConfigurationArray and RepositoryEncryptionConfigurationArrayOutput values.
// You can construct a concrete instance of `RepositoryEncryptionConfigurationArrayInput` via:
//
//	RepositoryEncryptionConfigurationArray{ RepositoryEncryptionConfigurationArgs{...} }
type RepositoryEncryptionConfigurationArrayInput interface {
	pulumi.Input

	ToRepositoryEncryptionConfigurationArrayOutput() RepositoryEncryptionConfigurationArrayOutput
	ToRepositoryEncryptionConfigurationArrayOutputWithContext(context.Context) RepositoryEncryptionConfigurationArrayOutput
}

type RepositoryEncryptionConfigurationArray []RepositoryEncryptionConfigurationInput

func (RepositoryEncryptionConfigurationArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]RepositoryEncryptionConfiguration)(nil)).Elem()
}

func (i RepositoryEncryptionConfigurationArray) ToRepositoryEncryptionConfigurationArrayOutput() RepositoryEncryptionConfigurationArrayOutput {
	return i.ToRepositoryEncryptionConfigurationArrayOutputWithContext(context.Background())
}

func (i RepositoryEncryptionConfigurationArray) ToRepositoryEncryptionConfigurationArrayOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepositoryEncryptionConfigurationArrayOutput)
}

type RepositoryEncryptionConfigurationOutput struct{ *pulumi.OutputState }

func (RepositoryEncryptionConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RepositoryEncryptionConfiguration)(nil)).Elem()
}

func (o RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationOutput() RepositoryEncryptionConfigurationOutput {
	return o
}

func (o RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationOutput {
	return o
}

// The encryption type to use for the repository. Valid values are `AES256` or `KMS`. Defaults to `AES256`.
func (o RepositoryEncryptionConfigurationOutput) EncryptionType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RepositoryEncryptionConfiguration) *string { return v.EncryptionType }).(pulumi.StringPtrOutput)
}

// The ARN of the KMS key to use when `encryptionType` is `KMS`. If not specified, uses the default AWS managed key for ECR.
func (o RepositoryEncryptionConfigurationOutput) KmsKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RepositoryEncryptionConfiguration) *string { return v.KmsKey }).(pulumi.StringPtrOutput)
}

type RepositoryEncryptionConfigurationArrayOutput struct{ *pulumi.OutputState }

func (RepositoryEncryptionConfigurationArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]RepositoryEncryptionConfiguration)(nil)).Elem()
}

func (o RepositoryEncryptionConfigurationArrayOutput) ToRepositoryEncryptionConfigurationArrayOutput() RepositoryEncryptionConfigurationArrayOutput {
	return o
}

func (o RepositoryEncryptionConfigurationArrayOutput) ToRepositoryEncryptionConfigurationArrayOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationArrayOutput {
	return o
}

func (o RepositoryEncryptionConfigurationArrayOutput) Index(i pulumi.IntInput) RepositoryEncryptionConfigurationOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RepositoryEncryptionConfiguration {
		return vs[0].([]RepositoryEncryptionConfiguration)[vs[1].(int)]
	}).(RepositoryEncryptionConfigurationOutput)
}

type RepositoryImageScanningConfiguration struct {
	// Indicates whether images are scanned after being pushed to the repository (true) or not scanned (false).
	ScanOnPush bool `pulumi:"scanOnPush"`
}

// RepositoryImageScanningConfigurationInput is an input type that accepts RepositoryImageScanningConfigurationArgs and RepositoryImageScanningConfigurationOutput values.
// You can construct a concrete instance of `RepositoryImageScanningConfigurationInput` via:
//
//	RepositoryImageScanningConfigurationArgs{...}
type RepositoryImageScanningConfigurationInput interface {
	pulumi.Input

	ToRepositoryImageScanningConfigurationOutput() RepositoryImageScanningConfigurationOutput
	ToRepositoryImageScanningConfigurationOutputWithContext(context.Context) RepositoryImageScanningConfigurationOutput
}

type RepositoryImageScanningConfigurationArgs struct {
	// Indicates whether images are scanned after being pushed to the repository (true) or not scanned (false).
	ScanOnPush pulumi.BoolInput `pulumi:"scanOnPush"`
}

func (RepositoryImageScanningConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RepositoryImageScanningConfiguration)(nil)).Elem()
}

func (i RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationOutput() RepositoryImageScanningConfigurationOutput {
	return i.ToRepositoryImageScanningConfigurationOutputWithContext(context.Background())
}

func (i RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepositoryImageScanningConfigurationOutput)
}

func (i RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput {
	return i.ToRepositoryImageScanningConfigurationPtrOutputWithContext(context.Background())
}

func (i RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationPtrOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepositoryImageScanningConfigurationOutput).ToRepositoryImageScanningConfigurationPtrOutputWithContext(ctx)
}

// RepositoryImageScanningConfigurationPtrInput is an input type that accepts RepositoryImageScanningConfigurationArgs, RepositoryImageScanningConfigurationPtr and RepositoryImageScanningConfigurationPtrOutput values.
// You can construct a concrete instance of `RepositoryImageScanningConfigurationPtrInput` via:
//
//	        RepositoryImageScanningConfigurationArgs{...}
//
//	or:
//
//	        nil
type RepositoryImageScanningConfigurationPtrInput interface {
	pulumi.Input

	ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput
	ToRepositoryImageScanningConfigurationPtrOutputWithContext(context.Context) RepositoryImageScanningConfigurationPtrOutput
}

type repositoryImageScanningConfigurationPtrType RepositoryImageScanningConfigurationArgs

func RepositoryImageScanningConfigurationPtr(v *RepositoryImageScanningConfigurationArgs) RepositoryImageScanningConfigurationPtrInput {
	return (*repositoryImageScanningConfigurationPtrType)(v)
}

func (*repositoryImageScanningConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**RepositoryImageScanningConfiguration)(nil)).Elem()
}

func (i *repositoryImageScanningConfigurationPtrType) ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput {
	return i.ToRepositoryImageScanningConfigurationPtrOutputWithContext(context.Background())
}

func (i *repositoryImageScanningConfigurationPtrType) ToRepositoryImageScanningConfigurationPtrOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepositoryImageScanningConfigurationPtrOutput)
}

type RepositoryImageScanningConfigurationOutput struct{ *pulumi.OutputState }

func (RepositoryImageScanningConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RepositoryImageScanningConfiguration)(nil)).Elem()
}

func (o RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationOutput() RepositoryImageScanningConfigurationOutput {
	return o
}

func (o RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationOutput {
	return o
}

func (o RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput {
	return o.ToRepositoryImageScanningConfigurationPtrOutputWithContext(context.Background())
}

func (o RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationPtrOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryImageScanningConfiguration) *RepositoryImageScanningConfiguration {
		return &v
	}).(RepositoryImageScanningConfigurationPtrOutput)
}

// Indicates whether images are scanned after being pushed to the repository (true) or not scanned (false).
func (o RepositoryImageScanningConfigurationOutput) ScanOnPush() pulumi.BoolOutput {
	return o.ApplyT(func(v RepositoryImageScanningConfiguration) bool { return v.ScanOnPush }).(pulumi.BoolOutput)
}

type RepositoryImageScanningConfigurationPtrOutput struct{ *pulumi.OutputState }

func (RepositoryImageScanningConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RepositoryImageScanningConfiguration)(nil)).Elem()
}

func (o RepositoryImageScanningConfigurationPtrOutput) ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput {
	return o
}

func (o RepositoryImageScanningConfigurationPtrOutput) ToRepositoryImageScanningConfigurationPtrOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationPtrOutput {
	return o
}

func (o RepositoryImageScanningConfigurationPtrOutput) Elem() RepositoryImageScanningConfigurationOutput {
	return o.ApplyT(func(v *RepositoryImageScanningConfiguration) RepositoryImageScanningConfiguration {
		if v != nil {
			return *v
		}
		var ret RepositoryImageScanningConfiguration
		return ret
	}).(RepositoryImageScanningConfigurationOutput)
}

// Indicates whether images are scanned after being pushed to the repository (true) or not scanned (false).
func (o RepositoryImageScanningConfigurationPtrOutput) ScanOnPush() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *RepositoryImageScanningConfiguration) *bool {
		if v == nil {
			return nil
		}
		return &v.ScanOnPush
	}).(pulumi.BoolPtrOutput)
}

type GetLifecyclePolicyDocumentRule struct {
	// Specifies the action type.
	Action *GetLifecyclePolicyDocumentRuleAction `pulumi:"action"`
	// Describes the purpose of a rule within a lifecycle policy.
	Description *string `pulumi:"description"`
	// Sets the order in which rules are evaluated, lowest to highest. When you add rules to a lifecycle policy, you must give them each a unique value for `priority`. Values do not need to be sequential across rules in a policy. A rule with a `tagStatus` value of any must have the highest value for `priority` and be evaluated last.
	Priority int `pulumi:"priority"`
	// Collects parameters describing the selection criteria for the ECR lifecycle policy:
	Selection *GetLifecyclePolicyDocumentRuleSelection `pulumi:"selection"`
}

// GetLifecyclePolicyDocumentRuleInput is an input type that accepts GetLifecyclePolicyDocumentRuleArgs and GetLifecyclePolicyDocumentRuleOutput values.
// You can construct a concrete instance of `GetLifecyclePolicyDocumentRuleInput` via:
//
//	GetLifecyclePolicyDocumentRuleArgs{...}
type GetLifecyclePolicyDocumentRuleInput interface {
	pulumi.Input

	ToGetLifecyclePolicyDocumentRuleOutput() GetLifecyclePolicyDocumentRuleOutput
	ToGetLifecyclePolicyDocumentRuleOutputWithContext(context.Context) GetLifecyclePolicyDocumentRuleOutput
}

type GetLifecyclePolicyDocumentRuleArgs struct {
	// Specifies the action type.
	Action GetLifecyclePolicyDocumentRuleActionPtrInput `pulumi:"action"`
	// Describes the purpose of a rule within a lifecycle policy.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Sets the order in which rules are evaluated, lowest to highest. When you add rules to a lifecycle policy, you must give them each a unique value for `priority`. Values do not need to be sequential across rules in a policy. A rule with a `tagStatus` value of any must have the highest value for `priority` and be evaluated last.
	Priority pulumi.IntInput `pulumi:"priority"`
	// Collects parameters describing the selection criteria for the ECR lifecycle policy:
	Selection GetLifecyclePolicyDocumentRuleSelectionPtrInput `pulumi:"selection"`
}

func (GetLifecyclePolicyDocumentRuleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetLifecyclePolicyDocumentRule)(nil)).Elem()
}

func (i GetLifecyclePolicyDocumentRuleArgs) ToGetLifecyclePolicyDocumentRuleOutput() GetLifecyclePolicyDocumentRuleOutput {
	return i.ToGetLifecyclePolicyDocumentRuleOutputWithContext(context.Background())
}

func (i GetLifecyclePolicyDocumentRuleArgs) ToGetLifecyclePolicyDocumentRuleOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetLifecyclePolicyDocumentRuleOutput)
}

// GetLifecyclePolicyDocumentRuleArrayInput is an input type that accepts GetLifecyclePolicyDocumentRuleArray and GetLifecyclePolicyDocumentRuleArrayOutput values.
// You can construct a concrete instance of `GetLifecyclePolicyDocumentRuleArrayInput` via:
//
//	GetLifecyclePolicyDocumentRuleArray{ GetLifecyclePolicyDocumentRuleArgs{...} }
type GetLifecyclePolicyDocumentRuleArrayInput interface {
	pulumi.Input

	ToGetLifecyclePolicyDocumentRuleArrayOutput() GetLifecyclePolicyDocumentRuleArrayOutput
	ToGetLifecyclePolicyDocumentRuleArrayOutputWithContext(context.Context) GetLifecyclePolicyDocumentRuleArrayOutput
}

type GetLifecyclePolicyDocumentRuleArray []GetLifecyclePolicyDocumentRuleInput

func (GetLifecyclePolicyDocumentRuleArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetLifecyclePolicyDocumentRule)(nil)).Elem()
}

func (i GetLifecyclePolicyDocumentRuleArray) ToGetLifecyclePolicyDocumentRuleArrayOutput() GetLifecyclePolicyDocumentRuleArrayOutput {
	return i.ToGetLifecyclePolicyDocumentRuleArrayOutputWithContext(context.Background())
}

func (i GetLifecyclePolicyDocumentRuleArray) ToGetLifecyclePolicyDocumentRuleArrayOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetLifecyclePolicyDocumentRuleArrayOutput)
}

type GetLifecyclePolicyDocumentRuleOutput struct{ *pulumi.OutputState }

func (GetLifecyclePolicyDocumentRuleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetLifecyclePolicyDocumentRule)(nil)).Elem()
}

func (o GetLifecyclePolicyDocumentRuleOutput) ToGetLifecyclePolicyDocumentRuleOutput() GetLifecyclePolicyDocumentRuleOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleOutput) ToGetLifecyclePolicyDocumentRuleOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleOutput {
	return o
}

// Specifies the action type.
func (o GetLifecyclePolicyDocumentRuleOutput) Action() GetLifecyclePolicyDocumentRuleActionPtrOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRule) *GetLifecyclePolicyDocumentRuleAction { return v.Action }).(GetLifecyclePolicyDocumentRuleActionPtrOutput)
}

// Describes the purpose of a rule within a lifecycle policy.
func (o GetLifecyclePolicyDocumentRuleOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRule) *string { return v.Description }).(pulumi.StringPtrOutput)
}

// Sets the order in which rules are evaluated, lowest to highest. When you add rules to a lifecycle policy, you must give them each a unique value for `priority`. Values do not need to be sequential across rules in a policy. A rule with a `tagStatus` value of any must have the highest value for `priority` and be evaluated last.
func (o GetLifecyclePolicyDocumentRuleOutput) Priority() pulumi.IntOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRule) int { return v.Priority }).(pulumi.IntOutput)
}

// Collects parameters describing the selection criteria for the ECR lifecycle policy:
func (o GetLifecyclePolicyDocumentRuleOutput) Selection() GetLifecyclePolicyDocumentRuleSelectionPtrOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRule) *GetLifecyclePolicyDocumentRuleSelection { return v.Selection }).(GetLifecyclePolicyDocumentRuleSelectionPtrOutput)
}

type GetLifecyclePolicyDocumentRuleArrayOutput struct{ *pulumi.OutputState }

func (GetLifecyclePolicyDocumentRuleArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetLifecyclePolicyDocumentRule)(nil)).Elem()
}

func (o GetLifecyclePolicyDocumentRuleArrayOutput) ToGetLifecyclePolicyDocumentRuleArrayOutput() GetLifecyclePolicyDocumentRuleArrayOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleArrayOutput) ToGetLifecyclePolicyDocumentRuleArrayOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleArrayOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleArrayOutput) Index(i pulumi.IntInput) GetLifecyclePolicyDocumentRuleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetLifecyclePolicyDocumentRule {
		return vs[0].([]GetLifecyclePolicyDocumentRule)[vs[1].(int)]
	}).(GetLifecyclePolicyDocumentRuleOutput)
}

type GetLifecyclePolicyDocumentRuleAction struct {
	// The supported value is `expire`.
	Type string `pulumi:"type"`
}

// GetLifecyclePolicyDocumentRuleActionInput is an input type that accepts GetLifecyclePolicyDocumentRuleActionArgs and GetLifecyclePolicyDocumentRuleActionOutput values.
// You can construct a concrete instance of `GetLifecyclePolicyDocumentRuleActionInput` via:
//
//	GetLifecyclePolicyDocumentRuleActionArgs{...}
type GetLifecyclePolicyDocumentRuleActionInput interface {
	pulumi.Input

	ToGetLifecyclePolicyDocumentRuleActionOutput() GetLifecyclePolicyDocumentRuleActionOutput
	ToGetLifecyclePolicyDocumentRuleActionOutputWithContext(context.Context) GetLifecyclePolicyDocumentRuleActionOutput
}

type GetLifecyclePolicyDocumentRuleActionArgs struct {
	// The supported value is `expire`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (GetLifecyclePolicyDocumentRuleActionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetLifecyclePolicyDocumentRuleAction)(nil)).Elem()
}

func (i GetLifecyclePolicyDocumentRuleActionArgs) ToGetLifecyclePolicyDocumentRuleActionOutput() GetLifecyclePolicyDocumentRuleActionOutput {
	return i.ToGetLifecyclePolicyDocumentRuleActionOutputWithContext(context.Background())
}

func (i GetLifecyclePolicyDocumentRuleActionArgs) ToGetLifecyclePolicyDocumentRuleActionOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleActionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetLifecyclePolicyDocumentRuleActionOutput)
}

func (i GetLifecyclePolicyDocumentRuleActionArgs) ToGetLifecyclePolicyDocumentRuleActionPtrOutput() GetLifecyclePolicyDocumentRuleActionPtrOutput {
	return i.ToGetLifecyclePolicyDocumentRuleActionPtrOutputWithContext(context.Background())
}

func (i GetLifecyclePolicyDocumentRuleActionArgs) ToGetLifecyclePolicyDocumentRuleActionPtrOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleActionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetLifecyclePolicyDocumentRuleActionOutput).ToGetLifecyclePolicyDocumentRuleActionPtrOutputWithContext(ctx)
}

// GetLifecyclePolicyDocumentRuleActionPtrInput is an input type that accepts GetLifecyclePolicyDocumentRuleActionArgs, GetLifecyclePolicyDocumentRuleActionPtr and GetLifecyclePolicyDocumentRuleActionPtrOutput values.
// You can construct a concrete instance of `GetLifecyclePolicyDocumentRuleActionPtrInput` via:
//
//	        GetLifecyclePolicyDocumentRuleActionArgs{...}
//
//	or:
//
//	        nil
type GetLifecyclePolicyDocumentRuleActionPtrInput interface {
	pulumi.Input

	ToGetLifecyclePolicyDocumentRuleActionPtrOutput() GetLifecyclePolicyDocumentRuleActionPtrOutput
	ToGetLifecyclePolicyDocumentRuleActionPtrOutputWithContext(context.Context) GetLifecyclePolicyDocumentRuleActionPtrOutput
}

type getLifecyclePolicyDocumentRuleActionPtrType GetLifecyclePolicyDocumentRuleActionArgs

func GetLifecyclePolicyDocumentRuleActionPtr(v *GetLifecyclePolicyDocumentRuleActionArgs) GetLifecyclePolicyDocumentRuleActionPtrInput {
	return (*getLifecyclePolicyDocumentRuleActionPtrType)(v)
}

func (*getLifecyclePolicyDocumentRuleActionPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GetLifecyclePolicyDocumentRuleAction)(nil)).Elem()
}

func (i *getLifecyclePolicyDocumentRuleActionPtrType) ToGetLifecyclePolicyDocumentRuleActionPtrOutput() GetLifecyclePolicyDocumentRuleActionPtrOutput {
	return i.ToGetLifecyclePolicyDocumentRuleActionPtrOutputWithContext(context.Background())
}

func (i *getLifecyclePolicyDocumentRuleActionPtrType) ToGetLifecyclePolicyDocumentRuleActionPtrOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleActionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetLifecyclePolicyDocumentRuleActionPtrOutput)
}

type GetLifecyclePolicyDocumentRuleActionOutput struct{ *pulumi.OutputState }

func (GetLifecyclePolicyDocumentRuleActionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetLifecyclePolicyDocumentRuleAction)(nil)).Elem()
}

func (o GetLifecyclePolicyDocumentRuleActionOutput) ToGetLifecyclePolicyDocumentRuleActionOutput() GetLifecyclePolicyDocumentRuleActionOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleActionOutput) ToGetLifecyclePolicyDocumentRuleActionOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleActionOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleActionOutput) ToGetLifecyclePolicyDocumentRuleActionPtrOutput() GetLifecyclePolicyDocumentRuleActionPtrOutput {
	return o.ToGetLifecyclePolicyDocumentRuleActionPtrOutputWithContext(context.Background())
}

func (o GetLifecyclePolicyDocumentRuleActionOutput) ToGetLifecyclePolicyDocumentRuleActionPtrOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleActionPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GetLifecyclePolicyDocumentRuleAction) *GetLifecyclePolicyDocumentRuleAction {
		return &v
	}).(GetLifecyclePolicyDocumentRuleActionPtrOutput)
}

// The supported value is `expire`.
func (o GetLifecyclePolicyDocumentRuleActionOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRuleAction) string { return v.Type }).(pulumi.StringOutput)
}

type GetLifecyclePolicyDocumentRuleActionPtrOutput struct{ *pulumi.OutputState }

func (GetLifecyclePolicyDocumentRuleActionPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GetLifecyclePolicyDocumentRuleAction)(nil)).Elem()
}

func (o GetLifecyclePolicyDocumentRuleActionPtrOutput) ToGetLifecyclePolicyDocumentRuleActionPtrOutput() GetLifecyclePolicyDocumentRuleActionPtrOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleActionPtrOutput) ToGetLifecyclePolicyDocumentRuleActionPtrOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleActionPtrOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleActionPtrOutput) Elem() GetLifecyclePolicyDocumentRuleActionOutput {
	return o.ApplyT(func(v *GetLifecyclePolicyDocumentRuleAction) GetLifecyclePolicyDocumentRuleAction {
		if v != nil {
			return *v
		}
		var ret GetLifecyclePolicyDocumentRuleAction
		return ret
	}).(GetLifecyclePolicyDocumentRuleActionOutput)
}

// The supported value is `expire`.
func (o GetLifecyclePolicyDocumentRuleActionPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetLifecyclePolicyDocumentRuleAction) *string {
		if v == nil {
			return nil
		}
		return &v.Type
	}).(pulumi.StringPtrOutput)
}

type GetLifecyclePolicyDocumentRuleSelection struct {
	// Specify a count number. If the `countType` used is imageCountMoreThan, then the value is the maximum number of images that you want to retain in your repository. If the `countType` used is sinceImagePushed, then the value is the maximum age limit for your images.
	CountNumber int `pulumi:"countNumber"`
	// Specify a count type to apply to the images. If `countType` is set to imageCountMoreThan, you also specify `countNumber` to create a rule that sets a limit on the number of images that exist in your repository. If `countType` is set to sinceImagePushed, you also specify `countUnit` and `countNumber` to specify a time limit on the images that exist in your repository.
	CountType string `pulumi:"countType"`
	// Specify a count unit of days to indicate that as the unit of time, in addition to `countNumber`, which is the number of days.
	CountUnit       *string  `pulumi:"countUnit"`
	TagPatternLists []string `pulumi:"tagPatternLists"`
	// You must specify a comma-separated list of image tag prefixes on which to take action with your lifecycle policy. For example, if your images are tagged as prod, prod1, prod2, and so on, you would use the tag prefix prod to specify all of them. If you specify multiple tags, only images with all specified tags are selected.
	TagPrefixLists []string `pulumi:"tagPrefixLists"`
	// Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are tagged, untagged, or any. If you specify any, then all images have the rule applied to them. If you specify tagged, then you must also specify a `tagPrefixList` value. If you specify untagged, then you must omit `tagPrefixList`.
	TagStatus string `pulumi:"tagStatus"`
}

// GetLifecyclePolicyDocumentRuleSelectionInput is an input type that accepts GetLifecyclePolicyDocumentRuleSelectionArgs and GetLifecyclePolicyDocumentRuleSelectionOutput values.
// You can construct a concrete instance of `GetLifecyclePolicyDocumentRuleSelectionInput` via:
//
//	GetLifecyclePolicyDocumentRuleSelectionArgs{...}
type GetLifecyclePolicyDocumentRuleSelectionInput interface {
	pulumi.Input

	ToGetLifecyclePolicyDocumentRuleSelectionOutput() GetLifecyclePolicyDocumentRuleSelectionOutput
	ToGetLifecyclePolicyDocumentRuleSelectionOutputWithContext(context.Context) GetLifecyclePolicyDocumentRuleSelectionOutput
}

type GetLifecyclePolicyDocumentRuleSelectionArgs struct {
	// Specify a count number. If the `countType` used is imageCountMoreThan, then the value is the maximum number of images that you want to retain in your repository. If the `countType` used is sinceImagePushed, then the value is the maximum age limit for your images.
	CountNumber pulumi.IntInput `pulumi:"countNumber"`
	// Specify a count type to apply to the images. If `countType` is set to imageCountMoreThan, you also specify `countNumber` to create a rule that sets a limit on the number of images that exist in your repository. If `countType` is set to sinceImagePushed, you also specify `countUnit` and `countNumber` to specify a time limit on the images that exist in your repository.
	CountType pulumi.StringInput `pulumi:"countType"`
	// Specify a count unit of days to indicate that as the unit of time, in addition to `countNumber`, which is the number of days.
	CountUnit       pulumi.StringPtrInput   `pulumi:"countUnit"`
	TagPatternLists pulumi.StringArrayInput `pulumi:"tagPatternLists"`
	// You must specify a comma-separated list of image tag prefixes on which to take action with your lifecycle policy. For example, if your images are tagged as prod, prod1, prod2, and so on, you would use the tag prefix prod to specify all of them. If you specify multiple tags, only images with all specified tags are selected.
	TagPrefixLists pulumi.StringArrayInput `pulumi:"tagPrefixLists"`
	// Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are tagged, untagged, or any. If you specify any, then all images have the rule applied to them. If you specify tagged, then you must also specify a `tagPrefixList` value. If you specify untagged, then you must omit `tagPrefixList`.
	TagStatus pulumi.StringInput `pulumi:"tagStatus"`
}

func (GetLifecyclePolicyDocumentRuleSelectionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetLifecyclePolicyDocumentRuleSelection)(nil)).Elem()
}

func (i GetLifecyclePolicyDocumentRuleSelectionArgs) ToGetLifecyclePolicyDocumentRuleSelectionOutput() GetLifecyclePolicyDocumentRuleSelectionOutput {
	return i.ToGetLifecyclePolicyDocumentRuleSelectionOutputWithContext(context.Background())
}

func (i GetLifecyclePolicyDocumentRuleSelectionArgs) ToGetLifecyclePolicyDocumentRuleSelectionOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleSelectionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetLifecyclePolicyDocumentRuleSelectionOutput)
}

func (i GetLifecyclePolicyDocumentRuleSelectionArgs) ToGetLifecyclePolicyDocumentRuleSelectionPtrOutput() GetLifecyclePolicyDocumentRuleSelectionPtrOutput {
	return i.ToGetLifecyclePolicyDocumentRuleSelectionPtrOutputWithContext(context.Background())
}

func (i GetLifecyclePolicyDocumentRuleSelectionArgs) ToGetLifecyclePolicyDocumentRuleSelectionPtrOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleSelectionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetLifecyclePolicyDocumentRuleSelectionOutput).ToGetLifecyclePolicyDocumentRuleSelectionPtrOutputWithContext(ctx)
}

// GetLifecyclePolicyDocumentRuleSelectionPtrInput is an input type that accepts GetLifecyclePolicyDocumentRuleSelectionArgs, GetLifecyclePolicyDocumentRuleSelectionPtr and GetLifecyclePolicyDocumentRuleSelectionPtrOutput values.
// You can construct a concrete instance of `GetLifecyclePolicyDocumentRuleSelectionPtrInput` via:
//
//	        GetLifecyclePolicyDocumentRuleSelectionArgs{...}
//
//	or:
//
//	        nil
type GetLifecyclePolicyDocumentRuleSelectionPtrInput interface {
	pulumi.Input

	ToGetLifecyclePolicyDocumentRuleSelectionPtrOutput() GetLifecyclePolicyDocumentRuleSelectionPtrOutput
	ToGetLifecyclePolicyDocumentRuleSelectionPtrOutputWithContext(context.Context) GetLifecyclePolicyDocumentRuleSelectionPtrOutput
}

type getLifecyclePolicyDocumentRuleSelectionPtrType GetLifecyclePolicyDocumentRuleSelectionArgs

func GetLifecyclePolicyDocumentRuleSelectionPtr(v *GetLifecyclePolicyDocumentRuleSelectionArgs) GetLifecyclePolicyDocumentRuleSelectionPtrInput {
	return (*getLifecyclePolicyDocumentRuleSelectionPtrType)(v)
}

func (*getLifecyclePolicyDocumentRuleSelectionPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GetLifecyclePolicyDocumentRuleSelection)(nil)).Elem()
}

func (i *getLifecyclePolicyDocumentRuleSelectionPtrType) ToGetLifecyclePolicyDocumentRuleSelectionPtrOutput() GetLifecyclePolicyDocumentRuleSelectionPtrOutput {
	return i.ToGetLifecyclePolicyDocumentRuleSelectionPtrOutputWithContext(context.Background())
}

func (i *getLifecyclePolicyDocumentRuleSelectionPtrType) ToGetLifecyclePolicyDocumentRuleSelectionPtrOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleSelectionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetLifecyclePolicyDocumentRuleSelectionPtrOutput)
}

type GetLifecyclePolicyDocumentRuleSelectionOutput struct{ *pulumi.OutputState }

func (GetLifecyclePolicyDocumentRuleSelectionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetLifecyclePolicyDocumentRuleSelection)(nil)).Elem()
}

func (o GetLifecyclePolicyDocumentRuleSelectionOutput) ToGetLifecyclePolicyDocumentRuleSelectionOutput() GetLifecyclePolicyDocumentRuleSelectionOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleSelectionOutput) ToGetLifecyclePolicyDocumentRuleSelectionOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleSelectionOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleSelectionOutput) ToGetLifecyclePolicyDocumentRuleSelectionPtrOutput() GetLifecyclePolicyDocumentRuleSelectionPtrOutput {
	return o.ToGetLifecyclePolicyDocumentRuleSelectionPtrOutputWithContext(context.Background())
}

func (o GetLifecyclePolicyDocumentRuleSelectionOutput) ToGetLifecyclePolicyDocumentRuleSelectionPtrOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleSelectionPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GetLifecyclePolicyDocumentRuleSelection) *GetLifecyclePolicyDocumentRuleSelection {
		return &v
	}).(GetLifecyclePolicyDocumentRuleSelectionPtrOutput)
}

// Specify a count number. If the `countType` used is imageCountMoreThan, then the value is the maximum number of images that you want to retain in your repository. If the `countType` used is sinceImagePushed, then the value is the maximum age limit for your images.
func (o GetLifecyclePolicyDocumentRuleSelectionOutput) CountNumber() pulumi.IntOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRuleSelection) int { return v.CountNumber }).(pulumi.IntOutput)
}

// Specify a count type to apply to the images. If `countType` is set to imageCountMoreThan, you also specify `countNumber` to create a rule that sets a limit on the number of images that exist in your repository. If `countType` is set to sinceImagePushed, you also specify `countUnit` and `countNumber` to specify a time limit on the images that exist in your repository.
func (o GetLifecyclePolicyDocumentRuleSelectionOutput) CountType() pulumi.StringOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRuleSelection) string { return v.CountType }).(pulumi.StringOutput)
}

// Specify a count unit of days to indicate that as the unit of time, in addition to `countNumber`, which is the number of days.
func (o GetLifecyclePolicyDocumentRuleSelectionOutput) CountUnit() pulumi.StringPtrOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRuleSelection) *string { return v.CountUnit }).(pulumi.StringPtrOutput)
}

func (o GetLifecyclePolicyDocumentRuleSelectionOutput) TagPatternLists() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRuleSelection) []string { return v.TagPatternLists }).(pulumi.StringArrayOutput)
}

// You must specify a comma-separated list of image tag prefixes on which to take action with your lifecycle policy. For example, if your images are tagged as prod, prod1, prod2, and so on, you would use the tag prefix prod to specify all of them. If you specify multiple tags, only images with all specified tags are selected.
func (o GetLifecyclePolicyDocumentRuleSelectionOutput) TagPrefixLists() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRuleSelection) []string { return v.TagPrefixLists }).(pulumi.StringArrayOutput)
}

// Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are tagged, untagged, or any. If you specify any, then all images have the rule applied to them. If you specify tagged, then you must also specify a `tagPrefixList` value. If you specify untagged, then you must omit `tagPrefixList`.
func (o GetLifecyclePolicyDocumentRuleSelectionOutput) TagStatus() pulumi.StringOutput {
	return o.ApplyT(func(v GetLifecyclePolicyDocumentRuleSelection) string { return v.TagStatus }).(pulumi.StringOutput)
}

type GetLifecyclePolicyDocumentRuleSelectionPtrOutput struct{ *pulumi.OutputState }

func (GetLifecyclePolicyDocumentRuleSelectionPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GetLifecyclePolicyDocumentRuleSelection)(nil)).Elem()
}

func (o GetLifecyclePolicyDocumentRuleSelectionPtrOutput) ToGetLifecyclePolicyDocumentRuleSelectionPtrOutput() GetLifecyclePolicyDocumentRuleSelectionPtrOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleSelectionPtrOutput) ToGetLifecyclePolicyDocumentRuleSelectionPtrOutputWithContext(ctx context.Context) GetLifecyclePolicyDocumentRuleSelectionPtrOutput {
	return o
}

func (o GetLifecyclePolicyDocumentRuleSelectionPtrOutput) Elem() GetLifecyclePolicyDocumentRuleSelectionOutput {
	return o.ApplyT(func(v *GetLifecyclePolicyDocumentRuleSelection) GetLifecyclePolicyDocumentRuleSelection {
		if v != nil {
			return *v
		}
		var ret GetLifecyclePolicyDocumentRuleSelection
		return ret
	}).(GetLifecyclePolicyDocumentRuleSelectionOutput)
}

// Specify a count number. If the `countType` used is imageCountMoreThan, then the value is the maximum number of images that you want to retain in your repository. If the `countType` used is sinceImagePushed, then the value is the maximum age limit for your images.
func (o GetLifecyclePolicyDocumentRuleSelectionPtrOutput) CountNumber() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *GetLifecyclePolicyDocumentRuleSelection) *int {
		if v == nil {
			return nil
		}
		return &v.CountNumber
	}).(pulumi.IntPtrOutput)
}

// Specify a count type to apply to the images. If `countType` is set to imageCountMoreThan, you also specify `countNumber` to create a rule that sets a limit on the number of images that exist in your repository. If `countType` is set to sinceImagePushed, you also specify `countUnit` and `countNumber` to specify a time limit on the images that exist in your repository.
func (o GetLifecyclePolicyDocumentRuleSelectionPtrOutput) CountType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetLifecyclePolicyDocumentRuleSelection) *string {
		if v == nil {
			return nil
		}
		return &v.CountType
	}).(pulumi.StringPtrOutput)
}

// Specify a count unit of days to indicate that as the unit of time, in addition to `countNumber`, which is the number of days.
func (o GetLifecyclePolicyDocumentRuleSelectionPtrOutput) CountUnit() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetLifecyclePolicyDocumentRuleSelection) *string {
		if v == nil {
			return nil
		}
		return v.CountUnit
	}).(pulumi.StringPtrOutput)
}

func (o GetLifecyclePolicyDocumentRuleSelectionPtrOutput) TagPatternLists() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *GetLifecyclePolicyDocumentRuleSelection) []string {
		if v == nil {
			return nil
		}
		return v.TagPatternLists
	}).(pulumi.StringArrayOutput)
}

// You must specify a comma-separated list of image tag prefixes on which to take action with your lifecycle policy. For example, if your images are tagged as prod, prod1, prod2, and so on, you would use the tag prefix prod to specify all of them. If you specify multiple tags, only images with all specified tags are selected.
func (o GetLifecyclePolicyDocumentRuleSelectionPtrOutput) TagPrefixLists() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *GetLifecyclePolicyDocumentRuleSelection) []string {
		if v == nil {
			return nil
		}
		return v.TagPrefixLists
	}).(pulumi.StringArrayOutput)
}

// Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are tagged, untagged, or any. If you specify any, then all images have the rule applied to them. If you specify tagged, then you must also specify a `tagPrefixList` value. If you specify untagged, then you must omit `tagPrefixList`.
func (o GetLifecyclePolicyDocumentRuleSelectionPtrOutput) TagStatus() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetLifecyclePolicyDocumentRuleSelection) *string {
		if v == nil {
			return nil
		}
		return &v.TagStatus
	}).(pulumi.StringPtrOutput)
}

type GetRepositoryEncryptionConfiguration struct {
	// Encryption type to use for the repository, either `AES256` or `KMS`.
	EncryptionType string `pulumi:"encryptionType"`
	// If `encryptionType` is `KMS`, the ARN of the KMS key used.
	KmsKey string `pulumi:"kmsKey"`
}

// GetRepositoryEncryptionConfigurationInput is an input type that accepts GetRepositoryEncryptionConfigurationArgs and GetRepositoryEncryptionConfigurationOutput values.
// You can construct a concrete instance of `GetRepositoryEncryptionConfigurationInput` via:
//
//	GetRepositoryEncryptionConfigurationArgs{...}
type GetRepositoryEncryptionConfigurationInput interface {
	pulumi.Input

	ToGetRepositoryEncryptionConfigurationOutput() GetRepositoryEncryptionConfigurationOutput
	ToGetRepositoryEncryptionConfigurationOutputWithContext(context.Context) GetRepositoryEncryptionConfigurationOutput
}

type GetRepositoryEncryptionConfigurationArgs struct {
	// Encryption type to use for the repository, either `AES256` or `KMS`.
	EncryptionType pulumi.StringInput `pulumi:"encryptionType"`
	// If `encryptionType` is `KMS`, the ARN of the KMS key used.
	KmsKey pulumi.StringInput `pulumi:"kmsKey"`
}

func (GetRepositoryEncryptionConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetRepositoryEncryptionConfiguration)(nil)).Elem()
}

func (i GetRepositoryEncryptionConfigurationArgs) ToGetRepositoryEncryptionConfigurationOutput() GetRepositoryEncryptionConfigurationOutput {
	return i.ToGetRepositoryEncryptionConfigurationOutputWithContext(context.Background())
}

func (i GetRepositoryEncryptionConfigurationArgs) ToGetRepositoryEncryptionConfigurationOutputWithContext(ctx context.Context) GetRepositoryEncryptionConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryEncryptionConfigurationOutput)
}

// GetRepositoryEncryptionConfigurationArrayInput is an input type that accepts GetRepositoryEncryptionConfigurationArray and GetRepositoryEncryptionConfigurationArrayOutput values.
// You can construct a concrete instance of `GetRepositoryEncryptionConfigurationArrayInput` via:
//
//	GetRepositoryEncryptionConfigurationArray{ GetRepositoryEncryptionConfigurationArgs{...} }
type GetRepositoryEncryptionConfigurationArrayInput interface {
	pulumi.Input

	ToGetRepositoryEncryptionConfigurationArrayOutput() GetRepositoryEncryptionConfigurationArrayOutput
	ToGetRepositoryEncryptionConfigurationArrayOutputWithContext(context.Context) GetRepositoryEncryptionConfigurationArrayOutput
}

type GetRepositoryEncryptionConfigurationArray []GetRepositoryEncryptionConfigurationInput

func (GetRepositoryEncryptionConfigurationArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetRepositoryEncryptionConfiguration)(nil)).Elem()
}

func (i GetRepositoryEncryptionConfigurationArray) ToGetRepositoryEncryptionConfigurationArrayOutput() GetRepositoryEncryptionConfigurationArrayOutput {
	return i.ToGetRepositoryEncryptionConfigurationArrayOutputWithContext(context.Background())
}

func (i GetRepositoryEncryptionConfigurationArray) ToGetRepositoryEncryptionConfigurationArrayOutputWithContext(ctx context.Context) GetRepositoryEncryptionConfigurationArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryEncryptionConfigurationArrayOutput)
}

type GetRepositoryEncryptionConfigurationOutput struct{ *pulumi.OutputState }

func (GetRepositoryEncryptionConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetRepositoryEncryptionConfiguration)(nil)).Elem()
}

func (o GetRepositoryEncryptionConfigurationOutput) ToGetRepositoryEncryptionConfigurationOutput() GetRepositoryEncryptionConfigurationOutput {
	return o
}

func (o GetRepositoryEncryptionConfigurationOutput) ToGetRepositoryEncryptionConfigurationOutputWithContext(ctx context.Context) GetRepositoryEncryptionConfigurationOutput {
	return o
}

// Encryption type to use for the repository, either `AES256` or `KMS`.
func (o GetRepositoryEncryptionConfigurationOutput) EncryptionType() pulumi.StringOutput {
	return o.ApplyT(func(v GetRepositoryEncryptionConfiguration) string { return v.EncryptionType }).(pulumi.StringOutput)
}

// If `encryptionType` is `KMS`, the ARN of the KMS key used.
func (o GetRepositoryEncryptionConfigurationOutput) KmsKey() pulumi.StringOutput {
	return o.ApplyT(func(v GetRepositoryEncryptionConfiguration) string { return v.KmsKey }).(pulumi.StringOutput)
}

type GetRepositoryEncryptionConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetRepositoryEncryptionConfigurationArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetRepositoryEncryptionConfiguration)(nil)).Elem()
}

func (o GetRepositoryEncryptionConfigurationArrayOutput) ToGetRepositoryEncryptionConfigurationArrayOutput() GetRepositoryEncryptionConfigurationArrayOutput {
	return o
}

func (o GetRepositoryEncryptionConfigurationArrayOutput) ToGetRepositoryEncryptionConfigurationArrayOutputWithContext(ctx context.Context) GetRepositoryEncryptionConfigurationArrayOutput {
	return o
}

func (o GetRepositoryEncryptionConfigurationArrayOutput) Index(i pulumi.IntInput) GetRepositoryEncryptionConfigurationOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryEncryptionConfiguration {
		return vs[0].([]GetRepositoryEncryptionConfiguration)[vs[1].(int)]
	}).(GetRepositoryEncryptionConfigurationOutput)
}

type GetRepositoryImageScanningConfiguration struct {
	// Whether images are scanned after being pushed to the repository.
	ScanOnPush bool `pulumi:"scanOnPush"`
}

// GetRepositoryImageScanningConfigurationInput is an input type that accepts GetRepositoryImageScanningConfigurationArgs and GetRepositoryImageScanningConfigurationOutput values.
// You can construct a concrete instance of `GetRepositoryImageScanningConfigurationInput` via:
//
//	GetRepositoryImageScanningConfigurationArgs{...}
type GetRepositoryImageScanningConfigurationInput interface {
	pulumi.Input

	ToGetRepositoryImageScanningConfigurationOutput() GetRepositoryImageScanningConfigurationOutput
	ToGetRepositoryImageScanningConfigurationOutputWithContext(context.Context) GetRepositoryImageScanningConfigurationOutput
}

type GetRepositoryImageScanningConfigurationArgs struct {
	// Whether images are scanned after being pushed to the repository.
	ScanOnPush pulumi.BoolInput `pulumi:"scanOnPush"`
}

func (GetRepositoryImageScanningConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetRepositoryImageScanningConfiguration)(nil)).Elem()
}

func (i GetRepositoryImageScanningConfigurationArgs) ToGetRepositoryImageScanningConfigurationOutput() GetRepositoryImageScanningConfigurationOutput {
	return i.ToGetRepositoryImageScanningConfigurationOutputWithContext(context.Background())
}

func (i GetRepositoryImageScanningConfigurationArgs) ToGetRepositoryImageScanningConfigurationOutputWithContext(ctx context.Context) GetRepositoryImageScanningConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryImageScanningConfigurationOutput)
}

// GetRepositoryImageScanningConfigurationArrayInput is an input type that accepts GetRepositoryImageScanningConfigurationArray and GetRepositoryImageScanningConfigurationArrayOutput values.
// You can construct a concrete instance of `GetRepositoryImageScanningConfigurationArrayInput` via:
//
//	GetRepositoryImageScanningConfigurationArray{ GetRepositoryImageScanningConfigurationArgs{...} }
type GetRepositoryImageScanningConfigurationArrayInput interface {
	pulumi.Input

	ToGetRepositoryImageScanningConfigurationArrayOutput() GetRepositoryImageScanningConfigurationArrayOutput
	ToGetRepositoryImageScanningConfigurationArrayOutputWithContext(context.Context) GetRepositoryImageScanningConfigurationArrayOutput
}

type GetRepositoryImageScanningConfigurationArray []GetRepositoryImageScanningConfigurationInput

func (GetRepositoryImageScanningConfigurationArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetRepositoryImageScanningConfiguration)(nil)).Elem()
}

func (i GetRepositoryImageScanningConfigurationArray) ToGetRepositoryImageScanningConfigurationArrayOutput() GetRepositoryImageScanningConfigurationArrayOutput {
	return i.ToGetRepositoryImageScanningConfigurationArrayOutputWithContext(context.Background())
}

func (i GetRepositoryImageScanningConfigurationArray) ToGetRepositoryImageScanningConfigurationArrayOutputWithContext(ctx context.Context) GetRepositoryImageScanningConfigurationArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryImageScanningConfigurationArrayOutput)
}

type GetRepositoryImageScanningConfigurationOutput struct{ *pulumi.OutputState }

func (GetRepositoryImageScanningConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetRepositoryImageScanningConfiguration)(nil)).Elem()
}

func (o GetRepositoryImageScanningConfigurationOutput) ToGetRepositoryImageScanningConfigurationOutput() GetRepositoryImageScanningConfigurationOutput {
	return o
}

func (o GetRepositoryImageScanningConfigurationOutput) ToGetRepositoryImageScanningConfigurationOutputWithContext(ctx context.Context) GetRepositoryImageScanningConfigurationOutput {
	return o
}

// Whether images are scanned after being pushed to the repository.
func (o GetRepositoryImageScanningConfigurationOutput) ScanOnPush() pulumi.BoolOutput {
	return o.ApplyT(func(v GetRepositoryImageScanningConfiguration) bool { return v.ScanOnPush }).(pulumi.BoolOutput)
}

type GetRepositoryImageScanningConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetRepositoryImageScanningConfigurationArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetRepositoryImageScanningConfiguration)(nil)).Elem()
}

func (o GetRepositoryImageScanningConfigurationArrayOutput) ToGetRepositoryImageScanningConfigurationArrayOutput() GetRepositoryImageScanningConfigurationArrayOutput {
	return o
}

func (o GetRepositoryImageScanningConfigurationArrayOutput) ToGetRepositoryImageScanningConfigurationArrayOutputWithContext(ctx context.Context) GetRepositoryImageScanningConfigurationArrayOutput {
	return o
}

func (o GetRepositoryImageScanningConfigurationArrayOutput) Index(i pulumi.IntInput) GetRepositoryImageScanningConfigurationOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryImageScanningConfiguration {
		return vs[0].([]GetRepositoryImageScanningConfiguration)[vs[1].(int)]
	}).(GetRepositoryImageScanningConfigurationOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*RegistryScanningConfigurationRuleInput)(nil)).Elem(), RegistryScanningConfigurationRuleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RegistryScanningConfigurationRuleArrayInput)(nil)).Elem(), RegistryScanningConfigurationRuleArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RegistryScanningConfigurationRuleRepositoryFilterInput)(nil)).Elem(), RegistryScanningConfigurationRuleRepositoryFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RegistryScanningConfigurationRuleRepositoryFilterArrayInput)(nil)).Elem(), RegistryScanningConfigurationRuleRepositoryFilterArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationInput)(nil)).Elem(), ReplicationConfigurationReplicationConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationPtrInput)(nil)).Elem(), ReplicationConfigurationReplicationConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleInput)(nil)).Elem(), ReplicationConfigurationReplicationConfigurationRuleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleArrayInput)(nil)).Elem(), ReplicationConfigurationReplicationConfigurationRuleArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleDestinationInput)(nil)).Elem(), ReplicationConfigurationReplicationConfigurationRuleDestinationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput)(nil)).Elem(), ReplicationConfigurationReplicationConfigurationRuleDestinationArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterInput)(nil)).Elem(), ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayInput)(nil)).Elem(), ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEncryptionConfigurationInput)(nil)).Elem(), RepositoryEncryptionConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEncryptionConfigurationArrayInput)(nil)).Elem(), RepositoryEncryptionConfigurationArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RepositoryImageScanningConfigurationInput)(nil)).Elem(), RepositoryImageScanningConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RepositoryImageScanningConfigurationPtrInput)(nil)).Elem(), RepositoryImageScanningConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetLifecyclePolicyDocumentRuleInput)(nil)).Elem(), GetLifecyclePolicyDocumentRuleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetLifecyclePolicyDocumentRuleArrayInput)(nil)).Elem(), GetLifecyclePolicyDocumentRuleArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetLifecyclePolicyDocumentRuleActionInput)(nil)).Elem(), GetLifecyclePolicyDocumentRuleActionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetLifecyclePolicyDocumentRuleActionPtrInput)(nil)).Elem(), GetLifecyclePolicyDocumentRuleActionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetLifecyclePolicyDocumentRuleSelectionInput)(nil)).Elem(), GetLifecyclePolicyDocumentRuleSelectionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetLifecyclePolicyDocumentRuleSelectionPtrInput)(nil)).Elem(), GetLifecyclePolicyDocumentRuleSelectionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryEncryptionConfigurationInput)(nil)).Elem(), GetRepositoryEncryptionConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryEncryptionConfigurationArrayInput)(nil)).Elem(), GetRepositoryEncryptionConfigurationArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryImageScanningConfigurationInput)(nil)).Elem(), GetRepositoryImageScanningConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryImageScanningConfigurationArrayInput)(nil)).Elem(), GetRepositoryImageScanningConfigurationArray{})
	pulumi.RegisterOutputType(RegistryScanningConfigurationRuleOutput{})
	pulumi.RegisterOutputType(RegistryScanningConfigurationRuleArrayOutput{})
	pulumi.RegisterOutputType(RegistryScanningConfigurationRuleRepositoryFilterOutput{})
	pulumi.RegisterOutputType(RegistryScanningConfigurationRuleRepositoryFilterArrayOutput{})
	pulumi.RegisterOutputType(ReplicationConfigurationReplicationConfigurationOutput{})
	pulumi.RegisterOutputType(ReplicationConfigurationReplicationConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ReplicationConfigurationReplicationConfigurationRuleOutput{})
	pulumi.RegisterOutputType(ReplicationConfigurationReplicationConfigurationRuleArrayOutput{})
	pulumi.RegisterOutputType(ReplicationConfigurationReplicationConfigurationRuleDestinationOutput{})
	pulumi.RegisterOutputType(ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput{})
	pulumi.RegisterOutputType(ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterOutput{})
	pulumi.RegisterOutputType(ReplicationConfigurationReplicationConfigurationRuleRepositoryFilterArrayOutput{})
	pulumi.RegisterOutputType(RepositoryEncryptionConfigurationOutput{})
	pulumi.RegisterOutputType(RepositoryEncryptionConfigurationArrayOutput{})
	pulumi.RegisterOutputType(RepositoryImageScanningConfigurationOutput{})
	pulumi.RegisterOutputType(RepositoryImageScanningConfigurationPtrOutput{})
	pulumi.RegisterOutputType(GetLifecyclePolicyDocumentRuleOutput{})
	pulumi.RegisterOutputType(GetLifecyclePolicyDocumentRuleArrayOutput{})
	pulumi.RegisterOutputType(GetLifecyclePolicyDocumentRuleActionOutput{})
	pulumi.RegisterOutputType(GetLifecyclePolicyDocumentRuleActionPtrOutput{})
	pulumi.RegisterOutputType(GetLifecyclePolicyDocumentRuleSelectionOutput{})
	pulumi.RegisterOutputType(GetLifecyclePolicyDocumentRuleSelectionPtrOutput{})
	pulumi.RegisterOutputType(GetRepositoryEncryptionConfigurationOutput{})
	pulumi.RegisterOutputType(GetRepositoryEncryptionConfigurationArrayOutput{})
	pulumi.RegisterOutputType(GetRepositoryImageScanningConfigurationOutput{})
	pulumi.RegisterOutputType(GetRepositoryImageScanningConfigurationArrayOutput{})
}