Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException

type AccessDeniedException struct {
	Message *string
}

    The operation did not succeed because of an unauthorized access attempt.

    func (*AccessDeniedException) Error

    func (e *AccessDeniedException) Error() string

    func (*AccessDeniedException) ErrorCode

    func (e *AccessDeniedException) ErrorCode() string

    func (*AccessDeniedException) ErrorFault

    func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

    func (*AccessDeniedException) ErrorMessage

    func (e *AccessDeniedException) ErrorMessage() string

    type AssetSummary

    type AssetSummary struct {
    
    	// The name of the asset.
    	//
    	// This member is required.
    	Name *string
    
    	// The hashes of the asset.
    	Hashes map[string]string
    
    	// The size of the asset.
    	Size *int64
    }

      Contains details about a package version asset.

      type ConflictException

      type ConflictException struct {
      	Message *string
      
      	ResourceId   *string
      	ResourceType ResourceType
      }

        The operation did not succeed because prerequisites are not met.

        func (*ConflictException) Error

        func (e *ConflictException) Error() string

        func (*ConflictException) ErrorCode

        func (e *ConflictException) ErrorCode() string

        func (*ConflictException) ErrorFault

        func (e *ConflictException) ErrorFault() smithy.ErrorFault

        func (*ConflictException) ErrorMessage

        func (e *ConflictException) ErrorMessage() string

        type DomainDescription

        type DomainDescription struct {
        
        	// The Amazon Resource Name (ARN) of the domain.
        	Arn *string
        
        	// The total size of all assets in the domain.
        	AssetSizeBytes int64
        
        	// A timestamp that represents the date and time the domain was created.
        	CreatedTime *time.Time
        
        	// The ARN of an AWS Key Management Service (AWS KMS) key associated with a domain.
        	EncryptionKey *string
        
        	// The name of the domain.
        	Name *string
        
        	// The AWS account ID that owns the domain.
        	Owner *string
        
        	// The number of repositories in the domain.
        	RepositoryCount int32
        
        	// The Amazon Resource Name (ARN) of the Amazon S3 bucket that is used to store
        	// package assets in the domain.
        	S3BucketArn *string
        
        	// The current status of a domain. The valid values are
        	//
        	// * Active
        	//
        	// * Deleted
        	Status DomainStatus
        }

          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.

          type DomainStatus

          type DomainStatus string
          const (
          	DomainStatusActive  DomainStatus = "Active"
          	DomainStatusDeleted DomainStatus = "Deleted"
          )

            Enum values for DomainStatus

            func (DomainStatus) Values

            func (DomainStatus) Values() []DomainStatus

              Values returns all known values for DomainStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

              type DomainSummary

              type DomainSummary struct {
              
              	// The ARN of the domain.
              	Arn *string
              
              	// A timestamp that contains the date and time the domain was created.
              	CreatedTime *time.Time
              
              	// The key used to encrypt the domain.
              	EncryptionKey *string
              
              	// The name of the domain.
              	Name *string
              
              	// The 12-digit account number of the AWS account that owns the domain. It does not
              	// include dashes or spaces.
              	Owner *string
              
              	// A string that contains the status of the domain. The valid values are:
              	//
              	// *
              	// Active
              	//
              	// * Deleted
              	Status DomainStatus
              }

                Information about a domain, including its name, Amazon Resource Name (ARN), and status. The ListDomains (https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListDomains.html) operation returns a list of DomainSummary objects.

                type ExternalConnectionStatus

                type ExternalConnectionStatus string
                const (
                	ExternalConnectionStatusAvailable ExternalConnectionStatus = "Available"
                )

                  Enum values for ExternalConnectionStatus

                  func (ExternalConnectionStatus) Values

                    Values returns all known values for ExternalConnectionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                    type HashAlgorithm

                    type HashAlgorithm string
                    const (
                    	HashAlgorithmMd5    HashAlgorithm = "MD5"
                    	HashAlgorithmSha1   HashAlgorithm = "SHA-1"
                    	HashAlgorithmSha256 HashAlgorithm = "SHA-256"
                    	HashAlgorithmSha512 HashAlgorithm = "SHA-512"
                    )

                      Enum values for HashAlgorithm

                      func (HashAlgorithm) Values

                      func (HashAlgorithm) Values() []HashAlgorithm

                        Values returns all known values for HashAlgorithm. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                        type InternalServerException

                        type InternalServerException struct {
                        	Message *string
                        }

                          The operation did not succeed because of an error that occurred inside AWS CodeArtifact.

                          func (*InternalServerException) Error

                          func (e *InternalServerException) Error() string

                          func (*InternalServerException) ErrorCode

                          func (e *InternalServerException) ErrorCode() string

                          func (*InternalServerException) ErrorFault

                          func (e *InternalServerException) ErrorFault() smithy.ErrorFault

                          func (*InternalServerException) ErrorMessage

                          func (e *InternalServerException) ErrorMessage() string

                          type LicenseInfo

                          type LicenseInfo struct {
                          
                          	// Name of the license.
                          	Name *string
                          
                          	// The URL for license data.
                          	Url *string
                          }

                            Details of the license data.

                            type PackageDependency

                            type PackageDependency struct {
                            
                            	// The type of a package dependency. The possible values depend on the package
                            	// type. Example types are compile, runtime, and test for Maven packages, and dev,
                            	// prod, and optional for npm packages.
                            	DependencyType *string
                            
                            	// The namespace of the package. The package component that specifies its namespace
                            	// depends on its type. For example:
                            	//
                            	// * The namespace of a Maven package is its
                            	// groupId.
                            	//
                            	// * The namespace of an npm package is its scope.
                            	//
                            	// * A Python package
                            	// does not contain a corresponding component, so Python packages do not have a
                            	// namespace.
                            	//
                            	// * A NuGet package does not contain a corresponding component, so
                            	// NuGet packages do not have a namespace.
                            	Namespace *string
                            
                            	// The name of the package that this package depends on.
                            	Package *string
                            
                            	// The required version, or version range, of the package that this package depends
                            	// on. The version format is specific to the package type. For example, the
                            	// following are possible valid required versions: 1.2.3, ^2.3.4, or 4.x.
                            	VersionRequirement *string
                            }

                              Details about a package dependency.

                              type PackageFormat

                              type PackageFormat string
                              const (
                              	PackageFormatNpm   PackageFormat = "npm"
                              	PackageFormatPypi  PackageFormat = "pypi"
                              	PackageFormatMaven PackageFormat = "maven"
                              	PackageFormatNuget PackageFormat = "nuget"
                              )

                                Enum values for PackageFormat

                                func (PackageFormat) Values

                                func (PackageFormat) Values() []PackageFormat

                                  Values returns all known values for PackageFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                  type PackageSummary

                                  type PackageSummary struct {
                                  
                                  	// The format of the package. Valid values are:
                                  	//
                                  	// * npm
                                  	//
                                  	// * pypi
                                  	//
                                  	// * maven
                                  	//
                                  	// * nuget
                                  	Format PackageFormat
                                  
                                  	// The namespace of the package. The package component that specifies its namespace
                                  	// depends on its type. For example:
                                  	//
                                  	// * The namespace of a Maven package is its
                                  	// groupId.
                                  	//
                                  	// * The namespace of an npm package is its scope.
                                  	//
                                  	// * A Python package
                                  	// does not contain a corresponding component, so Python packages do not have a
                                  	// namespace.
                                  	//
                                  	// * A NuGet package does not contain a corresponding component, so
                                  	// NuGet packages do not have a namespace.
                                  	Namespace *string
                                  
                                  	// The name of the package.
                                  	Package *string
                                  }

                                    Details about a package, including its format, namespace, and name. The ListPackages (https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackages.html) operation returns a list of PackageSummary objects.

                                    type PackageVersionDescription

                                    type PackageVersionDescription struct {
                                    
                                    	// The name of the package that is displayed. The displayName varies depending on
                                    	// the package version's format. For example, if an npm package is named ui, is in
                                    	// the namespace vue, and has the format npm, then the displayName is @vue/ui.
                                    	DisplayName *string
                                    
                                    	// The format of the package version. The valid package formats are:
                                    	//
                                    	// * npm: A Node
                                    	// Package Manager (npm) package.
                                    	//
                                    	// * pypi: A Python Package Index (PyPI)
                                    	// package.
                                    	//
                                    	// * maven: A Maven package that contains compiled code in a
                                    	// distributable format, such as a JAR file.
                                    	//
                                    	// * nuget: A NuGet package.
                                    	Format PackageFormat
                                    
                                    	// The homepage associated with the package.
                                    	HomePage *string
                                    
                                    	// Information about licenses associated with the package version.
                                    	Licenses []LicenseInfo
                                    
                                    	// The namespace of the package. The package component that specifies its namespace
                                    	// depends on its type. For example:
                                    	//
                                    	// * The namespace of a Maven package is its
                                    	// groupId.
                                    	//
                                    	// * The namespace of an npm package is its scope.
                                    	//
                                    	// * A Python package
                                    	// does not contain a corresponding component, so Python packages do not have a
                                    	// namespace.
                                    	//
                                    	// * A NuGet package does not contain a corresponding component, so
                                    	// NuGet packages do not have a namespace.
                                    	Namespace *string
                                    
                                    	// The name of the requested package.
                                    	PackageName *string
                                    
                                    	// A timestamp that contains the date and time the package version was published.
                                    	PublishedTime *time.Time
                                    
                                    	// The revision of the package version.
                                    	Revision *string
                                    
                                    	// The repository for the source code in the package version, or the source code
                                    	// used to build it.
                                    	SourceCodeRepository *string
                                    
                                    	// A string that contains the status of the package version. It can be one of the
                                    	// following:
                                    	//
                                    	// * Published
                                    	//
                                    	// * Unfinished
                                    	//
                                    	// * Unlisted
                                    	//
                                    	// * Archived
                                    	//
                                    	// * Disposed
                                    	Status PackageVersionStatus
                                    
                                    	// A summary of the package version. The summary is extracted from the package. The
                                    	// information in and detail level of the summary depends on the package version's
                                    	// format.
                                    	Summary *string
                                    
                                    	// The version of the package.
                                    	Version *string
                                    }

                                      Details about a package version.

                                      type PackageVersionError

                                      type PackageVersionError struct {
                                      
                                      	// The error code associated with the error. Valid error codes are:
                                      	//
                                      	// *
                                      	// ALREADY_EXISTS
                                      	//
                                      	// * MISMATCHED_REVISION
                                      	//
                                      	// * MISMATCHED_STATUS
                                      	//
                                      	// * NOT_ALLOWED
                                      	//
                                      	// *
                                      	// NOT_FOUND
                                      	//
                                      	// * SKIPPED
                                      	ErrorCode PackageVersionErrorCode
                                      
                                      	// The error message associated with the error.
                                      	ErrorMessage *string
                                      }

                                        An error associated with package.

                                        type PackageVersionErrorCode

                                        type PackageVersionErrorCode string
                                        const (
                                        	PackageVersionErrorCodeAlreadyExists      PackageVersionErrorCode = "ALREADY_EXISTS"
                                        	PackageVersionErrorCodeMismatchedRevision PackageVersionErrorCode = "MISMATCHED_REVISION"
                                        	PackageVersionErrorCodeMismatchedStatus   PackageVersionErrorCode = "MISMATCHED_STATUS"
                                        	PackageVersionErrorCodeNotAllowed         PackageVersionErrorCode = "NOT_ALLOWED"
                                        	PackageVersionErrorCodeNotFound           PackageVersionErrorCode = "NOT_FOUND"
                                        	PackageVersionErrorCodeSkipped            PackageVersionErrorCode = "SKIPPED"
                                        )

                                          Enum values for PackageVersionErrorCode

                                          func (PackageVersionErrorCode) Values

                                            Values returns all known values for PackageVersionErrorCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                            type PackageVersionSortType

                                            type PackageVersionSortType string
                                            const (
                                            	PackageVersionSortTypePublishedTime PackageVersionSortType = "PUBLISHED_TIME"
                                            )

                                              Enum values for PackageVersionSortType

                                              func (PackageVersionSortType) Values

                                                Values returns all known values for PackageVersionSortType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                type PackageVersionStatus

                                                type PackageVersionStatus string
                                                const (
                                                	PackageVersionStatusPublished  PackageVersionStatus = "Published"
                                                	PackageVersionStatusUnfinished PackageVersionStatus = "Unfinished"
                                                	PackageVersionStatusUnlisted   PackageVersionStatus = "Unlisted"
                                                	PackageVersionStatusArchived   PackageVersionStatus = "Archived"
                                                	PackageVersionStatusDisposed   PackageVersionStatus = "Disposed"
                                                	PackageVersionStatusDeleted    PackageVersionStatus = "Deleted"
                                                )

                                                  Enum values for PackageVersionStatus

                                                  func (PackageVersionStatus) Values

                                                    Values returns all known values for PackageVersionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                    type PackageVersionSummary

                                                    type PackageVersionSummary struct {
                                                    
                                                    	// A string that contains the status of the package version. It can be one of the
                                                    	// following:
                                                    	//
                                                    	// * Published
                                                    	//
                                                    	// * Unfinished
                                                    	//
                                                    	// * Unlisted
                                                    	//
                                                    	// * Archived
                                                    	//
                                                    	// * Disposed
                                                    	//
                                                    	// This member is required.
                                                    	Status PackageVersionStatus
                                                    
                                                    	// Information about a package version.
                                                    	//
                                                    	// This member is required.
                                                    	Version *string
                                                    
                                                    	// The revision associated with a package version.
                                                    	Revision *string
                                                    }

                                                      Details about a package version, including its status, version, and revision. The ListPackageVersions (https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html) operation returns a list of PackageVersionSummary objects.

                                                      type RepositoryDescription

                                                      type RepositoryDescription struct {
                                                      
                                                      	// The 12-digit account number of the AWS account that manages the repository.
                                                      	AdministratorAccount *string
                                                      
                                                      	// The Amazon Resource Name (ARN) of the repository.
                                                      	Arn *string
                                                      
                                                      	// A text description of the repository.
                                                      	Description *string
                                                      
                                                      	// The name of the domain that contains the repository.
                                                      	DomainName *string
                                                      
                                                      	// The 12-digit account number of the AWS account that owns the domain that
                                                      	// contains the repository. It does not include dashes or spaces.
                                                      	DomainOwner *string
                                                      
                                                      	// An array of external connections associated with the repository.
                                                      	ExternalConnections []RepositoryExternalConnectionInfo
                                                      
                                                      	// The name of the repository.
                                                      	Name *string
                                                      
                                                      	// 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. For more information, see
                                                      	// Working with upstream repositories
                                                      	// (https://docs.aws.amazon.com/codeartifact/latest/ug/repos-upstream.html).
                                                      	Upstreams []UpstreamRepositoryInfo
                                                      }

                                                        The details of a repository stored in AWS 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 AWS account.

                                                        type RepositoryExternalConnectionInfo

                                                        type RepositoryExternalConnectionInfo struct {
                                                        
                                                        	// The name of the external connection associated with a repository.
                                                        	ExternalConnectionName *string
                                                        
                                                        	// The package format associated with a repository's external connection. The valid
                                                        	// package formats are:
                                                        	//
                                                        	// * npm: A Node Package Manager (npm) package.
                                                        	//
                                                        	// * pypi: A
                                                        	// Python Package Index (PyPI) package.
                                                        	//
                                                        	// * maven: A Maven package that contains
                                                        	// compiled code in a distributable format, such as a JAR file.
                                                        	//
                                                        	// * nuget: A NuGet
                                                        	// package.
                                                        	PackageFormat PackageFormat
                                                        
                                                        	// The status of the external connection of a repository. There is one valid value,
                                                        	// Available.
                                                        	Status ExternalConnectionStatus
                                                        }

                                                          Contains information about the external connection of a repository.

                                                          type RepositorySummary

                                                          type RepositorySummary struct {
                                                          
                                                          	// The AWS account ID that manages the repository.
                                                          	AdministratorAccount *string
                                                          
                                                          	// The ARN of the repository.
                                                          	Arn *string
                                                          
                                                          	// The description of the repository.
                                                          	Description *string
                                                          
                                                          	// The name of the domain that contains the repository.
                                                          	DomainName *string
                                                          
                                                          	// The 12-digit account number of the AWS account that owns the domain. It does not
                                                          	// include dashes or spaces.
                                                          	DomainOwner *string
                                                          
                                                          	// The name of the repository.
                                                          	Name *string
                                                          }

                                                            Details about a repository, including its Amazon Resource Name (ARN), description, and domain information. The ListRepositories (https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListRepositories.html) operation returns a list of RepositorySummary objects.

                                                            type ResourceNotFoundException

                                                            type ResourceNotFoundException struct {
                                                            	Message *string
                                                            
                                                            	ResourceId   *string
                                                            	ResourceType ResourceType
                                                            }

                                                              The operation did not succeed because the resource requested is not found in the service.

                                                              func (*ResourceNotFoundException) Error

                                                              func (e *ResourceNotFoundException) Error() string

                                                              func (*ResourceNotFoundException) ErrorCode

                                                              func (e *ResourceNotFoundException) ErrorCode() string

                                                              func (*ResourceNotFoundException) ErrorFault

                                                              func (*ResourceNotFoundException) ErrorMessage

                                                              func (e *ResourceNotFoundException) ErrorMessage() string

                                                              type ResourcePolicy

                                                              type ResourcePolicy struct {
                                                              
                                                              	// The resource policy formatted in JSON.
                                                              	Document *string
                                                              
                                                              	// The ARN of the resource associated with the resource policy
                                                              	ResourceArn *string
                                                              
                                                              	// The current revision of the resource policy.
                                                              	Revision *string
                                                              }

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

                                                                type ResourceType

                                                                type ResourceType string
                                                                const (
                                                                	ResourceTypeDomain         ResourceType = "domain"
                                                                	ResourceTypeRepository     ResourceType = "repository"
                                                                	ResourceTypePackage        ResourceType = "package"
                                                                	ResourceTypePackageVersion ResourceType = "package-version"
                                                                	ResourceTypeAsset          ResourceType = "asset"
                                                                )

                                                                  Enum values for ResourceType

                                                                  func (ResourceType) Values

                                                                  func (ResourceType) Values() []ResourceType

                                                                    Values returns all known values for ResourceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                    type ServiceQuotaExceededException

                                                                    type ServiceQuotaExceededException struct {
                                                                    	Message *string
                                                                    
                                                                    	ResourceId   *string
                                                                    	ResourceType ResourceType
                                                                    }

                                                                      The operation did not succeed because it would have exceeded a service limit for your account.

                                                                      func (*ServiceQuotaExceededException) Error

                                                                      func (*ServiceQuotaExceededException) ErrorCode

                                                                      func (e *ServiceQuotaExceededException) ErrorCode() string

                                                                      func (*ServiceQuotaExceededException) ErrorFault

                                                                      func (*ServiceQuotaExceededException) ErrorMessage

                                                                      func (e *ServiceQuotaExceededException) ErrorMessage() string

                                                                      type SuccessfulPackageVersionInfo

                                                                      type SuccessfulPackageVersionInfo struct {
                                                                      
                                                                      	// The revision of a package version.
                                                                      	Revision *string
                                                                      
                                                                      	// The status of a package version. Valid statuses are:
                                                                      	//
                                                                      	// * Published
                                                                      	//
                                                                      	// *
                                                                      	// Unfinished
                                                                      	//
                                                                      	// * Unlisted
                                                                      	//
                                                                      	// * Archived
                                                                      	//
                                                                      	// * Disposed
                                                                      	Status PackageVersionStatus
                                                                      }

                                                                        Contains the revision and status of a package version.

                                                                        type Tag

                                                                        type Tag struct {
                                                                        
                                                                        	// The tag key.
                                                                        	//
                                                                        	// This member is required.
                                                                        	Key *string
                                                                        
                                                                        	// The tag value.
                                                                        	//
                                                                        	// This member is required.
                                                                        	Value *string
                                                                        }

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

                                                                          type ThrottlingException

                                                                          type ThrottlingException struct {
                                                                          	Message *string
                                                                          
                                                                          	RetryAfterSeconds *int32
                                                                          }

                                                                            The operation did not succeed because too many requests are sent to the service.

                                                                            func (*ThrottlingException) Error

                                                                            func (e *ThrottlingException) Error() string

                                                                            func (*ThrottlingException) ErrorCode

                                                                            func (e *ThrottlingException) ErrorCode() string

                                                                            func (*ThrottlingException) ErrorFault

                                                                            func (e *ThrottlingException) ErrorFault() smithy.ErrorFault

                                                                            func (*ThrottlingException) ErrorMessage

                                                                            func (e *ThrottlingException) ErrorMessage() string

                                                                            type UpstreamRepository

                                                                            type UpstreamRepository struct {
                                                                            
                                                                            	// The name of an upstream repository.
                                                                            	//
                                                                            	// This member is required.
                                                                            	RepositoryName *string
                                                                            }

                                                                              Information about an upstream repository. A list of UpstreamRepository objects is an input parameter to CreateRepository (https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_CreateRepository.html) and UpdateRepository (https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdateRepository.html).

                                                                              type UpstreamRepositoryInfo

                                                                              type UpstreamRepositoryInfo struct {
                                                                              
                                                                              	// The name of an upstream repository.
                                                                              	RepositoryName *string
                                                                              }

                                                                                Information about an upstream repository.

                                                                                type ValidationException

                                                                                type ValidationException struct {
                                                                                	Message *string
                                                                                
                                                                                	Reason ValidationExceptionReason
                                                                                }

                                                                                  The operation did not succeed because a parameter in the request was sent with an invalid value.

                                                                                  func (*ValidationException) Error

                                                                                  func (e *ValidationException) Error() string

                                                                                  func (*ValidationException) ErrorCode

                                                                                  func (e *ValidationException) ErrorCode() string

                                                                                  func (*ValidationException) ErrorFault

                                                                                  func (e *ValidationException) ErrorFault() smithy.ErrorFault

                                                                                  func (*ValidationException) ErrorMessage

                                                                                  func (e *ValidationException) ErrorMessage() string

                                                                                  type ValidationExceptionReason

                                                                                  type ValidationExceptionReason string
                                                                                  const (
                                                                                  	ValidationExceptionReasonCannotParse           ValidationExceptionReason = "CANNOT_PARSE"
                                                                                  	ValidationExceptionReasonEncryptionKeyError    ValidationExceptionReason = "ENCRYPTION_KEY_ERROR"
                                                                                  	ValidationExceptionReasonFieldValidationFailed ValidationExceptionReason = "FIELD_VALIDATION_FAILED"
                                                                                  	ValidationExceptionReasonUnknownOperation      ValidationExceptionReason = "UNKNOWN_OPERATION"
                                                                                  	ValidationExceptionReasonOther                 ValidationExceptionReason = "OTHER"
                                                                                  )

                                                                                    Enum values for ValidationExceptionReason

                                                                                    func (ValidationExceptionReason) Values

                                                                                      Values returns all known values for ValidationExceptionReason. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.