codeartifact

package
v4.38.1 Latest Latest
Warning

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

 Go to latest Published: Mar 10, 2022 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 the 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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a CodeArtifact Domain Resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v3/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 

func (*Domain) ElementType() reflect.Type

func (*Domain) ToDomainOutput 

func (i *Domain) ToDomainOutput() DomainOutput

func (*Domain) ToDomainOutputWithContext 

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

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Domain resource.

func (DomainArgs) ElementType 

func (DomainArgs) ElementType() reflect.Type

type DomainArray 

type DomainArray []DomainInput

func (DomainArray) ElementType 

func (DomainArray) ElementType() reflect.Type

func (DomainArray) ToDomainArrayOutput 

func (i DomainArray) ToDomainArrayOutput() DomainArrayOutput

func (DomainArray) ToDomainArrayOutputWithContext 

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

type DomainArrayInput 

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 

type DomainArrayOutput struct{ *pulumi.OutputState }

func (DomainArrayOutput) ElementType 

func (DomainArrayOutput) ElementType() reflect.Type

func (DomainArrayOutput) Index 

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

func (DomainArrayOutput) ToDomainArrayOutput 

func (o DomainArrayOutput) ToDomainArrayOutput() DomainArrayOutput

func (DomainArrayOutput) ToDomainArrayOutputWithContext 

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

type DomainInput 

type DomainInput interface {
	pulumi.Input

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

type DomainMap 

type DomainMap map[string]DomainInput

func (DomainMap) ElementType 

func (DomainMap) ElementType() reflect.Type

func (DomainMap) ToDomainMapOutput 

func (i DomainMap) ToDomainMapOutput() DomainMapOutput

func (DomainMap) ToDomainMapOutputWithContext 

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

type DomainMapInput 

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 

type DomainMapOutput struct{ *pulumi.OutputState }

func (DomainMapOutput) ElementType 

func (DomainMapOutput) ElementType() reflect.Type

func (DomainMapOutput) MapIndex 

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

func (DomainMapOutput) ToDomainMapOutput 

func (o DomainMapOutput) ToDomainMapOutput() DomainMapOutput

func (DomainMapOutput) ToDomainMapOutputWithContext 

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

type DomainOutput 

type DomainOutput struct{ *pulumi.OutputState }

func (DomainOutput) ElementType 

func (DomainOutput) ElementType() reflect.Type

func (DomainOutput) ToDomainOutput 

func (o DomainOutput) ToDomainOutput() DomainOutput

func (DomainOutput) ToDomainOutputWithContext 

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

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/v4/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v3/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 

func (*DomainPermissions) ElementType() reflect.Type

func (*DomainPermissions) ToDomainPermissionsOutput 

func (i *DomainPermissions) ToDomainPermissionsOutput() DomainPermissionsOutput

func (*DomainPermissions) ToDomainPermissionsOutputWithContext 

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

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 

type DomainPermissionsArray []DomainPermissionsInput

func (DomainPermissionsArray) ElementType 

func (DomainPermissionsArray) ElementType() reflect.Type

func (DomainPermissionsArray) ToDomainPermissionsArrayOutput 

func (i DomainPermissionsArray) ToDomainPermissionsArrayOutput() DomainPermissionsArrayOutput

func (DomainPermissionsArray) ToDomainPermissionsArrayOutputWithContext 

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

type DomainPermissionsArrayInput 

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 

type DomainPermissionsArrayOutput struct{ *pulumi.OutputState }

func (DomainPermissionsArrayOutput) ElementType 

func (DomainPermissionsArrayOutput) ElementType() reflect.Type

func (DomainPermissionsArrayOutput) Index 

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

func (DomainPermissionsArrayOutput) ToDomainPermissionsArrayOutput 

func (o DomainPermissionsArrayOutput) ToDomainPermissionsArrayOutput() DomainPermissionsArrayOutput

func (DomainPermissionsArrayOutput) ToDomainPermissionsArrayOutputWithContext 

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

type DomainPermissionsInput 

type DomainPermissionsInput interface {
	pulumi.Input

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

type DomainPermissionsMap 

type DomainPermissionsMap map[string]DomainPermissionsInput

func (DomainPermissionsMap) ElementType 

func (DomainPermissionsMap) ElementType() reflect.Type

func (DomainPermissionsMap) ToDomainPermissionsMapOutput 

func (i DomainPermissionsMap) ToDomainPermissionsMapOutput() DomainPermissionsMapOutput

func (DomainPermissionsMap) ToDomainPermissionsMapOutputWithContext 

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

type DomainPermissionsMapInput 

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 

type DomainPermissionsMapOutput struct{ *pulumi.OutputState }

func (DomainPermissionsMapOutput) ElementType 

func (DomainPermissionsMapOutput) ElementType() reflect.Type

func (DomainPermissionsMapOutput) MapIndex 

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

func (DomainPermissionsMapOutput) ToDomainPermissionsMapOutput 

func (o DomainPermissionsMapOutput) ToDomainPermissionsMapOutput() DomainPermissionsMapOutput

func (DomainPermissionsMapOutput) ToDomainPermissionsMapOutputWithContext 

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

type DomainPermissionsOutput 

type DomainPermissionsOutput struct{ *pulumi.OutputState }

func (DomainPermissionsOutput) ElementType 

func (DomainPermissionsOutput) ElementType() reflect.Type

func (DomainPermissionsOutput) ToDomainPermissionsOutput 

func (o DomainPermissionsOutput) ToDomainPermissionsOutput() DomainPermissionsOutput

func (DomainPermissionsOutput) ToDomainPermissionsOutputWithContext 

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

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 DomainState 

type DomainState struct {
	// The ARN of the 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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapInput
}

func (DomainState) ElementType 

func (DomainState) ElementType() reflect.Type

type GetAuthorizationTokenArgs 

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 GetAuthorizationTokenOutputArgs added in v4.21.0 

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

A collection of arguments for invoking getAuthorizationToken.

func (GetAuthorizationTokenOutputArgs) ElementType added in v4.21.0 

func (GetAuthorizationTokenOutputArgs) ElementType() reflect.Type

type GetAuthorizationTokenResult 

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 

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/v4/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v3/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 GetAuthorizationTokenResultOutput added in v4.21.0 

type GetAuthorizationTokenResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getAuthorizationToken.

func GetAuthorizationTokenOutput added in v4.21.0 

func GetAuthorizationTokenOutput(ctx *pulumi.Context, args GetAuthorizationTokenOutputArgs, opts ...pulumi.InvokeOption) GetAuthorizationTokenResultOutput

func (GetAuthorizationTokenResultOutput) AuthorizationToken added in v4.21.0 

func (o GetAuthorizationTokenResultOutput) AuthorizationToken() pulumi.StringOutput

Temporary authorization token.

func (GetAuthorizationTokenResultOutput) Domain added in v4.21.0 

func (o GetAuthorizationTokenResultOutput) Domain() pulumi.StringOutput

func (GetAuthorizationTokenResultOutput) DomainOwner added in v4.21.0 

func (o GetAuthorizationTokenResultOutput) DomainOwner() pulumi.StringOutput

func (GetAuthorizationTokenResultOutput) DurationSeconds added in v4.21.0 

func (o GetAuthorizationTokenResultOutput) DurationSeconds() pulumi.IntPtrOutput

func (GetAuthorizationTokenResultOutput) ElementType added in v4.21.0 

func (GetAuthorizationTokenResultOutput) ElementType() reflect.Type

func (GetAuthorizationTokenResultOutput) Expiration added in v4.21.0 

func (o GetAuthorizationTokenResultOutput) Expiration() pulumi.StringOutput

The time in UTC RFC3339 format when the authorization token expires.

func (GetAuthorizationTokenResultOutput) Id added in v4.21.0 

func (o GetAuthorizationTokenResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetAuthorizationTokenResultOutput) ToGetAuthorizationTokenResultOutput added in v4.21.0 

func (o GetAuthorizationTokenResultOutput) ToGetAuthorizationTokenResultOutput() GetAuthorizationTokenResultOutput

func (GetAuthorizationTokenResultOutput) ToGetAuthorizationTokenResultOutputWithContext added in v4.21.0 

func (o GetAuthorizationTokenResultOutput) ToGetAuthorizationTokenResultOutputWithContext(ctx context.Context) GetAuthorizationTokenResultOutput

type GetRepositoryEndpointArgs 

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 GetRepositoryEndpointOutputArgs added in v4.21.0 

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

A collection of arguments for invoking getRepositoryEndpoint.

func (GetRepositoryEndpointOutputArgs) ElementType added in v4.21.0 

func (GetRepositoryEndpointOutputArgs) ElementType() reflect.Type

type GetRepositoryEndpointResult 

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 

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/v4/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v3/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 GetRepositoryEndpointResultOutput added in v4.21.0 

type GetRepositoryEndpointResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getRepositoryEndpoint.

func GetRepositoryEndpointOutput added in v4.21.0 

func GetRepositoryEndpointOutput(ctx *pulumi.Context, args GetRepositoryEndpointOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryEndpointResultOutput

func (GetRepositoryEndpointResultOutput) Domain added in v4.21.0 

func (o GetRepositoryEndpointResultOutput) Domain() pulumi.StringOutput

func (GetRepositoryEndpointResultOutput) DomainOwner added in v4.21.0 

func (o GetRepositoryEndpointResultOutput) DomainOwner() pulumi.StringOutput

func (GetRepositoryEndpointResultOutput) ElementType added in v4.21.0 

func (GetRepositoryEndpointResultOutput) ElementType() reflect.Type

func (GetRepositoryEndpointResultOutput) Format added in v4.21.0 

func (o GetRepositoryEndpointResultOutput) Format() pulumi.StringOutput

func (GetRepositoryEndpointResultOutput) Id added in v4.21.0 

func (o GetRepositoryEndpointResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetRepositoryEndpointResultOutput) Repository added in v4.21.0 

func (o GetRepositoryEndpointResultOutput) Repository() pulumi.StringOutput

func (GetRepositoryEndpointResultOutput) RepositoryEndpoint added in v4.21.0 

func (o GetRepositoryEndpointResultOutput) RepositoryEndpoint() pulumi.StringOutput

The URL of the returned endpoint.

func (GetRepositoryEndpointResultOutput) ToGetRepositoryEndpointResultOutput added in v4.21.0 

func (o GetRepositoryEndpointResultOutput) ToGetRepositoryEndpointResultOutput() GetRepositoryEndpointResultOutput

func (GetRepositoryEndpointResultOutput) ToGetRepositoryEndpointResultOutputWithContext added in v4.21.0 

func (o GetRepositoryEndpointResultOutput) ToGetRepositoryEndpointResultOutputWithContext(ctx context.Context) GetRepositoryEndpointResultOutput

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// 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/v4/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v3/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 

func (*Repository) ElementType() reflect.Type

func (*Repository) ToRepositoryOutput 

func (i *Repository) ToRepositoryOutput() RepositoryOutput

func (*Repository) ToRepositoryOutputWithContext 

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

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A 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 

type RepositoryArray []RepositoryInput

func (RepositoryArray) ElementType 

func (RepositoryArray) ElementType() reflect.Type

func (RepositoryArray) ToRepositoryArrayOutput 

func (i RepositoryArray) ToRepositoryArrayOutput() RepositoryArrayOutput

func (RepositoryArray) ToRepositoryArrayOutputWithContext 

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

type RepositoryArrayInput 

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 

type RepositoryArrayOutput struct{ *pulumi.OutputState }

func (RepositoryArrayOutput) ElementType 

func (RepositoryArrayOutput) ElementType() reflect.Type

func (RepositoryArrayOutput) Index 

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

func (RepositoryArrayOutput) ToRepositoryArrayOutput 

func (o RepositoryArrayOutput) ToRepositoryArrayOutput() RepositoryArrayOutput

func (RepositoryArrayOutput) ToRepositoryArrayOutputWithContext 

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

type RepositoryExternalConnections 

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 

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 

func (RepositoryExternalConnectionsArgs) ElementType() reflect.Type

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutput 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutput() RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutputWithContext 

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

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutput 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutputWithContext 

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

type RepositoryExternalConnectionsInput 

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 

type RepositoryExternalConnectionsOutput struct{ *pulumi.OutputState }

func (RepositoryExternalConnectionsOutput) ElementType 

func (RepositoryExternalConnectionsOutput) ElementType() reflect.Type

func (RepositoryExternalConnectionsOutput) ExternalConnectionName 

func (o RepositoryExternalConnectionsOutput) ExternalConnectionName() pulumi.StringOutput

The name of the external connection associated with a repository.

func (RepositoryExternalConnectionsOutput) PackageFormat 

func (o RepositoryExternalConnectionsOutput) PackageFormat() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsOutput) Status 

func (o RepositoryExternalConnectionsOutput) Status() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutput 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutput() RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutputWithContext 

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

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutput 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutputWithContext 

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

type RepositoryExternalConnectionsPtrInput 

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 

func RepositoryExternalConnectionsPtr(v *RepositoryExternalConnectionsArgs) RepositoryExternalConnectionsPtrInput

type RepositoryExternalConnectionsPtrOutput 

type RepositoryExternalConnectionsPtrOutput struct{ *pulumi.OutputState }

func (RepositoryExternalConnectionsPtrOutput) Elem 

func (o RepositoryExternalConnectionsPtrOutput) Elem() RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsPtrOutput) ElementType 

func (RepositoryExternalConnectionsPtrOutput) ElementType() reflect.Type

func (RepositoryExternalConnectionsPtrOutput) ExternalConnectionName 

func (o RepositoryExternalConnectionsPtrOutput) ExternalConnectionName() pulumi.StringPtrOutput

The name of the external connection associated with a repository.

func (RepositoryExternalConnectionsPtrOutput) PackageFormat 

func (o RepositoryExternalConnectionsPtrOutput) PackageFormat() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsPtrOutput) Status 

func (o RepositoryExternalConnectionsPtrOutput) Status() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutput 

func (o RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput

func (RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutputWithContext 

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

type RepositoryInput 

type RepositoryInput interface {
	pulumi.Input

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

type RepositoryMap 

type RepositoryMap map[string]RepositoryInput

func (RepositoryMap) ElementType 

func (RepositoryMap) ElementType() reflect.Type

func (RepositoryMap) ToRepositoryMapOutput 

func (i RepositoryMap) ToRepositoryMapOutput() RepositoryMapOutput

func (RepositoryMap) ToRepositoryMapOutputWithContext 

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

type RepositoryMapInput 

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 

type RepositoryMapOutput struct{ *pulumi.OutputState }

func (RepositoryMapOutput) ElementType 

func (RepositoryMapOutput) ElementType() reflect.Type

func (RepositoryMapOutput) MapIndex 

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

func (RepositoryMapOutput) ToRepositoryMapOutput 

func (o RepositoryMapOutput) ToRepositoryMapOutput() RepositoryMapOutput

func (RepositoryMapOutput) ToRepositoryMapOutputWithContext 

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

type RepositoryOutput 

type RepositoryOutput struct{ *pulumi.OutputState }

func (RepositoryOutput) ElementType 

func (RepositoryOutput) ElementType() reflect.Type

func (RepositoryOutput) ToRepositoryOutput 

func (o RepositoryOutput) ToRepositoryOutput() RepositoryOutput

func (RepositoryOutput) ToRepositoryOutputWithContext 

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

type RepositoryPermissionsPolicy 

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/v4/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v3/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 

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 

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 

func (*RepositoryPermissionsPolicy) ElementType() reflect.Type

func (*RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutput 

func (i *RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutput() RepositoryPermissionsPolicyOutput

func (*RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutputWithContext 

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

type RepositoryPermissionsPolicyArgs 

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 

func (RepositoryPermissionsPolicyArgs) ElementType() reflect.Type

type RepositoryPermissionsPolicyArray 

type RepositoryPermissionsPolicyArray []RepositoryPermissionsPolicyInput

func (RepositoryPermissionsPolicyArray) ElementType 

func (RepositoryPermissionsPolicyArray) ElementType() reflect.Type

func (RepositoryPermissionsPolicyArray) ToRepositoryPermissionsPolicyArrayOutput 

func (i RepositoryPermissionsPolicyArray) ToRepositoryPermissionsPolicyArrayOutput() RepositoryPermissionsPolicyArrayOutput

func (RepositoryPermissionsPolicyArray) ToRepositoryPermissionsPolicyArrayOutputWithContext 

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

type RepositoryPermissionsPolicyArrayInput 

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 

type RepositoryPermissionsPolicyArrayOutput struct{ *pulumi.OutputState }

func (RepositoryPermissionsPolicyArrayOutput) ElementType 

func (RepositoryPermissionsPolicyArrayOutput) ElementType() reflect.Type

func (RepositoryPermissionsPolicyArrayOutput) Index 

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

func (RepositoryPermissionsPolicyArrayOutput) ToRepositoryPermissionsPolicyArrayOutput 

func (o RepositoryPermissionsPolicyArrayOutput) ToRepositoryPermissionsPolicyArrayOutput() RepositoryPermissionsPolicyArrayOutput

func (RepositoryPermissionsPolicyArrayOutput) ToRepositoryPermissionsPolicyArrayOutputWithContext 

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

type RepositoryPermissionsPolicyInput 

type RepositoryPermissionsPolicyInput interface {
	pulumi.Input

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

type RepositoryPermissionsPolicyMap 

type RepositoryPermissionsPolicyMap map[string]RepositoryPermissionsPolicyInput

func (RepositoryPermissionsPolicyMap) ElementType 

func (RepositoryPermissionsPolicyMap) ElementType() reflect.Type

func (RepositoryPermissionsPolicyMap) ToRepositoryPermissionsPolicyMapOutput 

func (i RepositoryPermissionsPolicyMap) ToRepositoryPermissionsPolicyMapOutput() RepositoryPermissionsPolicyMapOutput

func (RepositoryPermissionsPolicyMap) ToRepositoryPermissionsPolicyMapOutputWithContext 

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

type RepositoryPermissionsPolicyMapInput 

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 

type RepositoryPermissionsPolicyMapOutput struct{ *pulumi.OutputState }

func (RepositoryPermissionsPolicyMapOutput) ElementType 

func (RepositoryPermissionsPolicyMapOutput) ElementType() reflect.Type

func (RepositoryPermissionsPolicyMapOutput) MapIndex 

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

func (RepositoryPermissionsPolicyMapOutput) ToRepositoryPermissionsPolicyMapOutput 

func (o RepositoryPermissionsPolicyMapOutput) ToRepositoryPermissionsPolicyMapOutput() RepositoryPermissionsPolicyMapOutput

func (RepositoryPermissionsPolicyMapOutput) ToRepositoryPermissionsPolicyMapOutputWithContext 

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

type RepositoryPermissionsPolicyOutput 

type RepositoryPermissionsPolicyOutput struct{ *pulumi.OutputState }

func (RepositoryPermissionsPolicyOutput) ElementType 

func (RepositoryPermissionsPolicyOutput) ElementType() reflect.Type

func (RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutput 

func (o RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutput() RepositoryPermissionsPolicyOutput

func (RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutputWithContext 

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

type RepositoryPermissionsPolicyState 

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 

func (RepositoryPermissionsPolicyState) ElementType() reflect.Type

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll 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.