Module aws_sdk_codeartifact::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.

• 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.
• 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.