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 (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 (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) Index

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 (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

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 (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 (GetAuthorizationTokenResultOutput) DomainOwner added in v4.21.0

func (GetAuthorizationTokenResultOutput) DurationSeconds added in v4.21.0

func (GetAuthorizationTokenResultOutput) ElementType added in v4.21.0

func (GetAuthorizationTokenResultOutput) Expiration added in v4.21.0

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

func (GetAuthorizationTokenResultOutput) Id added in v4.21.0

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

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 (GetRepositoryEndpointResultOutput) Domain added in v4.21.0

func (GetRepositoryEndpointResultOutput) DomainOwner added in v4.21.0

func (GetRepositoryEndpointResultOutput) ElementType added in v4.21.0

func (GetRepositoryEndpointResultOutput) Format added in v4.21.0

func (GetRepositoryEndpointResultOutput) Id added in v4.21.0

The provider-assigned unique ID for this managed resource.

func (GetRepositoryEndpointResultOutput) Repository added in v4.21.0

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 (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) 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) ExternalConnectionName

func (o RepositoryExternalConnectionsOutput) ExternalConnectionName() pulumi.StringOutput

The name of the external connection associated with a repository.

func (RepositoryExternalConnectionsOutput) PackageFormat

func (RepositoryExternalConnectionsOutput) Status

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

type RepositoryExternalConnectionsPtrOutput

type RepositoryExternalConnectionsPtrOutput struct{ *pulumi.OutputState }

func (RepositoryExternalConnectionsPtrOutput) Elem

func (RepositoryExternalConnectionsPtrOutput) ElementType

func (RepositoryExternalConnectionsPtrOutput) ExternalConnectionName

The name of the external connection associated with a repository.

func (RepositoryExternalConnectionsPtrOutput) PackageFormat

func (RepositoryExternalConnectionsPtrOutput) Status

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 (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

type RepositoryPermissionsPolicyArray

type RepositoryPermissionsPolicyArray []RepositoryPermissionsPolicyInput

func (RepositoryPermissionsPolicyArray) ElementType

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) Index

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) 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) MapIndex

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) 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

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) Index

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

Jump to

Keyboard shortcuts

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