Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that CodeArtifact can respond with.

Structs

AssetSummary

Contains details about a package version asset.

AssociatedPackage

A package associated with a package group.

DomainDescription

Information about a domain. A domain is a container for repositories. When you create a domain, it is empty until you add one or more repositories.

DomainEntryPoint

Information about how a package originally entered the CodeArtifact domain. For packages published directly to CodeArtifact, the entry point is the repository it was published to. For packages ingested from an external repository, the entry point is the external connection that it was ingested from. An external connection is a CodeArtifact repository that is connected to an external repository such as the npm registry or NuGet gallery.

If a package version exists in a repository and is updated, for example if a package of the same version is added with additional assets, the package version's DomainEntryPoint will not change from the original package version's value.

DomainSummary

Information about a domain, including its name, Amazon Resource Name (ARN), and status. The ListDomains operation returns a list of DomainSummary objects.

LicenseInfo

Details of the license data.

PackageDependency

Details about a package dependency.

PackageDescription

Details about a package.

PackageGroupAllowedRepository

Details about an allowed repository for a package group, including its name and origin configuration.

PackageGroupDescription

The description of the package group.

PackageGroupOriginConfiguration

The package group origin configuration that determines how package versions can enter repositories.

PackageGroupOriginRestriction

Contains information about the configured restrictions of the origin controls of a package group.

PackageGroupReference

Information about the identifiers of a package group.

PackageGroupSummary

Details about a package group.

PackageOriginConfiguration

Details about the package origin configuration of a package.

PackageOriginRestrictions

Details about the origin restrictions set on the package. The package origin restrictions determine how new versions of a package can be added to a specific repository.

PackageSummary

Details about a package, including its format, namespace, and name.

PackageVersionDescription

Details about a package version.

PackageVersionError

l An error associated with package.

PackageVersionOrigin

Information about how a package version was added to a repository.

PackageVersionSummary

Details about a package version, including its status, version, and revision. The ListPackageVersions operation returns a list of PackageVersionSummary objects.

RepositoryDescription

The details of a repository stored in CodeArtifact. A CodeArtifact repository contains a set of package versions, each of which maps to a set of assets. Repositories are polyglot—a single repository can contain packages of any supported type. Each repository exposes endpoints for fetching and publishing packages using tools like the npm CLI, the Maven CLI (mvn), and pip. You can create up to 100 repositories per Amazon Web Services account.

RepositoryExternalConnectionInfo

Contains information about the external connection of a repository.

RepositorySummary

Details about a repository, including its Amazon Resource Name (ARN), description, and domain information. The ListRepositories operation returns a list of RepositorySummary objects.

ResourcePolicy

An CodeArtifact resource policy that contains a resource ARN, document details, and a revision.

SuccessfulPackageVersionInfo

Contains the revision and status of a package version.

Tag

A tag is a key-value pair that can be used to manage, search for, or filter resources in CodeArtifact.

UpstreamRepository

Information about an upstream repository. A list of UpstreamRepository objects is an input parameter to CreateRepository and UpdateRepository.

UpstreamRepositoryInfo

Information about an upstream repository.

Enums

AllowPublish

When writing a match expression against AllowPublish, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AllowUpstream

When writing a match expression against AllowUpstream, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DomainStatus

When writing a match expression against DomainStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EndpointType

When writing a match expression against EndpointType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExternalConnectionStatus

When writing a match expression against ExternalConnectionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

HashAlgorithm

When writing a match expression against HashAlgorithm, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageFormat

When writing a match expression against PackageFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageGroupAllowedRepositoryUpdateType

When writing a match expression against PackageGroupAllowedRepositoryUpdateType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageGroupAssociationType

When writing a match expression against PackageGroupAssociationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageGroupOriginRestrictionMode

When writing a match expression against PackageGroupOriginRestrictionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageGroupOriginRestrictionType

When writing a match expression against PackageGroupOriginRestrictionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageVersionErrorCode

When writing a match expression against PackageVersionErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageVersionOriginType

When writing a match expression against PackageVersionOriginType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageVersionSortType

When writing a match expression against PackageVersionSortType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageVersionStatus

When writing a match expression against PackageVersionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceType

When writing a match expression against ResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ValidationExceptionReason

When writing a match expression against ValidationExceptionReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.