codeartifact

package
v3.38.1 Latest Latest
Warning

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

 Go to latest Published: Apr 13, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Domain 

type Domain struct {
	pulumi.CustomResourceState

	// The ARN of Domain.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The total size of all assets in the domain.
	AssetSizeBytes pulumi.IntOutput `pulumi:"assetSizeBytes"`
	// A timestamp that represents the date and time the domain was created in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8).
	CreatedTime pulumi.StringOutput `pulumi:"createdTime"`
	// The name of the domain to create. All domain names in an AWS Region that are in the same AWS account must be unique. The domain name is used as the prefix in DNS hostnames. Do not use sensitive information in a domain name because it is publicly discoverable.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The encryption key for the domain. This is used to encrypt content stored in a domain. The KMS Key Amazon Resource Name (ARN). The default aws/codeartifact AWS KMS master key is used if this element is absent.
	EncryptionKey pulumi.StringOutput `pulumi:"encryptionKey"`
	// The AWS account ID that owns the domain.
	Owner pulumi.StringOutput `pulumi:"owner"`
	// The number of repositories in the domain.
	RepositoryCount pulumi.IntOutput `pulumi:"repositoryCount"`
	// Key-value map of resource tags.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Provides a CodeArtifact Domain Resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codeartifact.NewDomain(ctx, "example", &codeartifact.DomainArgs{
			Domain: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

CodeArtifact Domain can be imported using the CodeArtifact Domain arn, e.g.

```sh 

$ pulumi import aws:codeartifact/domain:Domain example arn:aws:codeartifact:us-west-2:012345678912:domain/tf-acc-test-8593714120730241305

```

func GetDomain 

func GetDomain(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainState, opts ...pulumi.ResourceOption) (*Domain, error)

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

func NewDomain 

func NewDomain(ctx *pulumi.Context,
	name string, args *DomainArgs, opts ...pulumi.ResourceOption) (*Domain, error)

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

func (*Domain) ElementType added in v3.13.0 

func (*Domain) ElementType() reflect.Type

func (*Domain) ToDomainOutput added in v3.13.0 

func (i *Domain) ToDomainOutput() DomainOutput

func (*Domain) ToDomainOutputWithContext added in v3.13.0 

func (i *Domain) ToDomainOutputWithContext(ctx context.Context) DomainOutput

func (*Domain) ToDomainPtrOutput added in v3.25.0 

func (i *Domain) ToDomainPtrOutput() DomainPtrOutput

func (*Domain) ToDomainPtrOutputWithContext added in v3.25.0 

func (i *Domain) ToDomainPtrOutputWithContext(ctx context.Context) DomainPtrOutput

type DomainArgs 

type DomainArgs struct {
	// The name of the domain to create. All domain names in an AWS Region that are in the same AWS account must be unique. The domain name is used as the prefix in DNS hostnames. Do not use sensitive information in a domain name because it is publicly discoverable.
	Domain pulumi.StringInput
	// The encryption key for the domain. This is used to encrypt content stored in a domain. The KMS Key Amazon Resource Name (ARN). The default aws/codeartifact AWS KMS master key is used if this element is absent.
	EncryptionKey pulumi.StringPtrInput
	// Key-value map of resource tags.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Domain resource.

func (DomainArgs) ElementType 

func (DomainArgs) ElementType() reflect.Type

type DomainArray added in v3.25.0 

type DomainArray []DomainInput

func (DomainArray) ElementType added in v3.25.0 

func (DomainArray) ElementType() reflect.Type

func (DomainArray) ToDomainArrayOutput added in v3.25.0 

func (i DomainArray) ToDomainArrayOutput() DomainArrayOutput

func (DomainArray) ToDomainArrayOutputWithContext added in v3.25.0 

func (i DomainArray) ToDomainArrayOutputWithContext(ctx context.Context) DomainArrayOutput

type DomainArrayInput added in v3.25.0 

type DomainArrayInput interface {
	pulumi.Input

	ToDomainArrayOutput() DomainArrayOutput
	ToDomainArrayOutputWithContext(context.Context) DomainArrayOutput
}

DomainArrayInput is an input type that accepts DomainArray and DomainArrayOutput values. You can construct a concrete instance of `DomainArrayInput` via: 

DomainArray{ DomainArgs{...} }

type DomainArrayOutput added in v3.25.0 

type DomainArrayOutput struct{ *pulumi.OutputState }

func (DomainArrayOutput) ElementType added in v3.25.0 

func (DomainArrayOutput) ElementType() reflect.Type

func (DomainArrayOutput) Index added in v3.25.0 

func (o DomainArrayOutput) Index(i pulumi.IntInput) DomainOutput

func (DomainArrayOutput) ToDomainArrayOutput added in v3.25.0 

func (o DomainArrayOutput) ToDomainArrayOutput() DomainArrayOutput

func (DomainArrayOutput) ToDomainArrayOutputWithContext added in v3.25.0 

func (o DomainArrayOutput) ToDomainArrayOutputWithContext(ctx context.Context) DomainArrayOutput

type DomainInput added in v3.13.0 

type DomainInput interface {
	pulumi.Input

	ToDomainOutput() DomainOutput
	ToDomainOutputWithContext(ctx context.Context) DomainOutput
}

type DomainMap added in v3.25.0 

type DomainMap map[string]DomainInput

func (DomainMap) ElementType added in v3.25.0 

func (DomainMap) ElementType() reflect.Type

func (DomainMap) ToDomainMapOutput added in v3.25.0 

func (i DomainMap) ToDomainMapOutput() DomainMapOutput

func (DomainMap) ToDomainMapOutputWithContext added in v3.25.0 

func (i DomainMap) ToDomainMapOutputWithContext(ctx context.Context) DomainMapOutput

type DomainMapInput added in v3.25.0 

type DomainMapInput interface {
	pulumi.Input

	ToDomainMapOutput() DomainMapOutput
	ToDomainMapOutputWithContext(context.Context) DomainMapOutput
}

DomainMapInput is an input type that accepts DomainMap and DomainMapOutput values. You can construct a concrete instance of `DomainMapInput` via: 

DomainMap{ "key": DomainArgs{...} }

type DomainMapOutput added in v3.25.0 

type DomainMapOutput struct{ *pulumi.OutputState }

func (DomainMapOutput) ElementType added in v3.25.0 

func (DomainMapOutput) ElementType() reflect.Type

func (DomainMapOutput) MapIndex added in v3.25.0 

func (o DomainMapOutput) MapIndex(k pulumi.StringInput) DomainOutput

func (DomainMapOutput) ToDomainMapOutput added in v3.25.0 

func (o DomainMapOutput) ToDomainMapOutput() DomainMapOutput

func (DomainMapOutput) ToDomainMapOutputWithContext added in v3.25.0 

func (o DomainMapOutput) ToDomainMapOutputWithContext(ctx context.Context) DomainMapOutput

type DomainOutput added in v3.13.0 

type DomainOutput struct {
	*pulumi.OutputState
}

func (DomainOutput) ElementType added in v3.13.0 

func (DomainOutput) ElementType() reflect.Type

func (DomainOutput) ToDomainOutput added in v3.13.0 

func (o DomainOutput) ToDomainOutput() DomainOutput

func (DomainOutput) ToDomainOutputWithContext added in v3.13.0 

func (o DomainOutput) ToDomainOutputWithContext(ctx context.Context) DomainOutput

func (DomainOutput) ToDomainPtrOutput added in v3.25.0 

func (o DomainOutput) ToDomainPtrOutput() DomainPtrOutput

func (DomainOutput) ToDomainPtrOutputWithContext added in v3.25.0 

func (o DomainOutput) ToDomainPtrOutputWithContext(ctx context.Context) DomainPtrOutput

type DomainPermissions 

type DomainPermissions struct {
	pulumi.CustomResourceState

	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringOutput `pulumi:"domainOwner"`
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringOutput `pulumi:"policyDocument"`
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringOutput `pulumi:"policyRevision"`
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringOutput `pulumi:"resourceArn"`
}

Provides a CodeArtifact Domains Permissions Policy Resource.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleKey, err := kms.NewKey(ctx, "exampleKey", &kms.KeyArgs{
			Description: pulumi.String("domain key"),
		})
		if err != nil {
			return err
		}
		exampleDomain, err := codeartifact.NewDomain(ctx, "exampleDomain", &codeartifact.DomainArgs{
			Domain:        pulumi.String("example.com"),
			EncryptionKey: exampleKey.Arn,
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewDomainPermissions(ctx, "test", &codeartifact.DomainPermissionsArgs{
			Domain: exampleDomain.Domain,
			PolicyDocument: exampleDomain.Arn.ApplyT(func(arn string) (string, error) {
				return fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"Version\": \"2012-10-17\",\n", "    \"Statement\": [\n", "        {\n", "            \"Action\": \"codeartifact:CreateRepository\",\n", "            \"Effect\": \"Allow\",\n", "            \"Principal\": \"*\",\n", "            \"Resource\": \"", arn, "\"\n", "        }\n", "    ]\n", "}\n"), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

CodeArtifact Domain Permissions Policies can be imported using the CodeArtifact Domain ARN, e.g.

```sh 

$ pulumi import aws:codeartifact/domainPermissions:DomainPermissions example arn:aws:codeartifact:us-west-2:012345678912:domain/tf-acc-test-1928056699409417367

```

func GetDomainPermissions 

func GetDomainPermissions(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainPermissionsState, opts ...pulumi.ResourceOption) (*DomainPermissions, error)

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

func NewDomainPermissions 

func NewDomainPermissions(ctx *pulumi.Context,
	name string, args *DomainPermissionsArgs, opts ...pulumi.ResourceOption) (*DomainPermissions, error)

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

func (*DomainPermissions) ElementType added in v3.13.0 

func (*DomainPermissions) ElementType() reflect.Type

func (*DomainPermissions) ToDomainPermissionsOutput added in v3.13.0 

func (i *DomainPermissions) ToDomainPermissionsOutput() DomainPermissionsOutput

func (*DomainPermissions) ToDomainPermissionsOutputWithContext added in v3.13.0 

func (i *DomainPermissions) ToDomainPermissionsOutputWithContext(ctx context.Context) DomainPermissionsOutput

func (*DomainPermissions) ToDomainPermissionsPtrOutput added in v3.25.0 

func (i *DomainPermissions) ToDomainPermissionsPtrOutput() DomainPermissionsPtrOutput

func (*DomainPermissions) ToDomainPermissionsPtrOutputWithContext added in v3.25.0 

func (i *DomainPermissions) ToDomainPermissionsPtrOutputWithContext(ctx context.Context) DomainPermissionsPtrOutput

type DomainPermissionsArgs 

type DomainPermissionsArgs struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
}

The set of arguments for constructing a DomainPermissions resource.

func (DomainPermissionsArgs) ElementType 

func (DomainPermissionsArgs) ElementType() reflect.Type

type DomainPermissionsArray added in v3.25.0 

type DomainPermissionsArray []DomainPermissionsInput

func (DomainPermissionsArray) ElementType added in v3.25.0 

func (DomainPermissionsArray) ElementType() reflect.Type

func (DomainPermissionsArray) ToDomainPermissionsArrayOutput added in v3.25.0 

func (i DomainPermissionsArray) ToDomainPermissionsArrayOutput() DomainPermissionsArrayOutput

func (DomainPermissionsArray) ToDomainPermissionsArrayOutputWithContext added in v3.25.0 

func (i DomainPermissionsArray) ToDomainPermissionsArrayOutputWithContext(ctx context.Context) DomainPermissionsArrayOutput

type DomainPermissionsArrayInput added in v3.25.0 

type DomainPermissionsArrayInput interface {
	pulumi.Input

	ToDomainPermissionsArrayOutput() DomainPermissionsArrayOutput
	ToDomainPermissionsArrayOutputWithContext(context.Context) DomainPermissionsArrayOutput
}

DomainPermissionsArrayInput is an input type that accepts DomainPermissionsArray and DomainPermissionsArrayOutput values. You can construct a concrete instance of `DomainPermissionsArrayInput` via: 

DomainPermissionsArray{ DomainPermissionsArgs{...} }

type DomainPermissionsArrayOutput added in v3.25.0 

type DomainPermissionsArrayOutput struct{ *pulumi.OutputState }

func (DomainPermissionsArrayOutput) ElementType added in v3.25.0 

func (DomainPermissionsArrayOutput) ElementType() reflect.Type

func (DomainPermissionsArrayOutput) Index added in v3.25.0 

func (o DomainPermissionsArrayOutput) Index(i pulumi.IntInput) DomainPermissionsOutput

func (DomainPermissionsArrayOutput) ToDomainPermissionsArrayOutput added in v3.25.0 

func (o DomainPermissionsArrayOutput) ToDomainPermissionsArrayOutput() DomainPermissionsArrayOutput

func (DomainPermissionsArrayOutput) ToDomainPermissionsArrayOutputWithContext added in v3.25.0 

func (o DomainPermissionsArrayOutput) ToDomainPermissionsArrayOutputWithContext(ctx context.Context) DomainPermissionsArrayOutput

type DomainPermissionsInput added in v3.13.0 

type DomainPermissionsInput interface {
	pulumi.Input

	ToDomainPermissionsOutput() DomainPermissionsOutput
	ToDomainPermissionsOutputWithContext(ctx context.Context) DomainPermissionsOutput
}

type DomainPermissionsMap added in v3.25.0 

type DomainPermissionsMap map[string]DomainPermissionsInput

func (DomainPermissionsMap) ElementType added in v3.25.0 

func (DomainPermissionsMap) ElementType() reflect.Type

func (DomainPermissionsMap) ToDomainPermissionsMapOutput added in v3.25.0 

func (i DomainPermissionsMap) ToDomainPermissionsMapOutput() DomainPermissionsMapOutput

func (DomainPermissionsMap) ToDomainPermissionsMapOutputWithContext added in v3.25.0 

func (i DomainPermissionsMap) ToDomainPermissionsMapOutputWithContext(ctx context.Context) DomainPermissionsMapOutput

type DomainPermissionsMapInput added in v3.25.0 

type DomainPermissionsMapInput interface {
	pulumi.Input

	ToDomainPermissionsMapOutput() DomainPermissionsMapOutput
	ToDomainPermissionsMapOutputWithContext(context.Context) DomainPermissionsMapOutput
}

DomainPermissionsMapInput is an input type that accepts DomainPermissionsMap and DomainPermissionsMapOutput values. You can construct a concrete instance of `DomainPermissionsMapInput` via: 

DomainPermissionsMap{ "key": DomainPermissionsArgs{...} }

type DomainPermissionsMapOutput added in v3.25.0 

type DomainPermissionsMapOutput struct{ *pulumi.OutputState }

func (DomainPermissionsMapOutput) ElementType added in v3.25.0 

func (DomainPermissionsMapOutput) ElementType() reflect.Type

func (DomainPermissionsMapOutput) MapIndex added in v3.25.0 

func (o DomainPermissionsMapOutput) MapIndex(k pulumi.StringInput) DomainPermissionsOutput

func (DomainPermissionsMapOutput) ToDomainPermissionsMapOutput added in v3.25.0 

func (o DomainPermissionsMapOutput) ToDomainPermissionsMapOutput() DomainPermissionsMapOutput

func (DomainPermissionsMapOutput) ToDomainPermissionsMapOutputWithContext added in v3.25.0 

func (o DomainPermissionsMapOutput) ToDomainPermissionsMapOutputWithContext(ctx context.Context) DomainPermissionsMapOutput

type DomainPermissionsOutput added in v3.13.0 

type DomainPermissionsOutput struct {
	*pulumi.OutputState
}

func (DomainPermissionsOutput) ElementType added in v3.13.0 

func (DomainPermissionsOutput) ElementType() reflect.Type

func (DomainPermissionsOutput) ToDomainPermissionsOutput added in v3.13.0 

func (o DomainPermissionsOutput) ToDomainPermissionsOutput() DomainPermissionsOutput

func (DomainPermissionsOutput) ToDomainPermissionsOutputWithContext added in v3.13.0 

func (o DomainPermissionsOutput) ToDomainPermissionsOutputWithContext(ctx context.Context) DomainPermissionsOutput

func (DomainPermissionsOutput) ToDomainPermissionsPtrOutput added in v3.25.0 

func (o DomainPermissionsOutput) ToDomainPermissionsPtrOutput() DomainPermissionsPtrOutput

func (DomainPermissionsOutput) ToDomainPermissionsPtrOutputWithContext added in v3.25.0 

func (o DomainPermissionsOutput) ToDomainPermissionsPtrOutputWithContext(ctx context.Context) DomainPermissionsPtrOutput

type DomainPermissionsPolicy 

type DomainPermissionsPolicy struct {
	pulumi.CustomResourceState

	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringOutput `pulumi:"domainOwner"`
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringOutput `pulumi:"policyDocument"`
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringOutput `pulumi:"policyRevision"`
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringOutput `pulumi:"resourceArn"`
}

Provides a CodeArtifact Domains Permissions Policy Resource.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleKey, err := kms.NewKey(ctx, "exampleKey", &kms.KeyArgs{
			Description: pulumi.String("domain key"),
		})
		if err != nil {
			return err
		}
		exampleDomain, err := codeartifact.NewDomain(ctx, "exampleDomain", &codeartifact.DomainArgs{
			Domain:        pulumi.String("example.com"),
			EncryptionKey: exampleKey.Arn,
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewDomainPermissionsPolicy(ctx, "test", &codeartifact.DomainPermissionsPolicyArgs{
			Domain: exampleDomain.Domain,
			PolicyDocument: exampleDomain.Arn.ApplyT(func(arn string) (string, error) {
				return fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"Version\": \"2012-10-17\",\n", "    \"Statement\": [\n", "        {\n", "            \"Action\": \"codeartifact:CreateRepository\",\n", "            \"Effect\": \"Allow\",\n", "            \"Principal\": \"*\",\n", "            \"Resource\": \"", arn, "\"\n", "        }\n", "    ]\n", "}\n"), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetDomainPermissionsPolicy 

func GetDomainPermissionsPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainPermissionsPolicyState, opts ...pulumi.ResourceOption) (*DomainPermissionsPolicy, error)

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

func NewDomainPermissionsPolicy 

func NewDomainPermissionsPolicy(ctx *pulumi.Context,
	name string, args *DomainPermissionsPolicyArgs, opts ...pulumi.ResourceOption) (*DomainPermissionsPolicy, error)

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

type DomainPermissionsPolicyArgs 

type DomainPermissionsPolicyArgs struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
}

The set of arguments for constructing a DomainPermissionsPolicy resource.

func (DomainPermissionsPolicyArgs) ElementType 

func (DomainPermissionsPolicyArgs) ElementType() reflect.Type

type DomainPermissionsPolicyState 

type DomainPermissionsPolicyState struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringPtrInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringPtrInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringPtrInput
}

func (DomainPermissionsPolicyState) ElementType 

func (DomainPermissionsPolicyState) ElementType() reflect.Type

type DomainPermissionsPtrInput added in v3.25.0 

type DomainPermissionsPtrInput interface {
	pulumi.Input

	ToDomainPermissionsPtrOutput() DomainPermissionsPtrOutput
	ToDomainPermissionsPtrOutputWithContext(ctx context.Context) DomainPermissionsPtrOutput
}

type DomainPermissionsPtrOutput added in v3.25.0 

type DomainPermissionsPtrOutput struct {
	*pulumi.OutputState
}

func (DomainPermissionsPtrOutput) ElementType added in v3.25.0 

func (DomainPermissionsPtrOutput) ElementType() reflect.Type

func (DomainPermissionsPtrOutput) ToDomainPermissionsPtrOutput added in v3.25.0 

func (o DomainPermissionsPtrOutput) ToDomainPermissionsPtrOutput() DomainPermissionsPtrOutput

func (DomainPermissionsPtrOutput) ToDomainPermissionsPtrOutputWithContext added in v3.25.0 

func (o DomainPermissionsPtrOutput) ToDomainPermissionsPtrOutputWithContext(ctx context.Context) DomainPermissionsPtrOutput

type DomainPermissionsState 

type DomainPermissionsState struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringPtrInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringPtrInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringPtrInput
}

func (DomainPermissionsState) ElementType 

func (DomainPermissionsState) ElementType() reflect.Type

type DomainPtrInput added in v3.25.0 

type DomainPtrInput interface {
	pulumi.Input

	ToDomainPtrOutput() DomainPtrOutput
	ToDomainPtrOutputWithContext(ctx context.Context) DomainPtrOutput
}

type DomainPtrOutput added in v3.25.0 

type DomainPtrOutput struct {
	*pulumi.OutputState
}

func (DomainPtrOutput) ElementType added in v3.25.0 

func (DomainPtrOutput) ElementType() reflect.Type

func (DomainPtrOutput) ToDomainPtrOutput added in v3.25.0 

func (o DomainPtrOutput) ToDomainPtrOutput() DomainPtrOutput

func (DomainPtrOutput) ToDomainPtrOutputWithContext added in v3.25.0 

func (o DomainPtrOutput) ToDomainPtrOutputWithContext(ctx context.Context) DomainPtrOutput

type DomainState 

type DomainState struct {
	// The ARN of Domain.
	Arn pulumi.StringPtrInput
	// The total size of all assets in the domain.
	AssetSizeBytes pulumi.IntPtrInput
	// A timestamp that represents the date and time the domain was created in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8).
	CreatedTime pulumi.StringPtrInput
	// The name of the domain to create. All domain names in an AWS Region that are in the same AWS account must be unique. The domain name is used as the prefix in DNS hostnames. Do not use sensitive information in a domain name because it is publicly discoverable.
	Domain pulumi.StringPtrInput
	// The encryption key for the domain. This is used to encrypt content stored in a domain. The KMS Key Amazon Resource Name (ARN). The default aws/codeartifact AWS KMS master key is used if this element is absent.
	EncryptionKey pulumi.StringPtrInput
	// The AWS account ID that owns the domain.
	Owner pulumi.StringPtrInput
	// The number of repositories in the domain.
	RepositoryCount pulumi.IntPtrInput
	// Key-value map of resource tags.
	Tags pulumi.StringMapInput
}

func (DomainState) ElementType 

func (DomainState) ElementType() reflect.Type

type GetAuthorizationTokenArgs added in v3.7.0 

type GetAuthorizationTokenArgs struct {
	// The name of the domain that is in scope for the generated authorization token.
	Domain string `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner *string `pulumi:"domainOwner"`
	// The time, in seconds, that the generated authorization token is valid. Valid values are `0` and between `900` and `43200`.
	DurationSeconds *int `pulumi:"durationSeconds"`
}

A collection of arguments for invoking getAuthorizationToken.

type GetAuthorizationTokenResult added in v3.7.0 

type GetAuthorizationTokenResult struct {
	// Temporary authorization token.
	AuthorizationToken string `pulumi:"authorizationToken"`
	Domain             string `pulumi:"domain"`
	DomainOwner        string `pulumi:"domainOwner"`
	DurationSeconds    *int   `pulumi:"durationSeconds"`
	// The time in UTC RFC3339 format when the authorization token expires.
	Expiration string `pulumi:"expiration"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
}

A collection of values returned by getAuthorizationToken.

func GetAuthorizationToken added in v3.7.0 

func GetAuthorizationToken(ctx *pulumi.Context, args *GetAuthorizationTokenArgs, opts ...pulumi.InvokeOption) (*GetAuthorizationTokenResult, error)

The CodeArtifact Authorization Token data source generates a temporary authentication token for accessing repositories in a CodeArtifact domain.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codeartifact.GetAuthorizationToken(ctx, &codeartifact.GetAuthorizationTokenArgs{
			Domain: aws_codeartifact_domain.Test.Domain,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetRepositoryEndpointArgs added in v3.8.0 

type GetRepositoryEndpointArgs struct {
	// The name of the domain that contains the repository.
	Domain string `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner *string `pulumi:"domainOwner"`
	// Which endpoint of a repository to return. A repository has one endpoint for each package format: `npm`, `pypi`, `maven`, and `nuget`.
	Format string `pulumi:"format"`
	// The name of the repository.
	Repository string `pulumi:"repository"`
}

A collection of arguments for invoking getRepositoryEndpoint.

type GetRepositoryEndpointResult added in v3.8.0 

type GetRepositoryEndpointResult struct {
	Domain      string `pulumi:"domain"`
	DomainOwner string `pulumi:"domainOwner"`
	Format      string `pulumi:"format"`
	// The provider-assigned unique ID for this managed resource.
	Id         string `pulumi:"id"`
	Repository string `pulumi:"repository"`
	// The URL of the returned endpoint.
	RepositoryEndpoint string `pulumi:"repositoryEndpoint"`
}

A collection of values returned by getRepositoryEndpoint.

func GetRepositoryEndpoint added in v3.8.0 

func GetRepositoryEndpoint(ctx *pulumi.Context, args *GetRepositoryEndpointArgs, opts ...pulumi.InvokeOption) (*GetRepositoryEndpointResult, error)

The CodeArtifact Repository Endpoint data source returns the endpoint of a repository for a specific package format.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codeartifact.GetRepositoryEndpoint(ctx, &codeartifact.GetRepositoryEndpointArgs{
			Domain:     aws_codeartifact_domain.Test.Domain,
			Repository: aws_codeartifact_repository.Test.Repository,
			Format:     "npm",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type Repository 

type Repository struct {
	pulumi.CustomResourceState

	// The account number of the AWS account that manages the repository.
	AdministratorAccount pulumi.StringOutput `pulumi:"administratorAccount"`
	// The ARN of the repository.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The description of the repository.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The domain that contains the created repository.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringOutput `pulumi:"domainOwner"`
	// An array of external connections associated with the repository. Only one external connection can be set per repository. see External Connections.
	ExternalConnections RepositoryExternalConnectionsPtrOutput `pulumi:"externalConnections"`
	// The name of the repository to create.
	Repository pulumi.StringOutput `pulumi:"repository"`
	// Key-value map of resource tags.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A list of upstream repositories to associate with the repository. The order of the upstream repositories in the list determines their priority order when AWS CodeArtifact looks for a requested package version. see Upstream
	Upstreams RepositoryUpstreamArrayOutput `pulumi:"upstreams"`
}

Provides a CodeArtifact Repository Resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleKey, err := kms.NewKey(ctx, "exampleKey", &kms.KeyArgs{
			Description: pulumi.String("domain key"),
		})
		if err != nil {
			return err
		}
		exampleDomain, err := codeartifact.NewDomain(ctx, "exampleDomain", &codeartifact.DomainArgs{
			Domain:        pulumi.String("example"),
			EncryptionKey: exampleKey.Arn,
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewRepository(ctx, "test", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("example"),
			Domain:     exampleDomain.Domain,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### With Upstream Repository

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		upstream, err := codeartifact.NewRepository(ctx, "upstream", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("upstream"),
			Domain:     pulumi.Any(aws_codeartifact_domain.Test.Domain),
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewRepository(ctx, "test", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("example"),
			Domain:     pulumi.Any(aws_codeartifact_domain.Example.Domain),
			Upstreams: codeartifact.RepositoryUpstreamArray{
				&codeartifact.RepositoryUpstreamArgs{
					RepositoryName: upstream.Repository,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### With External Connection

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codeartifact.NewRepository(ctx, "upstream", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("upstream"),
			Domain:     pulumi.Any(aws_codeartifact_domain.Test.Domain),
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewRepository(ctx, "test", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("example"),
			Domain:     pulumi.Any(aws_codeartifact_domain.Example.Domain),
			ExternalConnections: &codeartifact.RepositoryExternalConnectionsArgs{
				ExternalConnectionName: pulumi.String("public:npmjs"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

CodeArtifact Repository can be imported using the CodeArtifact Repository ARN, e.g.

```sh 

$ pulumi import aws:codeartifact/repository:Repository example arn:aws:codeartifact:us-west-2:012345678912:repository/tf-acc-test-6968272603913957763/tf-acc-test-6968272603913957763

```

func GetRepository 

func GetRepository(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RepositoryState, opts ...pulumi.ResourceOption) (*Repository, error)

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

func NewRepository 

func NewRepository(ctx *pulumi.Context,
	name string, args *RepositoryArgs, opts ...pulumi.ResourceOption) (*Repository, error)

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

func (*Repository) ElementType added in v3.13.0 

func (*Repository) ElementType() reflect.Type

func (*Repository) ToRepositoryOutput added in v3.13.0 

func (i *Repository) ToRepositoryOutput() RepositoryOutput

func (*Repository) ToRepositoryOutputWithContext added in v3.13.0 

func (i *Repository) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput

func (*Repository) ToRepositoryPtrOutput added in v3.25.0 

func (i *Repository) ToRepositoryPtrOutput() RepositoryPtrOutput

func (*Repository) ToRepositoryPtrOutputWithContext added in v3.25.0 

func (i *Repository) ToRepositoryPtrOutputWithContext(ctx context.Context) RepositoryPtrOutput

type RepositoryArgs 

type RepositoryArgs struct {
	// The description of the repository.
	Description pulumi.StringPtrInput
	// The domain that contains the created repository.
	Domain pulumi.StringInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// An array of external connections associated with the repository. Only one external connection can be set per repository. see External Connections.
	ExternalConnections RepositoryExternalConnectionsPtrInput
	// The name of the repository to create.
	Repository pulumi.StringInput
	// Key-value map of resource tags.
	Tags pulumi.StringMapInput
	// A list of upstream repositories to associate with the repository. The order of the upstream repositories in the list determines their priority order when AWS CodeArtifact looks for a requested package version. see Upstream
	Upstreams RepositoryUpstreamArrayInput
}

The set of arguments for constructing a Repository resource.

func (RepositoryArgs) ElementType 

func (RepositoryArgs) ElementType() reflect.Type

type RepositoryArray added in v3.25.0 

type RepositoryArray []RepositoryInput

func (RepositoryArray) ElementType added in v3.25.0 

func (RepositoryArray) ElementType() reflect.Type

func (RepositoryArray) ToRepositoryArrayOutput added in v3.25.0 

func (i RepositoryArray) ToRepositoryArrayOutput() RepositoryArrayOutput

func (RepositoryArray) ToRepositoryArrayOutputWithContext added in v3.25.0 

func (i RepositoryArray) ToRepositoryArrayOutputWithContext(ctx context.Context) RepositoryArrayOutput

type RepositoryArrayInput added in v3.25.0 

type RepositoryArrayInput interface {
	pulumi.Input

	ToRepositoryArrayOutput() RepositoryArrayOutput
	ToRepositoryArrayOutputWithContext(context.Context) RepositoryArrayOutput
}

RepositoryArrayInput is an input type that accepts RepositoryArray and RepositoryArrayOutput values. You can construct a concrete instance of `RepositoryArrayInput` via: 

RepositoryArray{ RepositoryArgs{...} }

type RepositoryArrayOutput added in v3.25.0 

type RepositoryArrayOutput struct{ *pulumi.OutputState }

func (RepositoryArrayOutput) ElementType added in v3.25.0 

func (RepositoryArrayOutput) ElementType() reflect.Type

func (RepositoryArrayOutput) Index added in v3.25.0 

func (o RepositoryArrayOutput) Index(i pulumi.IntInput) RepositoryOutput

func (RepositoryArrayOutput) ToRepositoryArrayOutput added in v3.25.0 

func (o RepositoryArrayOutput) ToRepositoryArrayOutput() RepositoryArrayOutput

func (RepositoryArrayOutput) ToRepositoryArrayOutputWithContext added in v3.25.0 

func (o RepositoryArrayOutput) ToRepositoryArrayOutputWithContext(ctx context.Context) RepositoryArrayOutput

type RepositoryExternalConnections added in v3.10.0 

type RepositoryExternalConnections struct {
	// The name of the external connection associated with a repository.
	ExternalConnectionName string  `pulumi:"externalConnectionName"`
	PackageFormat          *string `pulumi:"packageFormat"`
	Status                 *string `pulumi:"status"`
}

type RepositoryExternalConnectionsArgs added in v3.10.0 

type RepositoryExternalConnectionsArgs struct {
	// The name of the external connection associated with a repository.
	ExternalConnectionName pulumi.StringInput    `pulumi:"externalConnectionName"`
	PackageFormat          pulumi.StringPtrInput `pulumi:"packageFormat"`
	Status                 pulumi.StringPtrInput `pulumi:"status"`
}

func (RepositoryExternalConnectionsArgs) ElementType added in v3.10.0 

func (RepositoryExternalConnectionsArgs) ElementType() reflect.Type

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutput added in v3.10.0 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutput() RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutputWithContext added in v3.10.0 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutputWithContext(ctx context.Context) RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutput added in v3.10.0 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutputWithContext added in v3.10.0 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutputWithContext(ctx context.Context) RepositoryExternalConnectionsPtrOutput

type RepositoryExternalConnectionsInput added in v3.10.0 

type RepositoryExternalConnectionsInput interface {
	pulumi.Input

	ToRepositoryExternalConnectionsOutput() RepositoryExternalConnectionsOutput
	ToRepositoryExternalConnectionsOutputWithContext(context.Context) RepositoryExternalConnectionsOutput
}

RepositoryExternalConnectionsInput is an input type that accepts RepositoryExternalConnectionsArgs and RepositoryExternalConnectionsOutput values. You can construct a concrete instance of `RepositoryExternalConnectionsInput` via: 

RepositoryExternalConnectionsArgs{...}

type RepositoryExternalConnectionsOutput added in v3.10.0 

type RepositoryExternalConnectionsOutput struct{ *pulumi.OutputState }

func (RepositoryExternalConnectionsOutput) ElementType added in v3.10.0 

func (RepositoryExternalConnectionsOutput) ElementType() reflect.Type

func (RepositoryExternalConnectionsOutput) ExternalConnectionName added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ExternalConnectionName() pulumi.StringOutput

The name of the external connection associated with a repository.

func (RepositoryExternalConnectionsOutput) PackageFormat added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) PackageFormat() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsOutput) Status added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) Status() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutput added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutput() RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutputWithContext added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutputWithContext(ctx context.Context) RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutput added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutputWithContext added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutputWithContext(ctx context.Context) RepositoryExternalConnectionsPtrOutput

type RepositoryExternalConnectionsPtrInput added in v3.10.0 

type RepositoryExternalConnectionsPtrInput interface {
	pulumi.Input

	ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput
	ToRepositoryExternalConnectionsPtrOutputWithContext(context.Context) RepositoryExternalConnectionsPtrOutput
}

RepositoryExternalConnectionsPtrInput is an input type that accepts RepositoryExternalConnectionsArgs, RepositoryExternalConnectionsPtr and RepositoryExternalConnectionsPtrOutput values. You can construct a concrete instance of `RepositoryExternalConnectionsPtrInput` via: 

        RepositoryExternalConnectionsArgs{...}

or:

        nil

func RepositoryExternalConnectionsPtr added in v3.10.0 

func RepositoryExternalConnectionsPtr(v *RepositoryExternalConnectionsArgs) RepositoryExternalConnectionsPtrInput

type RepositoryExternalConnectionsPtrOutput added in v3.10.0 

type RepositoryExternalConnectionsPtrOutput struct{ *pulumi.OutputState }

func (RepositoryExternalConnectionsPtrOutput) Elem added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) Elem() RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsPtrOutput) ElementType added in v3.10.0 

func (RepositoryExternalConnectionsPtrOutput) ElementType() reflect.Type

func (RepositoryExternalConnectionsPtrOutput) ExternalConnectionName added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) ExternalConnectionName() pulumi.StringPtrOutput

The name of the external connection associated with a repository.

func (RepositoryExternalConnectionsPtrOutput) PackageFormat added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) PackageFormat() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsPtrOutput) Status added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) Status() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutput added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput

func (RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutputWithContext added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutputWithContext(ctx context.Context) RepositoryExternalConnectionsPtrOutput

type RepositoryInput added in v3.13.0 

type RepositoryInput interface {
	pulumi.Input

	ToRepositoryOutput() RepositoryOutput
	ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput
}

type RepositoryMap added in v3.25.0 

type RepositoryMap map[string]RepositoryInput

func (RepositoryMap) ElementType added in v3.25.0 

func (RepositoryMap) ElementType() reflect.Type

func (RepositoryMap) ToRepositoryMapOutput added in v3.25.0 

func (i RepositoryMap) ToRepositoryMapOutput() RepositoryMapOutput

func (RepositoryMap) ToRepositoryMapOutputWithContext added in v3.25.0 

func (i RepositoryMap) ToRepositoryMapOutputWithContext(ctx context.Context) RepositoryMapOutput

type RepositoryMapInput added in v3.25.0 

type RepositoryMapInput interface {
	pulumi.Input

	ToRepositoryMapOutput() RepositoryMapOutput
	ToRepositoryMapOutputWithContext(context.Context) RepositoryMapOutput
}

RepositoryMapInput is an input type that accepts RepositoryMap and RepositoryMapOutput values. You can construct a concrete instance of `RepositoryMapInput` via: 

RepositoryMap{ "key": RepositoryArgs{...} }

type RepositoryMapOutput added in v3.25.0 

type RepositoryMapOutput struct{ *pulumi.OutputState }

func (RepositoryMapOutput) ElementType added in v3.25.0 

func (RepositoryMapOutput) ElementType() reflect.Type

func (RepositoryMapOutput) MapIndex added in v3.25.0 

func (o RepositoryMapOutput) MapIndex(k pulumi.StringInput) RepositoryOutput

func (RepositoryMapOutput) ToRepositoryMapOutput added in v3.25.0 

func (o RepositoryMapOutput) ToRepositoryMapOutput() RepositoryMapOutput

func (RepositoryMapOutput) ToRepositoryMapOutputWithContext added in v3.25.0 

func (o RepositoryMapOutput) ToRepositoryMapOutputWithContext(ctx context.Context) RepositoryMapOutput

type RepositoryOutput added in v3.13.0 

type RepositoryOutput struct {
	*pulumi.OutputState
}

func (RepositoryOutput) ElementType added in v3.13.0 

func (RepositoryOutput) ElementType() reflect.Type

func (RepositoryOutput) ToRepositoryOutput added in v3.13.0 

func (o RepositoryOutput) ToRepositoryOutput() RepositoryOutput

func (RepositoryOutput) ToRepositoryOutputWithContext added in v3.13.0 

func (o RepositoryOutput) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput

func (RepositoryOutput) ToRepositoryPtrOutput added in v3.25.0 

func (o RepositoryOutput) ToRepositoryPtrOutput() RepositoryPtrOutput

func (RepositoryOutput) ToRepositoryPtrOutputWithContext added in v3.25.0 

func (o RepositoryOutput) ToRepositoryPtrOutputWithContext(ctx context.Context) RepositoryPtrOutput

type RepositoryPermissionsPolicy added in v3.7.0 

type RepositoryPermissionsPolicy struct {
	pulumi.CustomResourceState

	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringOutput `pulumi:"domainOwner"`
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringOutput `pulumi:"policyDocument"`
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringOutput `pulumi:"policyRevision"`
	// The name of the repository to set the resource policy on.
	Repository pulumi.StringOutput `pulumi:"repository"`
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringOutput `pulumi:"resourceArn"`
}

Provides a CodeArtifact Repostory Permissions Policy Resource.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleKey, err := kms.NewKey(ctx, "exampleKey", &kms.KeyArgs{
			Description: pulumi.String("domain key"),
		})
		if err != nil {
			return err
		}
		exampleDomain, err := codeartifact.NewDomain(ctx, "exampleDomain", &codeartifact.DomainArgs{
			Domain:        pulumi.String("example.com"),
			EncryptionKey: exampleKey.Arn,
		})
		if err != nil {
			return err
		}
		exampleRepository, err := codeartifact.NewRepository(ctx, "exampleRepository", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("example"),
			Domain:     exampleDomain.Domain,
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewRepositoryPermissionsPolicy(ctx, "exampleRepositoryPermissionsPolicy", &codeartifact.RepositoryPermissionsPolicyArgs{
			Repository: exampleRepository.Repository,
			Domain:     exampleDomain.Domain,
			PolicyDocument: exampleDomain.Arn.ApplyT(func(arn string) (string, error) {
				return fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"Version\": \"2012-10-17\",\n", "    \"Statement\": [\n", "        {\n", "            \"Action\": \"codeartifact:CreateRepository\",\n", "            \"Effect\": \"Allow\",\n", "            \"Principal\": \"*\",\n", "            \"Resource\": \"", arn, "\"\n", "        }\n", "    ]\n", "}\n"), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

CodeArtifact Repository Permissions Policies can be imported using the CodeArtifact Repository ARN, e.g.

```sh 

$ pulumi import aws:codeartifact/repositoryPermissionsPolicy:RepositoryPermissionsPolicy example arn:aws:codeartifact:us-west-2:012345678912:repository/tf-acc-test-6968272603913957763/tf-acc-test-6968272603913957763

```

func GetRepositoryPermissionsPolicy added in v3.7.0 

func GetRepositoryPermissionsPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RepositoryPermissionsPolicyState, opts ...pulumi.ResourceOption) (*RepositoryPermissionsPolicy, error)

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

func NewRepositoryPermissionsPolicy added in v3.7.0 

func NewRepositoryPermissionsPolicy(ctx *pulumi.Context,
	name string, args *RepositoryPermissionsPolicyArgs, opts ...pulumi.ResourceOption) (*RepositoryPermissionsPolicy, error)

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

func (*RepositoryPermissionsPolicy) ElementType added in v3.13.0 

func (*RepositoryPermissionsPolicy) ElementType() reflect.Type

func (*RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutput added in v3.13.0 

func (i *RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutput() RepositoryPermissionsPolicyOutput

func (*RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutputWithContext added in v3.13.0 

func (i *RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyOutput

func (*RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyPtrOutput added in v3.25.0 

func (i *RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyPtrOutput() RepositoryPermissionsPolicyPtrOutput

func (*RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyPtrOutputWithContext added in v3.25.0 

func (i *RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyPtrOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyPtrOutput

type RepositoryPermissionsPolicyArgs added in v3.7.0 

type RepositoryPermissionsPolicyArgs struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
	// The name of the repository to set the resource policy on.
	Repository pulumi.StringInput
}

The set of arguments for constructing a RepositoryPermissionsPolicy resource.

func (RepositoryPermissionsPolicyArgs) ElementType added in v3.7.0 

func (RepositoryPermissionsPolicyArgs) ElementType() reflect.Type

type RepositoryPermissionsPolicyArray added in v3.25.0 

type RepositoryPermissionsPolicyArray []RepositoryPermissionsPolicyInput

func (RepositoryPermissionsPolicyArray) ElementType added in v3.25.0 

func (RepositoryPermissionsPolicyArray) ElementType() reflect.Type

func (RepositoryPermissionsPolicyArray) ToRepositoryPermissionsPolicyArrayOutput added in v3.25.0 

func (i RepositoryPermissionsPolicyArray) ToRepositoryPermissionsPolicyArrayOutput() RepositoryPermissionsPolicyArrayOutput

func (RepositoryPermissionsPolicyArray) ToRepositoryPermissionsPolicyArrayOutputWithContext added in v3.25.0 

func (i RepositoryPermissionsPolicyArray) ToRepositoryPermissionsPolicyArrayOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyArrayOutput

type RepositoryPermissionsPolicyArrayInput added in v3.25.0 

type RepositoryPermissionsPolicyArrayInput interface {
	pulumi.Input

	ToRepositoryPermissionsPolicyArrayOutput() RepositoryPermissionsPolicyArrayOutput
	ToRepositoryPermissionsPolicyArrayOutputWithContext(context.Context) RepositoryPermissionsPolicyArrayOutput
}

RepositoryPermissionsPolicyArrayInput is an input type that accepts RepositoryPermissionsPolicyArray and RepositoryPermissionsPolicyArrayOutput values. You can construct a concrete instance of `RepositoryPermissionsPolicyArrayInput` via: 

RepositoryPermissionsPolicyArray{ RepositoryPermissionsPolicyArgs{...} }

type RepositoryPermissionsPolicyArrayOutput added in v3.25.0 

type RepositoryPermissionsPolicyArrayOutput struct{ *pulumi.OutputState }

func (RepositoryPermissionsPolicyArrayOutput) ElementType added in v3.25.0 

func (RepositoryPermissionsPolicyArrayOutput) ElementType() reflect.Type

func (RepositoryPermissionsPolicyArrayOutput) Index added in v3.25.0 

func (o RepositoryPermissionsPolicyArrayOutput) Index(i pulumi.IntInput) RepositoryPermissionsPolicyOutput

func (RepositoryPermissionsPolicyArrayOutput) ToRepositoryPermissionsPolicyArrayOutput added in v3.25.0 

func (o RepositoryPermissionsPolicyArrayOutput) ToRepositoryPermissionsPolicyArrayOutput() RepositoryPermissionsPolicyArrayOutput

func (RepositoryPermissionsPolicyArrayOutput) ToRepositoryPermissionsPolicyArrayOutputWithContext added in v3.25.0 

func (o RepositoryPermissionsPolicyArrayOutput) ToRepositoryPermissionsPolicyArrayOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyArrayOutput

type RepositoryPermissionsPolicyInput added in v3.13.0 

type RepositoryPermissionsPolicyInput interface {
	pulumi.Input

	ToRepositoryPermissionsPolicyOutput() RepositoryPermissionsPolicyOutput
	ToRepositoryPermissionsPolicyOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyOutput
}

type RepositoryPermissionsPolicyMap added in v3.25.0 

type RepositoryPermissionsPolicyMap map[string]RepositoryPermissionsPolicyInput

func (RepositoryPermissionsPolicyMap) ElementType added in v3.25.0 

func (RepositoryPermissionsPolicyMap) ElementType() reflect.Type

func (RepositoryPermissionsPolicyMap) ToRepositoryPermissionsPolicyMapOutput added in v3.25.0 

func (i RepositoryPermissionsPolicyMap) ToRepositoryPermissionsPolicyMapOutput() RepositoryPermissionsPolicyMapOutput

func (RepositoryPermissionsPolicyMap) ToRepositoryPermissionsPolicyMapOutputWithContext added in v3.25.0 

func (i RepositoryPermissionsPolicyMap) ToRepositoryPermissionsPolicyMapOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyMapOutput

type RepositoryPermissionsPolicyMapInput added in v3.25.0 

type RepositoryPermissionsPolicyMapInput interface {
	pulumi.Input

	ToRepositoryPermissionsPolicyMapOutput() RepositoryPermissionsPolicyMapOutput
	ToRepositoryPermissionsPolicyMapOutputWithContext(context.Context) RepositoryPermissionsPolicyMapOutput
}

RepositoryPermissionsPolicyMapInput is an input type that accepts RepositoryPermissionsPolicyMap and RepositoryPermissionsPolicyMapOutput values. You can construct a concrete instance of `RepositoryPermissionsPolicyMapInput` via: 

RepositoryPermissionsPolicyMap{ "key": RepositoryPermissionsPolicyArgs{...} }

type RepositoryPermissionsPolicyMapOutput added in v3.25.0 

type RepositoryPermissionsPolicyMapOutput struct{ *pulumi.OutputState }

func (RepositoryPermissionsPolicyMapOutput) ElementType added in v3.25.0 

func (RepositoryPermissionsPolicyMapOutput) ElementType() reflect.Type

func (RepositoryPermissionsPolicyMapOutput) MapIndex added in v3.25.0 

func (o RepositoryPermissionsPolicyMapOutput) MapIndex(k pulumi.StringInput) RepositoryPermissionsPolicyOutput

func (RepositoryPermissionsPolicyMapOutput) ToRepositoryPermissionsPolicyMapOutput added in v3.25.0 

func (o RepositoryPermissionsPolicyMapOutput) ToRepositoryPermissionsPolicyMapOutput() RepositoryPermissionsPolicyMapOutput

func (RepositoryPermissionsPolicyMapOutput) ToRepositoryPermissionsPolicyMapOutputWithContext added in v3.25.0 

func (o RepositoryPermissionsPolicyMapOutput) ToRepositoryPermissionsPolicyMapOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyMapOutput

type RepositoryPermissionsPolicyOutput added in v3.13.0 

type RepositoryPermissionsPolicyOutput struct {
	*pulumi.OutputState
}

func (RepositoryPermissionsPolicyOutput) ElementType added in v3.13.0 

func (RepositoryPermissionsPolicyOutput) ElementType() reflect.Type

func (RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutput added in v3.13.0 

func (o RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutput() RepositoryPermissionsPolicyOutput

func (RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutputWithContext added in v3.13.0 

func (o RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyOutput

func (RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyPtrOutput added in v3.25.0 

func (o RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyPtrOutput() RepositoryPermissionsPolicyPtrOutput

func (RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyPtrOutputWithContext added in v3.25.0 

func (o RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyPtrOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyPtrOutput

type RepositoryPermissionsPolicyPtrInput added in v3.25.0 

type RepositoryPermissionsPolicyPtrInput interface {
	pulumi.Input

	ToRepositoryPermissionsPolicyPtrOutput() RepositoryPermissionsPolicyPtrOutput
	ToRepositoryPermissionsPolicyPtrOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyPtrOutput
}

type RepositoryPermissionsPolicyPtrOutput added in v3.25.0 

type RepositoryPermissionsPolicyPtrOutput struct {
	*pulumi.OutputState
}

func (RepositoryPermissionsPolicyPtrOutput) ElementType added in v3.25.0 

func (RepositoryPermissionsPolicyPtrOutput) ElementType() reflect.Type

func (RepositoryPermissionsPolicyPtrOutput) ToRepositoryPermissionsPolicyPtrOutput added in v3.25.0 

func (o RepositoryPermissionsPolicyPtrOutput) ToRepositoryPermissionsPolicyPtrOutput() RepositoryPermissionsPolicyPtrOutput

func (RepositoryPermissionsPolicyPtrOutput) ToRepositoryPermissionsPolicyPtrOutputWithContext added in v3.25.0 

func (o RepositoryPermissionsPolicyPtrOutput) ToRepositoryPermissionsPolicyPtrOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyPtrOutput

type RepositoryPermissionsPolicyState added in v3.7.0 

type RepositoryPermissionsPolicyState struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringPtrInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringPtrInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
	// The name of the repository to set the resource policy on.
	Repository pulumi.StringPtrInput
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringPtrInput
}

func (RepositoryPermissionsPolicyState) ElementType added in v3.7.0 

func (RepositoryPermissionsPolicyState) ElementType() reflect.Type

type RepositoryPtrInput added in v3.25.0 

type RepositoryPtrInput interface {
	pulumi.Input

	ToRepositoryPtrOutput() RepositoryPtrOutput
	ToRepositoryPtrOutputWithContext(ctx context.Context) RepositoryPtrOutput
}

type RepositoryPtrOutput added in v3.25.0 

type RepositoryPtrOutput struct {
	*pulumi.OutputState
}

func (RepositoryPtrOutput) ElementType added in v3.25.0 

func (RepositoryPtrOutput) ElementType() reflect.Type

func (RepositoryPtrOutput) ToRepositoryPtrOutput added in v3.25.0 

func (o RepositoryPtrOutput) ToRepositoryPtrOutput() RepositoryPtrOutput

func (RepositoryPtrOutput) ToRepositoryPtrOutputWithContext added in v3.25.0 

func (o RepositoryPtrOutput) ToRepositoryPtrOutputWithContext(ctx context.Context) RepositoryPtrOutput

type RepositoryState 

type RepositoryState struct {
	// The account number of the AWS account that manages the repository.
	AdministratorAccount pulumi.StringPtrInput
	// The ARN of the repository.
	Arn pulumi.StringPtrInput
	// The description of the repository.
	Description pulumi.StringPtrInput
	// The domain that contains the created repository.
	Domain pulumi.StringPtrInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// An array of external connections associated with the repository. Only one external connection can be set per repository. see External Connections.
	ExternalConnections RepositoryExternalConnectionsPtrInput
	// The name of the repository to create.
	Repository pulumi.StringPtrInput
	// Key-value map of resource tags.
	Tags pulumi.StringMapInput
	// A list of upstream repositories to associate with the repository. The order of the upstream repositories in the list determines their priority order when AWS CodeArtifact looks for a requested package version. see Upstream
	Upstreams RepositoryUpstreamArrayInput
}

func (RepositoryState) ElementType 

func (RepositoryState) ElementType() reflect.Type

type RepositoryUpstream 

type RepositoryUpstream struct {
	// The name of an upstream repository.
	RepositoryName string `pulumi:"repositoryName"`
}

type RepositoryUpstreamArgs 

type RepositoryUpstreamArgs struct {
	// The name of an upstream repository.
	RepositoryName pulumi.StringInput `pulumi:"repositoryName"`
}

func (RepositoryUpstreamArgs) ElementType 

func (RepositoryUpstreamArgs) ElementType() reflect.Type

func (RepositoryUpstreamArgs) ToRepositoryUpstreamOutput 

func (i RepositoryUpstreamArgs) ToRepositoryUpstreamOutput() RepositoryUpstreamOutput

func (RepositoryUpstreamArgs) ToRepositoryUpstreamOutputWithContext 

func (i RepositoryUpstreamArgs) ToRepositoryUpstreamOutputWithContext(ctx context.Context) RepositoryUpstreamOutput

type RepositoryUpstreamArray 

type RepositoryUpstreamArray []RepositoryUpstreamInput

func (RepositoryUpstreamArray) ElementType 

func (RepositoryUpstreamArray) ElementType() reflect.Type

func (RepositoryUpstreamArray) ToRepositoryUpstreamArrayOutput 

func (i RepositoryUpstreamArray) ToRepositoryUpstreamArrayOutput() RepositoryUpstreamArrayOutput

func (RepositoryUpstreamArray) ToRepositoryUpstreamArrayOutputWithContext 

func (i RepositoryUpstreamArray) ToRepositoryUpstreamArrayOutputWithContext(ctx context.Context) RepositoryUpstreamArrayOutput

type RepositoryUpstreamArrayInput 

type RepositoryUpstreamArrayInput interface {
	pulumi.Input

	ToRepositoryUpstreamArrayOutput() RepositoryUpstreamArrayOutput
	ToRepositoryUpstreamArrayOutputWithContext(context.Context) RepositoryUpstreamArrayOutput
}

RepositoryUpstreamArrayInput is an input type that accepts RepositoryUpstreamArray and RepositoryUpstreamArrayOutput values. You can construct a concrete instance of `RepositoryUpstreamArrayInput` via: 

RepositoryUpstreamArray{ RepositoryUpstreamArgs{...} }

type RepositoryUpstreamArrayOutput 

type RepositoryUpstreamArrayOutput struct{ *pulumi.OutputState }

func (RepositoryUpstreamArrayOutput) ElementType 

func (RepositoryUpstreamArrayOutput) ElementType() reflect.Type

func (RepositoryUpstreamArrayOutput) Index 

func (o RepositoryUpstreamArrayOutput) Index(i pulumi.IntInput) RepositoryUpstreamOutput

func (RepositoryUpstreamArrayOutput) ToRepositoryUpstreamArrayOutput 

func (o RepositoryUpstreamArrayOutput) ToRepositoryUpstreamArrayOutput() RepositoryUpstreamArrayOutput

func (RepositoryUpstreamArrayOutput) ToRepositoryUpstreamArrayOutputWithContext 

func (o RepositoryUpstreamArrayOutput) ToRepositoryUpstreamArrayOutputWithContext(ctx context.Context) RepositoryUpstreamArrayOutput

type RepositoryUpstreamInput 

type RepositoryUpstreamInput interface {
	pulumi.Input

	ToRepositoryUpstreamOutput() RepositoryUpstreamOutput
	ToRepositoryUpstreamOutputWithContext(context.Context) RepositoryUpstreamOutput
}

RepositoryUpstreamInput is an input type that accepts RepositoryUpstreamArgs and RepositoryUpstreamOutput values. You can construct a concrete instance of `RepositoryUpstreamInput` via: 

RepositoryUpstreamArgs{...}

type RepositoryUpstreamOutput 

type RepositoryUpstreamOutput struct{ *pulumi.OutputState }

func (RepositoryUpstreamOutput) ElementType 

func (RepositoryUpstreamOutput) ElementType() reflect.Type

func (RepositoryUpstreamOutput) RepositoryName 

func (o RepositoryUpstreamOutput) RepositoryName() pulumi.StringOutput

The name of an upstream repository.

func (RepositoryUpstreamOutput) ToRepositoryUpstreamOutput 

func (o RepositoryUpstreamOutput) ToRepositoryUpstreamOutput() RepositoryUpstreamOutput

func (RepositoryUpstreamOutput) ToRepositoryUpstreamOutputWithContext 

func (o RepositoryUpstreamOutput) ToRepositoryUpstreamOutputWithContext(ctx context.Context) RepositoryUpstreamOutput

Source Files

View all Source files

Jump to

Keyboard shortcuts

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