Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CertificateDetail

type CertificateDetail struct {

	// The Amazon Resource Name (ARN) of the certificate. For more information about
	// ARNs, see Amazon Resource Names (ARNs) and AWS Service Namespaces
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) in
	// the AWS General Reference.
	CertificateArn *string

	// The Amazon Resource Name (ARN) of the ACM PCA private certificate authority (CA)
	// that issued the certificate. This has the following format:
	// arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
	CertificateAuthorityArn *string

	// The time at which the certificate was requested. This value exists only when the
	// certificate type is AMAZON_ISSUED.
	CreatedAt *time.Time

	// The fully qualified domain name for the certificate, such as www.example.com or
	// example.com.
	DomainName *string

	// Contains information about the initial validation of each domain name that
	// occurs as a result of the RequestCertificate request. This field exists only
	// when the certificate type is AMAZON_ISSUED.
	DomainValidationOptions []DomainValidation

	// Contains a list of Extended Key Usage X.509 v3 extension objects. Each object
	// specifies a purpose for which the certificate public key can be used and
	// consists of a name and an object identifier (OID).
	ExtendedKeyUsages []ExtendedKeyUsage

	// The reason the certificate request failed. This value exists only when the
	// certificate status is FAILED. For more information, see Certificate Request
	// Failed
	// (https://docs.aws.amazon.com/acm/latest/userguide/troubleshooting.html#troubleshooting-failed)
	// in the AWS Certificate Manager User Guide.
	FailureReason FailureReason

	// The date and time at which the certificate was imported. This value exists only
	// when the certificate type is IMPORTED.
	ImportedAt *time.Time

	// A list of ARNs for the AWS resources that are using the certificate. A
	// certificate can be used by multiple AWS resources.
	InUseBy []string

	// The time at which the certificate was issued. This value exists only when the
	// certificate type is AMAZON_ISSUED.
	IssuedAt *time.Time

	// The name of the certificate authority that issued and signed the certificate.
	Issuer *string

	// The algorithm that was used to generate the public-private key pair.
	KeyAlgorithm KeyAlgorithm

	// A list of Key Usage X.509 v3 extension objects. Each object is a string value
	// that identifies the purpose of the public key contained in the certificate.
	// Possible extension values include DIGITAL_SIGNATURE, KEY_ENCHIPHERMENT,
	// NON_REPUDIATION, and more.
	KeyUsages []KeyUsage

	// The time after which the certificate is not valid.
	NotAfter *time.Time

	// The time before which the certificate is not valid.
	NotBefore *time.Time

	// Value that specifies whether to add the certificate to a transparency log.
	// Certificate transparency makes it possible to detect SSL certificates that have
	// been mistakenly or maliciously issued. A browser might respond to certificate
	// that has not been logged by showing an error message. The logs are
	// cryptographically secure.
	Options *CertificateOptions

	// Specifies whether the certificate is eligible for renewal. At this time, only
	// exported private certificates can be renewed with the RenewCertificate command.
	RenewalEligibility RenewalEligibility

	// Contains information about the status of ACM's managed renewal
	// (https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html) for the
	// certificate. This field exists only when the certificate type is AMAZON_ISSUED.
	RenewalSummary *RenewalSummary

	// The reason the certificate was revoked. This value exists only when the
	// certificate status is REVOKED.
	RevocationReason RevocationReason

	// The time at which the certificate was revoked. This value exists only when the
	// certificate status is REVOKED.
	RevokedAt *time.Time

	// The serial number of the certificate.
	Serial *string

	// The algorithm that was used to sign the certificate.
	SignatureAlgorithm *string

	// The status of the certificate.
	Status CertificateStatus

	// The name of the entity that is associated with the public key contained in the
	// certificate.
	Subject *string

	// One or more domain names (subject alternative names) included in the
	// certificate. This list contains the domain names that are bound to the public
	// key that is contained in the certificate. The subject alternative names include
	// the canonical domain name (CN) of the certificate and additional domain names
	// that can be used to connect to the website.
	SubjectAlternativeNames []string

	// The source of the certificate. For certificates provided by ACM, this value is
	// AMAZON_ISSUED. For certificates that you imported with ImportCertificate, this
	// value is IMPORTED. ACM does not provide managed renewal
	// (https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html) for imported
	// certificates. For more information about the differences between certificates
	// that you import and those that ACM provides, see Importing Certificates
	// (https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html) in
	// the AWS Certificate Manager User Guide.
	Type CertificateType
}

    Contains metadata about an ACM certificate. This structure is returned in the response to a DescribeCertificate request.

    type CertificateOptions

    type CertificateOptions struct {
    
    	// You can opt out of certificate transparency logging by specifying the DISABLED
    	// option. Opt in by specifying ENABLED.
    	CertificateTransparencyLoggingPreference CertificateTransparencyLoggingPreference
    }

      Structure that contains options for your certificate. Currently, you can use this only to specify whether to opt in to or out of certificate transparency logging. Some browsers require that public certificates issued for your domain be recorded in a log. Certificates that are not logged typically generate a browser error. Transparency makes it possible for you to detect SSL/TLS certificates that have been mistakenly or maliciously issued for your domain. For general information, see Certificate Transparency Logging (https://docs.aws.amazon.com/acm/latest/userguide/acm-concepts.html#concept-transparency).

      type CertificateStatus

      type CertificateStatus string
      const (
      	CertificateStatusPendingValidation  CertificateStatus = "PENDING_VALIDATION"
      	CertificateStatusIssued             CertificateStatus = "ISSUED"
      	CertificateStatusInactive           CertificateStatus = "INACTIVE"
      	CertificateStatusExpired            CertificateStatus = "EXPIRED"
      	CertificateStatusValidationTimedOut CertificateStatus = "VALIDATION_TIMED_OUT"
      	CertificateStatusRevoked            CertificateStatus = "REVOKED"
      	CertificateStatusFailed             CertificateStatus = "FAILED"
      )

        Enum values for CertificateStatus

        func (CertificateStatus) Values

          Values returns all known values for CertificateStatus. 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 CertificateSummary

          type CertificateSummary struct {
          
          	// Amazon Resource Name (ARN) of the certificate. This is of the form:
          	// arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012
          	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
          	// Service Namespaces
          	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
          	CertificateArn *string
          
          	// Fully qualified domain name (FQDN), such as www.example.com or example.com, for
          	// the certificate.
          	DomainName *string
          }

            This structure is returned in the response object of ListCertificates action.

            type CertificateTransparencyLoggingPreference

            type CertificateTransparencyLoggingPreference string
            const (
            	CertificateTransparencyLoggingPreferenceEnabled  CertificateTransparencyLoggingPreference = "ENABLED"
            	CertificateTransparencyLoggingPreferenceDisabled CertificateTransparencyLoggingPreference = "DISABLED"
            )

              Enum values for CertificateTransparencyLoggingPreference

              func (CertificateTransparencyLoggingPreference) Values

                Values returns all known values for CertificateTransparencyLoggingPreference. 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 CertificateType

                type CertificateType string
                const (
                	CertificateTypeImported     CertificateType = "IMPORTED"
                	CertificateTypeAmazonIssued CertificateType = "AMAZON_ISSUED"
                	CertificateTypePrivate      CertificateType = "PRIVATE"
                )

                  Enum values for CertificateType

                  func (CertificateType) Values

                  func (CertificateType) Values() []CertificateType

                    Values returns all known values for CertificateType. 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 DomainStatus

                    type DomainStatus string
                    const (
                    	DomainStatusPendingValidation DomainStatus = "PENDING_VALIDATION"
                    	DomainStatusSuccess           DomainStatus = "SUCCESS"
                    	DomainStatusFailed            DomainStatus = "FAILED"
                    )

                      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 DomainValidation

                        type DomainValidation struct {
                        
                        	// A fully qualified domain name (FQDN) in the certificate. For example,
                        	// www.example.com or example.com.
                        	//
                        	// This member is required.
                        	DomainName *string
                        
                        	// Contains the CNAME record that you add to your DNS database for domain
                        	// validation. For more information, see Use DNS to Validate Domain Ownership
                        	// (https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-dns.html).
                        	// Note: The CNAME information that you need does not include the name of your
                        	// domain. If you include
 your domain name in the DNS database CNAME record,
                        	// validation fails.
 For example, if the name is
                        	// "_a79865eb4cd1a6ab990a45779b4e0b96.yourdomain.com", only
                        	// "_a79865eb4cd1a6ab990a45779b4e0b96" must be used.
                        	ResourceRecord *ResourceRecord
                        
                        	// The domain name that ACM used to send domain validation emails.
                        	ValidationDomain *string
                        
                        	// A list of email addresses that ACM used to send domain validation emails.
                        	ValidationEmails []string
                        
                        	// Specifies the domain validation method.
                        	ValidationMethod ValidationMethod
                        
                        	// The validation status of the domain name. This can be one of the following
                        	// values:
                        	//
                        	// * PENDING_VALIDATION
                        	//
                        	// * SUCCESS
                        	//
                        	// * FAILED
                        	ValidationStatus DomainStatus
                        }

                          Contains information about the validation of each domain name in the certificate.

                          type DomainValidationOption

                          type DomainValidationOption struct {
                          
                          	// A fully qualified domain name (FQDN) in the certificate request.
                          	//
                          	// This member is required.
                          	DomainName *string
                          
                          	// The domain name that you want ACM to use to send you validation emails. This
                          	// domain name is the suffix of the email addresses that you want ACM to use. This
                          	// must be the same as the DomainName value or a superdomain of the DomainName
                          	// value. For example, if you request a certificate for testing.example.com, you
                          	// can specify example.com for this value. In that case, ACM sends domain
                          	// validation emails to the following five addresses:
                          	//
                          	// * admin@example.com
                          	//
                          	// *
                          	// administrator@example.com
                          	//
                          	// * hostmaster@example.com
                          	//
                          	// * postmaster@example.com
                          	//
                          	// *
                          	// webmaster@example.com
                          	//
                          	// This member is required.
                          	ValidationDomain *string
                          }

                            Contains information about the domain names that you want ACM to use to send you emails that enable you to validate domain ownership.

                            type ExtendedKeyUsage

                            type ExtendedKeyUsage struct {
                            
                            	// The name of an Extended Key Usage value.
                            	Name ExtendedKeyUsageName
                            
                            	// An object identifier (OID) for the extension value. OIDs are strings of numbers
                            	// separated by periods. The following OIDs are defined in RFC 3280 and RFC
                            	// 5280.
                            	//
                            	// * 1.3.6.1.5.5.7.3.1 (TLS_WEB_SERVER_AUTHENTICATION)
                            	//
                            	// * 1.3.6.1.5.5.7.3.2
                            	// (TLS_WEB_CLIENT_AUTHENTICATION)
                            	//
                            	// * 1.3.6.1.5.5.7.3.3 (CODE_SIGNING)
                            	//
                            	// *
                            	// 1.3.6.1.5.5.7.3.4 (EMAIL_PROTECTION)
                            	//
                            	// * 1.3.6.1.5.5.7.3.8 (TIME_STAMPING)
                            	//
                            	// *
                            	// 1.3.6.1.5.5.7.3.9 (OCSP_SIGNING)
                            	//
                            	// * 1.3.6.1.5.5.7.3.5 (IPSEC_END_SYSTEM)
                            	//
                            	// *
                            	// 1.3.6.1.5.5.7.3.6 (IPSEC_TUNNEL)
                            	//
                            	// * 1.3.6.1.5.5.7.3.7 (IPSEC_USER)
                            	OID *string
                            }

                              The Extended Key Usage X.509 v3 extension defines one or more purposes for which the public key can be used. This is in addition to or in place of the basic purposes specified by the Key Usage extension.

                              type ExtendedKeyUsageName

                              type ExtendedKeyUsageName string
                              const (
                              	ExtendedKeyUsageNameTlsWebServerAuthentication ExtendedKeyUsageName = "TLS_WEB_SERVER_AUTHENTICATION"
                              	ExtendedKeyUsageNameTlsWebClientAuthentication ExtendedKeyUsageName = "TLS_WEB_CLIENT_AUTHENTICATION"
                              	ExtendedKeyUsageNameCodeSigning                ExtendedKeyUsageName = "CODE_SIGNING"
                              	ExtendedKeyUsageNameEmailProtection            ExtendedKeyUsageName = "EMAIL_PROTECTION"
                              	ExtendedKeyUsageNameTimeStamping               ExtendedKeyUsageName = "TIME_STAMPING"
                              	ExtendedKeyUsageNameOcspSigning                ExtendedKeyUsageName = "OCSP_SIGNING"
                              	ExtendedKeyUsageNameIpsecEndSystem             ExtendedKeyUsageName = "IPSEC_END_SYSTEM"
                              	ExtendedKeyUsageNameIpsecTunnel                ExtendedKeyUsageName = "IPSEC_TUNNEL"
                              	ExtendedKeyUsageNameIpsecUser                  ExtendedKeyUsageName = "IPSEC_USER"
                              	ExtendedKeyUsageNameAny                        ExtendedKeyUsageName = "ANY"
                              	ExtendedKeyUsageNameNone                       ExtendedKeyUsageName = "NONE"
                              	ExtendedKeyUsageNameCustom                     ExtendedKeyUsageName = "CUSTOM"
                              )

                                Enum values for ExtendedKeyUsageName

                                func (ExtendedKeyUsageName) Values

                                  Values returns all known values for ExtendedKeyUsageName. 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 FailureReason

                                  type FailureReason string
                                  const (
                                  	FailureReasonNoAvailableContacts            FailureReason = "NO_AVAILABLE_CONTACTS"
                                  	FailureReasonAdditionalVerificationRequired FailureReason = "ADDITIONAL_VERIFICATION_REQUIRED"
                                  	FailureReasonDomainNotAllowed               FailureReason = "DOMAIN_NOT_ALLOWED"
                                  	FailureReasonInvalidPublicDomain            FailureReason = "INVALID_PUBLIC_DOMAIN"
                                  	FailureReasonDomainValidationDenied         FailureReason = "DOMAIN_VALIDATION_DENIED"
                                  	FailureReasonCaaError                       FailureReason = "CAA_ERROR"
                                  	FailureReasonPcaLimitExceeded               FailureReason = "PCA_LIMIT_EXCEEDED"
                                  	FailureReasonPcaInvalidArn                  FailureReason = "PCA_INVALID_ARN"
                                  	FailureReasonPcaInvalidState                FailureReason = "PCA_INVALID_STATE"
                                  	FailureReasonPcaRequestFailed               FailureReason = "PCA_REQUEST_FAILED"
                                  	FailureReasonPcaNameConstraintsValidation   FailureReason = "PCA_NAME_CONSTRAINTS_VALIDATION"
                                  	FailureReasonPcaResourceNotFound            FailureReason = "PCA_RESOURCE_NOT_FOUND"
                                  	FailureReasonPcaInvalidArgs                 FailureReason = "PCA_INVALID_ARGS"
                                  	FailureReasonPcaInvalidDuration             FailureReason = "PCA_INVALID_DURATION"
                                  	FailureReasonPcaAccessDenied                FailureReason = "PCA_ACCESS_DENIED"
                                  	FailureReasonSlrNotFound                    FailureReason = "SLR_NOT_FOUND"
                                  	FailureReasonOther                          FailureReason = "OTHER"
                                  )

                                    Enum values for FailureReason

                                    func (FailureReason) Values

                                    func (FailureReason) Values() []FailureReason

                                      Values returns all known values for FailureReason. 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 Filters

                                      type Filters struct {
                                      
                                      	// Specify one or more ExtendedKeyUsage extension values.
                                      	ExtendedKeyUsage []ExtendedKeyUsageName
                                      
                                      	// Specify one or more algorithms that can be used to generate key pairs. Default
                                      	// filtering returns only RSA_2048 certificates. To return other certificate types,
                                      	// provide the desired type signatures in a comma-separated list. For example,
                                      	// "keyTypes": ["RSA_2048,RSA_4096"] returns both RSA_2048 and RSA_4096
                                      	// certificates.
                                      	KeyTypes []KeyAlgorithm
                                      
                                      	// Specify one or more KeyUsage extension values.
                                      	KeyUsage []KeyUsageName
                                      }

                                        This structure can be used in the ListCertificates action to filter the output of the certificate list.

                                        type InvalidArgsException

                                        type InvalidArgsException struct {
                                        	Message *string
                                        }

                                          One or more of of request parameters specified is not valid.

                                          func (*InvalidArgsException) Error

                                          func (e *InvalidArgsException) Error() string

                                          func (*InvalidArgsException) ErrorCode

                                          func (e *InvalidArgsException) ErrorCode() string

                                          func (*InvalidArgsException) ErrorFault

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

                                          func (*InvalidArgsException) ErrorMessage

                                          func (e *InvalidArgsException) ErrorMessage() string

                                          type InvalidArnException

                                          type InvalidArnException struct {
                                          	Message *string
                                          }

                                            The requested Amazon Resource Name (ARN) does not refer to an existing resource.

                                            func (*InvalidArnException) Error

                                            func (e *InvalidArnException) Error() string

                                            func (*InvalidArnException) ErrorCode

                                            func (e *InvalidArnException) ErrorCode() string

                                            func (*InvalidArnException) ErrorFault

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

                                            func (*InvalidArnException) ErrorMessage

                                            func (e *InvalidArnException) ErrorMessage() string

                                            type InvalidDomainValidationOptionsException

                                            type InvalidDomainValidationOptionsException struct {
                                            	Message *string
                                            }

                                              One or more values in the DomainValidationOption structure is incorrect.

                                              func (*InvalidDomainValidationOptionsException) Error

                                              func (*InvalidDomainValidationOptionsException) ErrorCode

                                              func (*InvalidDomainValidationOptionsException) ErrorFault

                                              func (*InvalidDomainValidationOptionsException) ErrorMessage

                                              type InvalidParameterException

                                              type InvalidParameterException struct {
                                              	Message *string
                                              }

                                                An input parameter was invalid.

                                                func (*InvalidParameterException) Error

                                                func (e *InvalidParameterException) Error() string

                                                func (*InvalidParameterException) ErrorCode

                                                func (e *InvalidParameterException) ErrorCode() string

                                                func (*InvalidParameterException) ErrorFault

                                                func (*InvalidParameterException) ErrorMessage

                                                func (e *InvalidParameterException) ErrorMessage() string

                                                type InvalidStateException

                                                type InvalidStateException struct {
                                                	Message *string
                                                }

                                                  Processing has reached an invalid state.

                                                  func (*InvalidStateException) Error

                                                  func (e *InvalidStateException) Error() string

                                                  func (*InvalidStateException) ErrorCode

                                                  func (e *InvalidStateException) ErrorCode() string

                                                  func (*InvalidStateException) ErrorFault

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

                                                  func (*InvalidStateException) ErrorMessage

                                                  func (e *InvalidStateException) ErrorMessage() string

                                                  type InvalidTagException

                                                  type InvalidTagException struct {
                                                  	Message *string
                                                  }

                                                    One or both of the values that make up the key-value pair is not valid. For example, you cannot specify a tag value that begins with aws:.

                                                    func (*InvalidTagException) Error

                                                    func (e *InvalidTagException) Error() string

                                                    func (*InvalidTagException) ErrorCode

                                                    func (e *InvalidTagException) ErrorCode() string

                                                    func (*InvalidTagException) ErrorFault

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

                                                    func (*InvalidTagException) ErrorMessage

                                                    func (e *InvalidTagException) ErrorMessage() string

                                                    type KeyAlgorithm

                                                    type KeyAlgorithm string
                                                    const (
                                                    	KeyAlgorithmRsa2048      KeyAlgorithm = "RSA_2048"
                                                    	KeyAlgorithmRsa1024      KeyAlgorithm = "RSA_1024"
                                                    	KeyAlgorithmRsa4096      KeyAlgorithm = "RSA_4096"
                                                    	KeyAlgorithmEcPrime256v1 KeyAlgorithm = "EC_prime256v1"
                                                    	KeyAlgorithmEcSecp384r1  KeyAlgorithm = "EC_secp384r1"
                                                    	KeyAlgorithmEcSecp521r1  KeyAlgorithm = "EC_secp521r1"
                                                    )

                                                      Enum values for KeyAlgorithm

                                                      func (KeyAlgorithm) Values

                                                      func (KeyAlgorithm) Values() []KeyAlgorithm

                                                        Values returns all known values for KeyAlgorithm. 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 KeyUsage

                                                        type KeyUsage struct {
                                                        
                                                        	// A string value that contains a Key Usage extension name.
                                                        	Name KeyUsageName
                                                        }

                                                          The Key Usage X.509 v3 extension defines the purpose of the public key contained in the certificate.

                                                          type KeyUsageName

                                                          type KeyUsageName string
                                                          const (
                                                          	KeyUsageNameDigitalSignature   KeyUsageName = "DIGITAL_SIGNATURE"
                                                          	KeyUsageNameNonRepudation      KeyUsageName = "NON_REPUDIATION"
                                                          	KeyUsageNameKeyEncipherment    KeyUsageName = "KEY_ENCIPHERMENT"
                                                          	KeyUsageNameDataEncipherment   KeyUsageName = "DATA_ENCIPHERMENT"
                                                          	KeyUsageNameKeyAgreement       KeyUsageName = "KEY_AGREEMENT"
                                                          	KeyUsageNameCertificateSigning KeyUsageName = "CERTIFICATE_SIGNING"
                                                          	KeyUsageNameCrlSigning         KeyUsageName = "CRL_SIGNING"
                                                          	KeyUsageNameEnchiperOnly       KeyUsageName = "ENCIPHER_ONLY"
                                                          	KeyUsageNameDecipherOnly       KeyUsageName = "DECIPHER_ONLY"
                                                          	KeyUsageNameAny                KeyUsageName = "ANY"
                                                          	KeyUsageNameCustom             KeyUsageName = "CUSTOM"
                                                          )

                                                            Enum values for KeyUsageName

                                                            func (KeyUsageName) Values

                                                            func (KeyUsageName) Values() []KeyUsageName

                                                              Values returns all known values for KeyUsageName. 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 LimitExceededException

                                                              type LimitExceededException struct {
                                                              	Message *string
                                                              }

                                                                An ACM quota has been exceeded.

                                                                func (*LimitExceededException) Error

                                                                func (e *LimitExceededException) Error() string

                                                                func (*LimitExceededException) ErrorCode

                                                                func (e *LimitExceededException) ErrorCode() string

                                                                func (*LimitExceededException) ErrorFault

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

                                                                func (*LimitExceededException) ErrorMessage

                                                                func (e *LimitExceededException) ErrorMessage() string

                                                                type RecordType

                                                                type RecordType string
                                                                const (
                                                                	RecordTypeCname RecordType = "CNAME"
                                                                )

                                                                  Enum values for RecordType

                                                                  func (RecordType) Values

                                                                  func (RecordType) Values() []RecordType

                                                                    Values returns all known values for RecordType. 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 RenewalEligibility

                                                                    type RenewalEligibility string
                                                                    const (
                                                                    	RenewalEligibilityEligible   RenewalEligibility = "ELIGIBLE"
                                                                    	RenewalEligibilityIneligible RenewalEligibility = "INELIGIBLE"
                                                                    )

                                                                      Enum values for RenewalEligibility

                                                                      func (RenewalEligibility) Values

                                                                        Values returns all known values for RenewalEligibility. 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 RenewalStatus

                                                                        type RenewalStatus string
                                                                        const (
                                                                        	RenewalStatusPendingAutoRenewal RenewalStatus = "PENDING_AUTO_RENEWAL"
                                                                        	RenewalStatusPendingValidation  RenewalStatus = "PENDING_VALIDATION"
                                                                        	RenewalStatusSuccess            RenewalStatus = "SUCCESS"
                                                                        	RenewalStatusFailed             RenewalStatus = "FAILED"
                                                                        )

                                                                          Enum values for RenewalStatus

                                                                          func (RenewalStatus) Values

                                                                          func (RenewalStatus) Values() []RenewalStatus

                                                                            Values returns all known values for RenewalStatus. 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 RenewalSummary

                                                                            type RenewalSummary struct {
                                                                            
                                                                            	// Contains information about the validation of each domain name in the
                                                                            	// certificate, as it pertains to ACM's managed renewal
                                                                            	// (https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html). This is
                                                                            	// different from the initial validation that occurs as a result of the
                                                                            	// RequestCertificate request. This field exists only when the certificate type is
                                                                            	// AMAZON_ISSUED.
                                                                            	//
                                                                            	// This member is required.
                                                                            	DomainValidationOptions []DomainValidation
                                                                            
                                                                            	// The status of ACM's managed renewal
                                                                            	// (https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html) of the
                                                                            	// certificate.
                                                                            	//
                                                                            	// This member is required.
                                                                            	RenewalStatus RenewalStatus
                                                                            
                                                                            	// The time at which the renewal summary was last updated.
                                                                            	//
                                                                            	// This member is required.
                                                                            	UpdatedAt *time.Time
                                                                            
                                                                            	// The reason that a renewal request was unsuccessful.
                                                                            	RenewalStatusReason FailureReason
                                                                            }

                                                                              Contains information about the status of ACM's managed renewal (https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html) for the certificate. This structure exists only when the certificate type is AMAZON_ISSUED.

                                                                              type RequestInProgressException

                                                                              type RequestInProgressException struct {
                                                                              	Message *string
                                                                              }

                                                                                The certificate request is in process and the certificate in your account has not yet been issued.

                                                                                func (*RequestInProgressException) Error

                                                                                func (*RequestInProgressException) ErrorCode

                                                                                func (e *RequestInProgressException) ErrorCode() string

                                                                                func (*RequestInProgressException) ErrorFault

                                                                                func (*RequestInProgressException) ErrorMessage

                                                                                func (e *RequestInProgressException) ErrorMessage() string

                                                                                type ResourceInUseException

                                                                                type ResourceInUseException struct {
                                                                                	Message *string
                                                                                }

                                                                                  The certificate is in use by another AWS service in the caller's account. Remove the association and try again.

                                                                                  func (*ResourceInUseException) Error

                                                                                  func (e *ResourceInUseException) Error() string

                                                                                  func (*ResourceInUseException) ErrorCode

                                                                                  func (e *ResourceInUseException) ErrorCode() string

                                                                                  func (*ResourceInUseException) ErrorFault

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

                                                                                  func (*ResourceInUseException) ErrorMessage

                                                                                  func (e *ResourceInUseException) ErrorMessage() string

                                                                                  type ResourceNotFoundException

                                                                                  type ResourceNotFoundException struct {
                                                                                  	Message *string
                                                                                  }

                                                                                    The specified certificate cannot be found in the caller's account or the caller's account cannot be found.

                                                                                    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 ResourceRecord

                                                                                    type ResourceRecord struct {
                                                                                    
                                                                                    	// The name of the DNS record to create in your domain. This is supplied by ACM.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	Name *string
                                                                                    
                                                                                    	// The type of DNS record. Currently this can be CNAME.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	Type RecordType
                                                                                    
                                                                                    	// The value of the CNAME record to add to your DNS database. This is supplied by
                                                                                    	// ACM.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	Value *string
                                                                                    }

                                                                                      Contains a DNS record value that you can use to can use to validate ownership or control of a domain. This is used by the DescribeCertificate action.

                                                                                      type RevocationReason

                                                                                      type RevocationReason string
                                                                                      const (
                                                                                      	RevocationReasonUnspecified          RevocationReason = "UNSPECIFIED"
                                                                                      	RevocationReasonKeyCompromise        RevocationReason = "KEY_COMPROMISE"
                                                                                      	RevocationReasonCaCompromise         RevocationReason = "CA_COMPROMISE"
                                                                                      	RevocationReasonAffiliationChanged   RevocationReason = "AFFILIATION_CHANGED"
                                                                                      	RevocationReasonSuperceded           RevocationReason = "SUPERCEDED"
                                                                                      	RevocationReasonCessationOfOperation RevocationReason = "CESSATION_OF_OPERATION"
                                                                                      	RevocationReasonCertificateHold      RevocationReason = "CERTIFICATE_HOLD"
                                                                                      	RevocationReasonRemoveFromCrl        RevocationReason = "REMOVE_FROM_CRL"
                                                                                      	RevocationReasonPrivilegeWithdrawn   RevocationReason = "PRIVILEGE_WITHDRAWN"
                                                                                      	RevocationReasonAACompromise         RevocationReason = "A_A_COMPROMISE"
                                                                                      )

                                                                                        Enum values for RevocationReason

                                                                                        func (RevocationReason) Values

                                                                                          Values returns all known values for RevocationReason. 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 Tag

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

                                                                                            A key-value pair that identifies or specifies metadata about an ACM resource.

                                                                                            type TagPolicyException

                                                                                            type TagPolicyException struct {
                                                                                            	Message *string
                                                                                            }

                                                                                              A specified tag did not comply with an existing tag policy and was rejected.

                                                                                              func (*TagPolicyException) Error

                                                                                              func (e *TagPolicyException) Error() string

                                                                                              func (*TagPolicyException) ErrorCode

                                                                                              func (e *TagPolicyException) ErrorCode() string

                                                                                              func (*TagPolicyException) ErrorFault

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

                                                                                              func (*TagPolicyException) ErrorMessage

                                                                                              func (e *TagPolicyException) ErrorMessage() string

                                                                                              type TooManyTagsException

                                                                                              type TooManyTagsException struct {
                                                                                              	Message *string
                                                                                              }

                                                                                                The request contains too many tags. Try the request again with fewer tags.

                                                                                                func (*TooManyTagsException) Error

                                                                                                func (e *TooManyTagsException) Error() string

                                                                                                func (*TooManyTagsException) ErrorCode

                                                                                                func (e *TooManyTagsException) ErrorCode() string

                                                                                                func (*TooManyTagsException) ErrorFault

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

                                                                                                func (*TooManyTagsException) ErrorMessage

                                                                                                func (e *TooManyTagsException) ErrorMessage() string

                                                                                                type ValidationMethod

                                                                                                type ValidationMethod string
                                                                                                const (
                                                                                                	ValidationMethodEmail ValidationMethod = "EMAIL"
                                                                                                	ValidationMethodDns   ValidationMethod = "DNS"
                                                                                                )

                                                                                                  Enum values for ValidationMethod

                                                                                                  func (ValidationMethod) Values

                                                                                                    Values returns all known values for ValidationMethod. 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.