com.amazonaws.services.certificatemanager.model.RequestCertificateRequest Maven / Gradle / Ivy
/*
* Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.certificatemanager.model;
import java.io.Serializable;
import javax.annotation.Generated;
import com.amazonaws.AmazonWebServiceRequest;
/**
*
* @see AWS API
* Documentation
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class RequestCertificateRequest extends com.amazonaws.AmazonWebServiceRequest implements Serializable, Cloneable {
/**
*
* Fully qualified domain name (FQDN), such as www.example.com, that you want to secure with an ACM certificate. Use
* an asterisk (*) to create a wildcard certificate that protects several sites in the same domain. For example,
* *.example.com protects www.example.com, site.example.com, and images.example.com.
*
*
* In compliance with RFC 5280, the length of the domain
* name (technically, the Common Name) that you provide cannot exceed 64 octets (characters), including periods. To
* add a longer domain name, specify it in the Subject Alternative Name field, which supports names up to 253 octets
* in length.
*
*/
private String domainName;
/**
*
* The method you want to use if you are requesting a public certificate to validate that you own or control domain.
* You can validate with DNS
* or validate with email.
* We recommend that you use DNS validation.
*
*/
private String validationMethod;
/**
*
* Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For example,
* add the name www.example.net to a certificate for which the DomainName field is www.example.com if
* users can reach your site by using either name. The maximum number of domain names that you can add to an ACM
* certificate is 100. However, the initial quota is 10 domain names. If you need more than 10 names, you must
* request a quota increase. For more information, see Quotas.
*
*
* The maximum length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by periods.
* No label can be longer than 63 octets. Consider the following examples:
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253 octets
* (63+1+63+1+63+1+61) and no label exceeds 63 octets.
*
*
* -
*
* (64 octets).(63 octets).(63 octets).(61 octets) is not legal because the total length exceeds 253
* octets (64+1+63+1+63+1+61) and the first label exceeds 63 octets.
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(62 octets) is not legal because the total length of the DNS
* name (63+1+63+1+63+1+62) exceeds 253 octets.
*
*
*
*/
private java.util.List subjectAlternativeNames;
/**
*
* Customer chosen string that can be used to distinguish between calls to RequestCertificate.
* Idempotency tokens time out after one hour. Therefore, if you call RequestCertificate multiple times
* with the same idempotency token within one hour, ACM recognizes that you are requesting only one certificate and
* will issue only one. If you change the idempotency token for each call, ACM recognizes that you are requesting
* multiple certificates.
*
*/
private String idempotencyToken;
/**
*
* The domain name that you want ACM to use to send you emails so that you can validate domain ownership.
*
*/
private java.util.List domainValidationOptions;
/**
*
* Currently, you can use this parameter to specify whether to add the certificate to a certificate transparency
* log. Certificate transparency makes it possible to detect SSL/TLS certificates that have been mistakenly or
* maliciously issued. Certificates that have not been logged typically produce an error message in a browser. For
* more information, see Opting
* Out of Certificate Transparency Logging.
*
*/
private CertificateOptions options;
/**
*
* The Amazon Resource Name (ARN) of the private certificate authority (CA) that will be used to issue the
* certificate. If you do not provide an ARN and you are trying to request a private certificate, ACM will attempt
* to issue a public certificate. For more information about private CAs, see the Amazon Web Services Private
* Certificate Authority user guide. The ARN must have the following form:
*
*
* arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
*
*/
private String certificateAuthorityArn;
/**
*
* One or more resource tags to associate with the certificate.
*
*/
private java.util.List tags;
/**
*
* Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data. RSA is the
* default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA) keys are smaller,
* offering security comparable to RSA keys but with greater computing efficiency. However, ECDSA is not supported
* by all network clients. Some AWS services may require RSA keys, or only support ECDSA keys of a particular size,
* while others allow the use of either RSA and ECDSA keys to ensure that compatibility is not broken. Check the
* requirements for the AWS service where you plan to deploy your certificate.
*
*
* Default: RSA_2048
*
*/
private String keyAlgorithm;
/**
*
* Fully qualified domain name (FQDN), such as www.example.com, that you want to secure with an ACM certificate. Use
* an asterisk (*) to create a wildcard certificate that protects several sites in the same domain. For example,
* *.example.com protects www.example.com, site.example.com, and images.example.com.
*
*
* In compliance with RFC 5280, the length of the domain
* name (technically, the Common Name) that you provide cannot exceed 64 octets (characters), including periods. To
* add a longer domain name, specify it in the Subject Alternative Name field, which supports names up to 253 octets
* in length.
*
*
* @param domainName
* Fully qualified domain name (FQDN), such as www.example.com, that you want to secure with an ACM
* certificate. Use an asterisk (*) to create a wildcard certificate that protects several sites in the same
* domain. For example, *.example.com protects www.example.com, site.example.com, and images.example.com.
*
*
* In compliance with RFC 5280, the length of the
* domain name (technically, the Common Name) that you provide cannot exceed 64 octets (characters),
* including periods. To add a longer domain name, specify it in the Subject Alternative Name field, which
* supports names up to 253 octets in length.
*/
public void setDomainName(String domainName) {
this.domainName = domainName;
}
/**
*
* Fully qualified domain name (FQDN), such as www.example.com, that you want to secure with an ACM certificate. Use
* an asterisk (*) to create a wildcard certificate that protects several sites in the same domain. For example,
* *.example.com protects www.example.com, site.example.com, and images.example.com.
*
*
* In compliance with RFC 5280, the length of the domain
* name (technically, the Common Name) that you provide cannot exceed 64 octets (characters), including periods. To
* add a longer domain name, specify it in the Subject Alternative Name field, which supports names up to 253 octets
* in length.
*
*
* @return Fully qualified domain name (FQDN), such as www.example.com, that you want to secure with an ACM
* certificate. Use an asterisk (*) to create a wildcard certificate that protects several sites in the same
* domain. For example, *.example.com protects www.example.com, site.example.com, and images.example.com.
*
*
* In compliance with RFC 5280, the length of
* the domain name (technically, the Common Name) that you provide cannot exceed 64 octets (characters),
* including periods. To add a longer domain name, specify it in the Subject Alternative Name field, which
* supports names up to 253 octets in length.
*/
public String getDomainName() {
return this.domainName;
}
/**
*
* Fully qualified domain name (FQDN), such as www.example.com, that you want to secure with an ACM certificate. Use
* an asterisk (*) to create a wildcard certificate that protects several sites in the same domain. For example,
* *.example.com protects www.example.com, site.example.com, and images.example.com.
*
*
* In compliance with RFC 5280, the length of the domain
* name (technically, the Common Name) that you provide cannot exceed 64 octets (characters), including periods. To
* add a longer domain name, specify it in the Subject Alternative Name field, which supports names up to 253 octets
* in length.
*
*
* @param domainName
* Fully qualified domain name (FQDN), such as www.example.com, that you want to secure with an ACM
* certificate. Use an asterisk (*) to create a wildcard certificate that protects several sites in the same
* domain. For example, *.example.com protects www.example.com, site.example.com, and images.example.com.
*
*
* In compliance with RFC 5280, the length of the
* domain name (technically, the Common Name) that you provide cannot exceed 64 octets (characters),
* including periods. To add a longer domain name, specify it in the Subject Alternative Name field, which
* supports names up to 253 octets in length.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withDomainName(String domainName) {
setDomainName(domainName);
return this;
}
/**
*
* The method you want to use if you are requesting a public certificate to validate that you own or control domain.
* You can validate with DNS
* or validate with email.
* We recommend that you use DNS validation.
*
*
* @param validationMethod
* The method you want to use if you are requesting a public certificate to validate that you own or control
* domain. You can validate with DNS or
* validate with
* email. We recommend that you use DNS validation.
* @see ValidationMethod
*/
public void setValidationMethod(String validationMethod) {
this.validationMethod = validationMethod;
}
/**
*
* The method you want to use if you are requesting a public certificate to validate that you own or control domain.
* You can validate with DNS
* or validate with email.
* We recommend that you use DNS validation.
*
*
* @return The method you want to use if you are requesting a public certificate to validate that you own or control
* domain. You can validate with DNS or
* validate with
* email. We recommend that you use DNS validation.
* @see ValidationMethod
*/
public String getValidationMethod() {
return this.validationMethod;
}
/**
*
* The method you want to use if you are requesting a public certificate to validate that you own or control domain.
* You can validate with DNS
* or validate with email.
* We recommend that you use DNS validation.
*
*
* @param validationMethod
* The method you want to use if you are requesting a public certificate to validate that you own or control
* domain. You can validate with DNS or
* validate with
* email. We recommend that you use DNS validation.
* @return Returns a reference to this object so that method calls can be chained together.
* @see ValidationMethod
*/
public RequestCertificateRequest withValidationMethod(String validationMethod) {
setValidationMethod(validationMethod);
return this;
}
/**
*
* The method you want to use if you are requesting a public certificate to validate that you own or control domain.
* You can validate with DNS
* or validate with email.
* We recommend that you use DNS validation.
*
*
* @param validationMethod
* The method you want to use if you are requesting a public certificate to validate that you own or control
* domain. You can validate with DNS or
* validate with
* email. We recommend that you use DNS validation.
* @return Returns a reference to this object so that method calls can be chained together.
* @see ValidationMethod
*/
public RequestCertificateRequest withValidationMethod(ValidationMethod validationMethod) {
this.validationMethod = validationMethod.toString();
return this;
}
/**
*
* Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For example,
* add the name www.example.net to a certificate for which the DomainName field is www.example.com if
* users can reach your site by using either name. The maximum number of domain names that you can add to an ACM
* certificate is 100. However, the initial quota is 10 domain names. If you need more than 10 names, you must
* request a quota increase. For more information, see Quotas.
*
*
* The maximum length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by periods.
* No label can be longer than 63 octets. Consider the following examples:
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253 octets
* (63+1+63+1+63+1+61) and no label exceeds 63 octets.
*
*
* -
*
* (64 octets).(63 octets).(63 octets).(61 octets) is not legal because the total length exceeds 253
* octets (64+1+63+1+63+1+61) and the first label exceeds 63 octets.
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(62 octets) is not legal because the total length of the DNS
* name (63+1+63+1+63+1+62) exceeds 253 octets.
*
*
*
*
* @return Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For
* example, add the name www.example.net to a certificate for which the DomainName field is
* www.example.com if users can reach your site by using either name. The maximum number of domain names
* that you can add to an ACM certificate is 100. However, the initial quota is 10 domain names. If you need
* more than 10 names, you must request a quota increase. For more information, see Quotas.
*
* The maximum length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by
* periods. No label can be longer than 63 octets. Consider the following examples:
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253
* octets (63+1+63+1+63+1+61) and no label exceeds 63 octets.
*
*
* -
*
* (64 octets).(63 octets).(63 octets).(61 octets) is not legal because the total length
* exceeds 253 octets (64+1+63+1+63+1+61) and the first label exceeds 63 octets.
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(62 octets) is not legal because the total length of the
* DNS name (63+1+63+1+63+1+62) exceeds 253 octets.
*
*
*/
public java.util.List getSubjectAlternativeNames() {
return subjectAlternativeNames;
}
/**
*
* Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For example,
* add the name www.example.net to a certificate for which the DomainName field is www.example.com if
* users can reach your site by using either name. The maximum number of domain names that you can add to an ACM
* certificate is 100. However, the initial quota is 10 domain names. If you need more than 10 names, you must
* request a quota increase. For more information, see Quotas.
*
*
* The maximum length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by periods.
* No label can be longer than 63 octets. Consider the following examples:
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253 octets
* (63+1+63+1+63+1+61) and no label exceeds 63 octets.
*
*
* -
*
* (64 octets).(63 octets).(63 octets).(61 octets) is not legal because the total length exceeds 253
* octets (64+1+63+1+63+1+61) and the first label exceeds 63 octets.
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(62 octets) is not legal because the total length of the DNS
* name (63+1+63+1+63+1+62) exceeds 253 octets.
*
*
*
*
* @param subjectAlternativeNames
* Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For
* example, add the name www.example.net to a certificate for which the DomainName field is
* www.example.com if users can reach your site by using either name. The maximum number of domain names that
* you can add to an ACM certificate is 100. However, the initial quota is 10 domain names. If you need more
* than 10 names, you must request a quota increase. For more information, see Quotas.
*
* The maximum length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by
* periods. No label can be longer than 63 octets. Consider the following examples:
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253
* octets (63+1+63+1+63+1+61) and no label exceeds 63 octets.
*
*
* -
*
* (64 octets).(63 octets).(63 octets).(61 octets) is not legal because the total length exceeds
* 253 octets (64+1+63+1+63+1+61) and the first label exceeds 63 octets.
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(62 octets) is not legal because the total length of the
* DNS name (63+1+63+1+63+1+62) exceeds 253 octets.
*
*
*/
public void setSubjectAlternativeNames(java.util.Collection subjectAlternativeNames) {
if (subjectAlternativeNames == null) {
this.subjectAlternativeNames = null;
return;
}
this.subjectAlternativeNames = new java.util.ArrayList(subjectAlternativeNames);
}
/**
*
* Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For example,
* add the name www.example.net to a certificate for which the DomainName field is www.example.com if
* users can reach your site by using either name. The maximum number of domain names that you can add to an ACM
* certificate is 100. However, the initial quota is 10 domain names. If you need more than 10 names, you must
* request a quota increase. For more information, see Quotas.
*
*
* The maximum length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by periods.
* No label can be longer than 63 octets. Consider the following examples:
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253 octets
* (63+1+63+1+63+1+61) and no label exceeds 63 octets.
*
*
* -
*
* (64 octets).(63 octets).(63 octets).(61 octets) is not legal because the total length exceeds 253
* octets (64+1+63+1+63+1+61) and the first label exceeds 63 octets.
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(62 octets) is not legal because the total length of the DNS
* name (63+1+63+1+63+1+62) exceeds 253 octets.
*
*
*
*
* NOTE: This method appends the values to the existing list (if any). Use
* {@link #setSubjectAlternativeNames(java.util.Collection)} or
* {@link #withSubjectAlternativeNames(java.util.Collection)} if you want to override the existing values.
*
*
* @param subjectAlternativeNames
* Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For
* example, add the name www.example.net to a certificate for which the DomainName field is
* www.example.com if users can reach your site by using either name. The maximum number of domain names that
* you can add to an ACM certificate is 100. However, the initial quota is 10 domain names. If you need more
* than 10 names, you must request a quota increase. For more information, see Quotas.
*
* The maximum length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by
* periods. No label can be longer than 63 octets. Consider the following examples:
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253
* octets (63+1+63+1+63+1+61) and no label exceeds 63 octets.
*
*
* -
*
* (64 octets).(63 octets).(63 octets).(61 octets) is not legal because the total length exceeds
* 253 octets (64+1+63+1+63+1+61) and the first label exceeds 63 octets.
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(62 octets) is not legal because the total length of the
* DNS name (63+1+63+1+63+1+62) exceeds 253 octets.
*
*
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withSubjectAlternativeNames(String... subjectAlternativeNames) {
if (this.subjectAlternativeNames == null) {
setSubjectAlternativeNames(new java.util.ArrayList(subjectAlternativeNames.length));
}
for (String ele : subjectAlternativeNames) {
this.subjectAlternativeNames.add(ele);
}
return this;
}
/**
*
* Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For example,
* add the name www.example.net to a certificate for which the DomainName field is www.example.com if
* users can reach your site by using either name. The maximum number of domain names that you can add to an ACM
* certificate is 100. However, the initial quota is 10 domain names. If you need more than 10 names, you must
* request a quota increase. For more information, see Quotas.
*
*
* The maximum length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by periods.
* No label can be longer than 63 octets. Consider the following examples:
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253 octets
* (63+1+63+1+63+1+61) and no label exceeds 63 octets.
*
*
* -
*
* (64 octets).(63 octets).(63 octets).(61 octets) is not legal because the total length exceeds 253
* octets (64+1+63+1+63+1+61) and the first label exceeds 63 octets.
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(62 octets) is not legal because the total length of the DNS
* name (63+1+63+1+63+1+62) exceeds 253 octets.
*
*
*
*
* @param subjectAlternativeNames
* Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For
* example, add the name www.example.net to a certificate for which the DomainName field is
* www.example.com if users can reach your site by using either name. The maximum number of domain names that
* you can add to an ACM certificate is 100. However, the initial quota is 10 domain names. If you need more
* than 10 names, you must request a quota increase. For more information, see Quotas.
*
* The maximum length of a SAN DNS name is 253 octets. The name is made up of multiple labels separated by
* periods. No label can be longer than 63 octets. Consider the following examples:
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(61 octets) is legal because the total length is 253
* octets (63+1+63+1+63+1+61) and no label exceeds 63 octets.
*
*
* -
*
* (64 octets).(63 octets).(63 octets).(61 octets) is not legal because the total length exceeds
* 253 octets (64+1+63+1+63+1+61) and the first label exceeds 63 octets.
*
*
* -
*
* (63 octets).(63 octets).(63 octets).(62 octets) is not legal because the total length of the
* DNS name (63+1+63+1+63+1+62) exceeds 253 octets.
*
*
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withSubjectAlternativeNames(java.util.Collection subjectAlternativeNames) {
setSubjectAlternativeNames(subjectAlternativeNames);
return this;
}
/**
*
* Customer chosen string that can be used to distinguish between calls to RequestCertificate.
* Idempotency tokens time out after one hour. Therefore, if you call RequestCertificate multiple times
* with the same idempotency token within one hour, ACM recognizes that you are requesting only one certificate and
* will issue only one. If you change the idempotency token for each call, ACM recognizes that you are requesting
* multiple certificates.
*
*
* @param idempotencyToken
* Customer chosen string that can be used to distinguish between calls to RequestCertificate.
* Idempotency tokens time out after one hour. Therefore, if you call RequestCertificate
* multiple times with the same idempotency token within one hour, ACM recognizes that you are requesting
* only one certificate and will issue only one. If you change the idempotency token for each call, ACM
* recognizes that you are requesting multiple certificates.
*/
public void setIdempotencyToken(String idempotencyToken) {
this.idempotencyToken = idempotencyToken;
}
/**
*
* Customer chosen string that can be used to distinguish between calls to RequestCertificate.
* Idempotency tokens time out after one hour. Therefore, if you call RequestCertificate multiple times
* with the same idempotency token within one hour, ACM recognizes that you are requesting only one certificate and
* will issue only one. If you change the idempotency token for each call, ACM recognizes that you are requesting
* multiple certificates.
*
*
* @return Customer chosen string that can be used to distinguish between calls to RequestCertificate.
* Idempotency tokens time out after one hour. Therefore, if you call RequestCertificate
* multiple times with the same idempotency token within one hour, ACM recognizes that you are requesting
* only one certificate and will issue only one. If you change the idempotency token for each call, ACM
* recognizes that you are requesting multiple certificates.
*/
public String getIdempotencyToken() {
return this.idempotencyToken;
}
/**
*
* Customer chosen string that can be used to distinguish between calls to RequestCertificate.
* Idempotency tokens time out after one hour. Therefore, if you call RequestCertificate multiple times
* with the same idempotency token within one hour, ACM recognizes that you are requesting only one certificate and
* will issue only one. If you change the idempotency token for each call, ACM recognizes that you are requesting
* multiple certificates.
*
*
* @param idempotencyToken
* Customer chosen string that can be used to distinguish between calls to RequestCertificate.
* Idempotency tokens time out after one hour. Therefore, if you call RequestCertificate
* multiple times with the same idempotency token within one hour, ACM recognizes that you are requesting
* only one certificate and will issue only one. If you change the idempotency token for each call, ACM
* recognizes that you are requesting multiple certificates.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withIdempotencyToken(String idempotencyToken) {
setIdempotencyToken(idempotencyToken);
return this;
}
/**
*
* The domain name that you want ACM to use to send you emails so that you can validate domain ownership.
*
*
* @return The domain name that you want ACM to use to send you emails so that you can validate domain ownership.
*/
public java.util.List getDomainValidationOptions() {
return domainValidationOptions;
}
/**
*
* The domain name that you want ACM to use to send you emails so that you can validate domain ownership.
*
*
* @param domainValidationOptions
* The domain name that you want ACM to use to send you emails so that you can validate domain ownership.
*/
public void setDomainValidationOptions(java.util.Collection domainValidationOptions) {
if (domainValidationOptions == null) {
this.domainValidationOptions = null;
return;
}
this.domainValidationOptions = new java.util.ArrayList(domainValidationOptions);
}
/**
*
* The domain name that you want ACM to use to send you emails so that you can validate domain ownership.
*
*
* NOTE: This method appends the values to the existing list (if any). Use
* {@link #setDomainValidationOptions(java.util.Collection)} or
* {@link #withDomainValidationOptions(java.util.Collection)} if you want to override the existing values.
*
*
* @param domainValidationOptions
* The domain name that you want ACM to use to send you emails so that you can validate domain ownership.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withDomainValidationOptions(DomainValidationOption... domainValidationOptions) {
if (this.domainValidationOptions == null) {
setDomainValidationOptions(new java.util.ArrayList(domainValidationOptions.length));
}
for (DomainValidationOption ele : domainValidationOptions) {
this.domainValidationOptions.add(ele);
}
return this;
}
/**
*
* The domain name that you want ACM to use to send you emails so that you can validate domain ownership.
*
*
* @param domainValidationOptions
* The domain name that you want ACM to use to send you emails so that you can validate domain ownership.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withDomainValidationOptions(java.util.Collection domainValidationOptions) {
setDomainValidationOptions(domainValidationOptions);
return this;
}
/**
*
* Currently, you can use this parameter to specify whether to add the certificate to a certificate transparency
* log. Certificate transparency makes it possible to detect SSL/TLS certificates that have been mistakenly or
* maliciously issued. Certificates that have not been logged typically produce an error message in a browser. For
* more information, see Opting
* Out of Certificate Transparency Logging.
*
*
* @param options
* Currently, you can use this parameter to specify whether to add the certificate to a certificate
* transparency log. Certificate transparency makes it possible to detect SSL/TLS certificates that have been
* mistakenly or maliciously issued. Certificates that have not been logged typically produce an error
* message in a browser. For more information, see Opting Out of Certificate Transparency Logging.
*/
public void setOptions(CertificateOptions options) {
this.options = options;
}
/**
*
* Currently, you can use this parameter to specify whether to add the certificate to a certificate transparency
* log. Certificate transparency makes it possible to detect SSL/TLS certificates that have been mistakenly or
* maliciously issued. Certificates that have not been logged typically produce an error message in a browser. For
* more information, see Opting
* Out of Certificate Transparency Logging.
*
*
* @return Currently, you can use this parameter to specify whether to add the certificate to a certificate
* transparency log. Certificate transparency makes it possible to detect SSL/TLS certificates that have
* been mistakenly or maliciously issued. Certificates that have not been logged typically produce an error
* message in a browser. For more information, see Opting Out of Certificate Transparency Logging.
*/
public CertificateOptions getOptions() {
return this.options;
}
/**
*
* Currently, you can use this parameter to specify whether to add the certificate to a certificate transparency
* log. Certificate transparency makes it possible to detect SSL/TLS certificates that have been mistakenly or
* maliciously issued. Certificates that have not been logged typically produce an error message in a browser. For
* more information, see Opting
* Out of Certificate Transparency Logging.
*
*
* @param options
* Currently, you can use this parameter to specify whether to add the certificate to a certificate
* transparency log. Certificate transparency makes it possible to detect SSL/TLS certificates that have been
* mistakenly or maliciously issued. Certificates that have not been logged typically produce an error
* message in a browser. For more information, see Opting Out of Certificate Transparency Logging.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withOptions(CertificateOptions options) {
setOptions(options);
return this;
}
/**
*
* The Amazon Resource Name (ARN) of the private certificate authority (CA) that will be used to issue the
* certificate. If you do not provide an ARN and you are trying to request a private certificate, ACM will attempt
* to issue a public certificate. For more information about private CAs, see the Amazon Web Services Private
* Certificate Authority user guide. The ARN must have the following form:
*
*
* arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
*
*
* @param certificateAuthorityArn
* The Amazon Resource Name (ARN) of the private certificate authority (CA) that will be used to issue the
* certificate. If you do not provide an ARN and you are trying to request a private certificate, ACM will
* attempt to issue a public certificate. For more information about private CAs, see the Amazon Web Services Private
* Certificate Authority user guide. The ARN must have the following form:
*
* arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
*/
public void setCertificateAuthorityArn(String certificateAuthorityArn) {
this.certificateAuthorityArn = certificateAuthorityArn;
}
/**
*
* The Amazon Resource Name (ARN) of the private certificate authority (CA) that will be used to issue the
* certificate. If you do not provide an ARN and you are trying to request a private certificate, ACM will attempt
* to issue a public certificate. For more information about private CAs, see the Amazon Web Services Private
* Certificate Authority user guide. The ARN must have the following form:
*
*
* arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
*
*
* @return The Amazon Resource Name (ARN) of the private certificate authority (CA) that will be used to issue the
* certificate. If you do not provide an ARN and you are trying to request a private certificate, ACM will
* attempt to issue a public certificate. For more information about private CAs, see the Amazon Web Services Private
* Certificate Authority user guide. The ARN must have the following form:
*
* arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
*/
public String getCertificateAuthorityArn() {
return this.certificateAuthorityArn;
}
/**
*
* The Amazon Resource Name (ARN) of the private certificate authority (CA) that will be used to issue the
* certificate. If you do not provide an ARN and you are trying to request a private certificate, ACM will attempt
* to issue a public certificate. For more information about private CAs, see the Amazon Web Services Private
* Certificate Authority user guide. The ARN must have the following form:
*
*
* arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
*
*
* @param certificateAuthorityArn
* The Amazon Resource Name (ARN) of the private certificate authority (CA) that will be used to issue the
* certificate. If you do not provide an ARN and you are trying to request a private certificate, ACM will
* attempt to issue a public certificate. For more information about private CAs, see the Amazon Web Services Private
* Certificate Authority user guide. The ARN must have the following form:
*
* arn:aws:acm-pca:region:account:certificate-authority/12345678-1234-1234-1234-123456789012
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withCertificateAuthorityArn(String certificateAuthorityArn) {
setCertificateAuthorityArn(certificateAuthorityArn);
return this;
}
/**
*
* One or more resource tags to associate with the certificate.
*
*
* @return One or more resource tags to associate with the certificate.
*/
public java.util.List getTags() {
return tags;
}
/**
*
* One or more resource tags to associate with the certificate.
*
*
* @param tags
* One or more resource tags to associate with the certificate.
*/
public void setTags(java.util.Collection tags) {
if (tags == null) {
this.tags = null;
return;
}
this.tags = new java.util.ArrayList(tags);
}
/**
*
* One or more resource tags to associate with the certificate.
*
*
* NOTE: This method appends the values to the existing list (if any). Use
* {@link #setTags(java.util.Collection)} or {@link #withTags(java.util.Collection)} if you want to override the
* existing values.
*
*
* @param tags
* One or more resource tags to associate with the certificate.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withTags(Tag... tags) {
if (this.tags == null) {
setTags(new java.util.ArrayList(tags.length));
}
for (Tag ele : tags) {
this.tags.add(ele);
}
return this;
}
/**
*
* One or more resource tags to associate with the certificate.
*
*
* @param tags
* One or more resource tags to associate with the certificate.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public RequestCertificateRequest withTags(java.util.Collection tags) {
setTags(tags);
return this;
}
/**
*
* Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data. RSA is the
* default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA) keys are smaller,
* offering security comparable to RSA keys but with greater computing efficiency. However, ECDSA is not supported
* by all network clients. Some AWS services may require RSA keys, or only support ECDSA keys of a particular size,
* while others allow the use of either RSA and ECDSA keys to ensure that compatibility is not broken. Check the
* requirements for the AWS service where you plan to deploy your certificate.
*
*
* Default: RSA_2048
*
*
* @param keyAlgorithm
* Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data. RSA
* is the default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA) keys
* are smaller, offering security comparable to RSA keys but with greater computing efficiency. However,
* ECDSA is not supported by all network clients. Some AWS services may require RSA keys, or only support
* ECDSA keys of a particular size, while others allow the use of either RSA and ECDSA keys to ensure that
* compatibility is not broken. Check the requirements for the AWS service where you plan to deploy your
* certificate.
*
* Default: RSA_2048
* @see KeyAlgorithm
*/
public void setKeyAlgorithm(String keyAlgorithm) {
this.keyAlgorithm = keyAlgorithm;
}
/**
*
* Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data. RSA is the
* default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA) keys are smaller,
* offering security comparable to RSA keys but with greater computing efficiency. However, ECDSA is not supported
* by all network clients. Some AWS services may require RSA keys, or only support ECDSA keys of a particular size,
* while others allow the use of either RSA and ECDSA keys to ensure that compatibility is not broken. Check the
* requirements for the AWS service where you plan to deploy your certificate.
*
*
* Default: RSA_2048
*
*
* @return Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data.
* RSA is the default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA)
* keys are smaller, offering security comparable to RSA keys but with greater computing efficiency.
* However, ECDSA is not supported by all network clients. Some AWS services may require RSA keys, or only
* support ECDSA keys of a particular size, while others allow the use of either RSA and ECDSA keys to
* ensure that compatibility is not broken. Check the requirements for the AWS service where you plan to
* deploy your certificate.
*
* Default: RSA_2048
* @see KeyAlgorithm
*/
public String getKeyAlgorithm() {
return this.keyAlgorithm;
}
/**
*
* Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data. RSA is the
* default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA) keys are smaller,
* offering security comparable to RSA keys but with greater computing efficiency. However, ECDSA is not supported
* by all network clients. Some AWS services may require RSA keys, or only support ECDSA keys of a particular size,
* while others allow the use of either RSA and ECDSA keys to ensure that compatibility is not broken. Check the
* requirements for the AWS service where you plan to deploy your certificate.
*
*
* Default: RSA_2048
*
*
* @param keyAlgorithm
* Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data. RSA
* is the default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA) keys
* are smaller, offering security comparable to RSA keys but with greater computing efficiency. However,
* ECDSA is not supported by all network clients. Some AWS services may require RSA keys, or only support
* ECDSA keys of a particular size, while others allow the use of either RSA and ECDSA keys to ensure that
* compatibility is not broken. Check the requirements for the AWS service where you plan to deploy your
* certificate.
*
* Default: RSA_2048
* @return Returns a reference to this object so that method calls can be chained together.
* @see KeyAlgorithm
*/
public RequestCertificateRequest withKeyAlgorithm(String keyAlgorithm) {
setKeyAlgorithm(keyAlgorithm);
return this;
}
/**
*
* Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data. RSA is the
* default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA) keys are smaller,
* offering security comparable to RSA keys but with greater computing efficiency. However, ECDSA is not supported
* by all network clients. Some AWS services may require RSA keys, or only support ECDSA keys of a particular size,
* while others allow the use of either RSA and ECDSA keys to ensure that compatibility is not broken. Check the
* requirements for the AWS service where you plan to deploy your certificate.
*
*
* Default: RSA_2048
*
*
* @param keyAlgorithm
* Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data. RSA
* is the default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA) keys
* are smaller, offering security comparable to RSA keys but with greater computing efficiency. However,
* ECDSA is not supported by all network clients. Some AWS services may require RSA keys, or only support
* ECDSA keys of a particular size, while others allow the use of either RSA and ECDSA keys to ensure that
* compatibility is not broken. Check the requirements for the AWS service where you plan to deploy your
* certificate.
*
* Default: RSA_2048
* @return Returns a reference to this object so that method calls can be chained together.
* @see KeyAlgorithm
*/
public RequestCertificateRequest withKeyAlgorithm(KeyAlgorithm keyAlgorithm) {
this.keyAlgorithm = keyAlgorithm.toString();
return this;
}
/**
* Returns a string representation of this object. This is useful for testing and debugging. Sensitive data will be
* redacted from this string using a placeholder value.
*
* @return A string representation of this object.
*
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{");
if (getDomainName() != null)
sb.append("DomainName: ").append(getDomainName()).append(",");
if (getValidationMethod() != null)
sb.append("ValidationMethod: ").append(getValidationMethod()).append(",");
if (getSubjectAlternativeNames() != null)
sb.append("SubjectAlternativeNames: ").append(getSubjectAlternativeNames()).append(",");
if (getIdempotencyToken() != null)
sb.append("IdempotencyToken: ").append(getIdempotencyToken()).append(",");
if (getDomainValidationOptions() != null)
sb.append("DomainValidationOptions: ").append(getDomainValidationOptions()).append(",");
if (getOptions() != null)
sb.append("Options: ").append(getOptions()).append(",");
if (getCertificateAuthorityArn() != null)
sb.append("CertificateAuthorityArn: ").append(getCertificateAuthorityArn()).append(",");
if (getTags() != null)
sb.append("Tags: ").append(getTags()).append(",");
if (getKeyAlgorithm() != null)
sb.append("KeyAlgorithm: ").append(getKeyAlgorithm());
sb.append("}");
return sb.toString();
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (obj instanceof RequestCertificateRequest == false)
return false;
RequestCertificateRequest other = (RequestCertificateRequest) obj;
if (other.getDomainName() == null ^ this.getDomainName() == null)
return false;
if (other.getDomainName() != null && other.getDomainName().equals(this.getDomainName()) == false)
return false;
if (other.getValidationMethod() == null ^ this.getValidationMethod() == null)
return false;
if (other.getValidationMethod() != null && other.getValidationMethod().equals(this.getValidationMethod()) == false)
return false;
if (other.getSubjectAlternativeNames() == null ^ this.getSubjectAlternativeNames() == null)
return false;
if (other.getSubjectAlternativeNames() != null && other.getSubjectAlternativeNames().equals(this.getSubjectAlternativeNames()) == false)
return false;
if (other.getIdempotencyToken() == null ^ this.getIdempotencyToken() == null)
return false;
if (other.getIdempotencyToken() != null && other.getIdempotencyToken().equals(this.getIdempotencyToken()) == false)
return false;
if (other.getDomainValidationOptions() == null ^ this.getDomainValidationOptions() == null)
return false;
if (other.getDomainValidationOptions() != null && other.getDomainValidationOptions().equals(this.getDomainValidationOptions()) == false)
return false;
if (other.getOptions() == null ^ this.getOptions() == null)
return false;
if (other.getOptions() != null && other.getOptions().equals(this.getOptions()) == false)
return false;
if (other.getCertificateAuthorityArn() == null ^ this.getCertificateAuthorityArn() == null)
return false;
if (other.getCertificateAuthorityArn() != null && other.getCertificateAuthorityArn().equals(this.getCertificateAuthorityArn()) == false)
return false;
if (other.getTags() == null ^ this.getTags() == null)
return false;
if (other.getTags() != null && other.getTags().equals(this.getTags()) == false)
return false;
if (other.getKeyAlgorithm() == null ^ this.getKeyAlgorithm() == null)
return false;
if (other.getKeyAlgorithm() != null && other.getKeyAlgorithm().equals(this.getKeyAlgorithm()) == false)
return false;
return true;
}
@Override
public int hashCode() {
final int prime = 31;
int hashCode = 1;
hashCode = prime * hashCode + ((getDomainName() == null) ? 0 : getDomainName().hashCode());
hashCode = prime * hashCode + ((getValidationMethod() == null) ? 0 : getValidationMethod().hashCode());
hashCode = prime * hashCode + ((getSubjectAlternativeNames() == null) ? 0 : getSubjectAlternativeNames().hashCode());
hashCode = prime * hashCode + ((getIdempotencyToken() == null) ? 0 : getIdempotencyToken().hashCode());
hashCode = prime * hashCode + ((getDomainValidationOptions() == null) ? 0 : getDomainValidationOptions().hashCode());
hashCode = prime * hashCode + ((getOptions() == null) ? 0 : getOptions().hashCode());
hashCode = prime * hashCode + ((getCertificateAuthorityArn() == null) ? 0 : getCertificateAuthorityArn().hashCode());
hashCode = prime * hashCode + ((getTags() == null) ? 0 : getTags().hashCode());
hashCode = prime * hashCode + ((getKeyAlgorithm() == null) ? 0 : getKeyAlgorithm().hashCode());
return hashCode;
}
@Override
public RequestCertificateRequest clone() {
return (RequestCertificateRequest) super.clone();
}
}