Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BillingRecord

type BillingRecord struct {

	// The date that the operation was billed, in Unix format.
	BillDate *time.Time

	// The name of the domain that the billing record applies to. If the domain name
	// contains characters other than a-z, 0-9, and - (hyphen), such as an
	// internationalized domain name, then this value is in Punycode. For more
	// information, see DNS Domain Name Format
	// (https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DomainNameFormat.html)
	// in the Amazon Route 53 Developer Guide.
	DomainName *string

	// The ID of the invoice that is associated with the billing record.
	InvoiceId *string

	// The operation that you were charged for.
	Operation OperationType

	// The price that you were charged for the operation, in US dollars. Example value:
	// 12.0
	Price float64
}

    Information for one billing record.

    type ContactDetail

    type ContactDetail struct {
    
    	// First line of the contact's address.
    	AddressLine1 *string
    
    	// Second line of contact's address, if any.
    	AddressLine2 *string
    
    	// The city of the contact's address.
    	City *string
    
    	// Indicates whether the contact is a person, company, association, or public
    	// organization. Note the following:
    	//
    	// * If you specify a value other than PERSON,
    	// you must also specify a value for OrganizationName.
    	//
    	// * For some TLDs, the
    	// privacy protection available depends on the value that you specify for Contact
    	// Type. For the privacy protection settings for your TLD, see Domains that You Can
    	// Register with Amazon Route 53
    	// (https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/registrar-tld-list.html)
    	// in the Amazon Route 53 Developer Guide
    	//
    	// * For .es domains, if you specify
    	// PERSON, you must specify INDIVIDUAL for the value of ES_LEGAL_FORM.
    	ContactType ContactType
    
    	// Code for the country of the contact's address.
    	CountryCode CountryCode
    
    	// Email address of the contact.
    	Email *string
    
    	// A list of name-value pairs for parameters required by certain top-level domains.
    	ExtraParams []ExtraParam
    
    	// Fax number of the contact. Constraints: Phone number must be specified in the
    	// format "+[country dialing code].[number including any area code]". For example,
    	// a US phone number might appear as "+1.1234567890".
    	Fax *string
    
    	// First name of contact.
    	FirstName *string
    
    	// Last name of contact.
    	LastName *string
    
    	// Name of the organization for contact types other than PERSON.
    	OrganizationName *string
    
    	// The phone number of the contact. Constraints: Phone number must be specified in
    	// the format "+[country dialing code].[number including any area code>]". For
    	// example, a US phone number might appear as "+1.1234567890".
    	PhoneNumber *string
    
    	// The state or province of the contact's city.
    	State *string
    
    	// The zip or postal code of the contact's address.
    	ZipCode *string
    }

      ContactDetail includes the following elements.

      type ContactType

      type ContactType string
      const (
      	ContactTypePerson      ContactType = "PERSON"
      	ContactTypeCompany     ContactType = "COMPANY"
      	ContactTypeAssociation ContactType = "ASSOCIATION"
      	ContactTypePublicBody  ContactType = "PUBLIC_BODY"
      	ContactTypeReseller    ContactType = "RESELLER"
      )

        Enum values for ContactType

        func (ContactType) Values

        func (ContactType) Values() []ContactType

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

          type CountryCode string
          const (
          	CountryCodeAd CountryCode = "AD"
          	CountryCodeAe CountryCode = "AE"
          	CountryCodeAf CountryCode = "AF"
          	CountryCodeAg CountryCode = "AG"
          	CountryCodeAi CountryCode = "AI"
          	CountryCodeAl CountryCode = "AL"
          	CountryCodeAm CountryCode = "AM"
          	CountryCodeAn CountryCode = "AN"
          	CountryCodeAo CountryCode = "AO"
          	CountryCodeAq CountryCode = "AQ"
          	CountryCodeAr CountryCode = "AR"
          	CountryCodeAs CountryCode = "AS"
          	CountryCodeAt CountryCode = "AT"
          	CountryCodeAu CountryCode = "AU"
          	CountryCodeAw CountryCode = "AW"
          	CountryCodeAz CountryCode = "AZ"
          	CountryCodeBa CountryCode = "BA"
          	CountryCodeBb CountryCode = "BB"
          	CountryCodeBd CountryCode = "BD"
          	CountryCodeBe CountryCode = "BE"
          	CountryCodeBf CountryCode = "BF"
          	CountryCodeBg CountryCode = "BG"
          	CountryCodeBh CountryCode = "BH"
          	CountryCodeBi CountryCode = "BI"
          	CountryCodeBj CountryCode = "BJ"
          	CountryCodeBl CountryCode = "BL"
          	CountryCodeBm CountryCode = "BM"
          	CountryCodeBn CountryCode = "BN"
          	CountryCodeBo CountryCode = "BO"
          	CountryCodeBr CountryCode = "BR"
          	CountryCodeBs CountryCode = "BS"
          	CountryCodeBt CountryCode = "BT"
          	CountryCodeBw CountryCode = "BW"
          	CountryCodeBy CountryCode = "BY"
          	CountryCodeBz CountryCode = "BZ"
          	CountryCodeCa CountryCode = "CA"
          	CountryCodeCc CountryCode = "CC"
          	CountryCodeCd CountryCode = "CD"
          	CountryCodeCf CountryCode = "CF"
          	CountryCodeCg CountryCode = "CG"
          	CountryCodeCh CountryCode = "CH"
          	CountryCodeCi CountryCode = "CI"
          	CountryCodeCk CountryCode = "CK"
          	CountryCodeCl CountryCode = "CL"
          	CountryCodeCm CountryCode = "CM"
          	CountryCodeCn CountryCode = "CN"
          	CountryCodeCo CountryCode = "CO"
          	CountryCodeCr CountryCode = "CR"
          	CountryCodeCu CountryCode = "CU"
          	CountryCodeCv CountryCode = "CV"
          	CountryCodeCx CountryCode = "CX"
          	CountryCodeCy CountryCode = "CY"
          	CountryCodeCz CountryCode = "CZ"
          	CountryCodeDe CountryCode = "DE"
          	CountryCodeDj CountryCode = "DJ"
          	CountryCodeDk CountryCode = "DK"
          	CountryCodeDm CountryCode = "DM"
          	CountryCodeDo CountryCode = "DO"
          	CountryCodeDz CountryCode = "DZ"
          	CountryCodeEc CountryCode = "EC"
          	CountryCodeEe CountryCode = "EE"
          	CountryCodeEg CountryCode = "EG"
          	CountryCodeEr CountryCode = "ER"
          	CountryCodeEs CountryCode = "ES"
          	CountryCodeEt CountryCode = "ET"
          	CountryCodeFi CountryCode = "FI"
          	CountryCodeFj CountryCode = "FJ"
          	CountryCodeFk CountryCode = "FK"
          	CountryCodeFm CountryCode = "FM"
          	CountryCodeFo CountryCode = "FO"
          	CountryCodeFr CountryCode = "FR"
          	CountryCodeGa CountryCode = "GA"
          	CountryCodeGb CountryCode = "GB"
          	CountryCodeGd CountryCode = "GD"
          	CountryCodeGe CountryCode = "GE"
          	CountryCodeGh CountryCode = "GH"
          	CountryCodeGi CountryCode = "GI"
          	CountryCodeGl CountryCode = "GL"
          	CountryCodeGm CountryCode = "GM"
          	CountryCodeGn CountryCode = "GN"
          	CountryCodeGq CountryCode = "GQ"
          	CountryCodeGr CountryCode = "GR"
          	CountryCodeGt CountryCode = "GT"
          	CountryCodeGu CountryCode = "GU"
          	CountryCodeGw CountryCode = "GW"
          	CountryCodeGy CountryCode = "GY"
          	CountryCodeHk CountryCode = "HK"
          	CountryCodeHn CountryCode = "HN"
          	CountryCodeHr CountryCode = "HR"
          	CountryCodeHt CountryCode = "HT"
          	CountryCodeHu CountryCode = "HU"
          	CountryCodeId CountryCode = "ID"
          	CountryCodeIe CountryCode = "IE"
          	CountryCodeIl CountryCode = "IL"
          	CountryCodeIm CountryCode = "IM"
          	CountryCodeIn CountryCode = "IN"
          	CountryCodeIq CountryCode = "IQ"
          	CountryCodeIr CountryCode = "IR"
          	CountryCodeIs CountryCode = "IS"
          	CountryCodeIt CountryCode = "IT"
          	CountryCodeJm CountryCode = "JM"
          	CountryCodeJo CountryCode = "JO"
          	CountryCodeJp CountryCode = "JP"
          	CountryCodeKe CountryCode = "KE"
          	CountryCodeKg CountryCode = "KG"
          	CountryCodeKh CountryCode = "KH"
          	CountryCodeKi CountryCode = "KI"
          	CountryCodeKm CountryCode = "KM"
          	CountryCodeKn CountryCode = "KN"
          	CountryCodeKp CountryCode = "KP"
          	CountryCodeKr CountryCode = "KR"
          	CountryCodeKw CountryCode = "KW"
          	CountryCodeKy CountryCode = "KY"
          	CountryCodeKz CountryCode = "KZ"
          	CountryCodeLa CountryCode = "LA"
          	CountryCodeLb CountryCode = "LB"
          	CountryCodeLc CountryCode = "LC"
          	CountryCodeLi CountryCode = "LI"
          	CountryCodeLk CountryCode = "LK"
          	CountryCodeLr CountryCode = "LR"
          	CountryCodeLs CountryCode = "LS"
          	CountryCodeLt CountryCode = "LT"
          	CountryCodeLu CountryCode = "LU"
          	CountryCodeLv CountryCode = "LV"
          	CountryCodeLy CountryCode = "LY"
          	CountryCodeMa CountryCode = "MA"
          	CountryCodeMc CountryCode = "MC"
          	CountryCodeMd CountryCode = "MD"
          	CountryCodeMe CountryCode = "ME"
          	CountryCodeMf CountryCode = "MF"
          	CountryCodeMg CountryCode = "MG"
          	CountryCodeMh CountryCode = "MH"
          	CountryCodeMk CountryCode = "MK"
          	CountryCodeMl CountryCode = "ML"
          	CountryCodeMm CountryCode = "MM"
          	CountryCodeMn CountryCode = "MN"
          	CountryCodeMo CountryCode = "MO"
          	CountryCodeMp CountryCode = "MP"
          	CountryCodeMr CountryCode = "MR"
          	CountryCodeMs CountryCode = "MS"
          	CountryCodeMt CountryCode = "MT"
          	CountryCodeMu CountryCode = "MU"
          	CountryCodeMv CountryCode = "MV"
          	CountryCodeMw CountryCode = "MW"
          	CountryCodeMx CountryCode = "MX"
          	CountryCodeMy CountryCode = "MY"
          	CountryCodeMz CountryCode = "MZ"
          	CountryCodeNa CountryCode = "NA"
          	CountryCodeNc CountryCode = "NC"
          	CountryCodeNe CountryCode = "NE"
          	CountryCodeNg CountryCode = "NG"
          	CountryCodeNi CountryCode = "NI"
          	CountryCodeNl CountryCode = "NL"
          	CountryCodeNo CountryCode = "NO"
          	CountryCodeNp CountryCode = "NP"
          	CountryCodeNr CountryCode = "NR"
          	CountryCodeNu CountryCode = "NU"
          	CountryCodeNz CountryCode = "NZ"
          	CountryCodeOm CountryCode = "OM"
          	CountryCodePa CountryCode = "PA"
          	CountryCodePe CountryCode = "PE"
          	CountryCodePf CountryCode = "PF"
          	CountryCodePg CountryCode = "PG"
          	CountryCodePh CountryCode = "PH"
          	CountryCodePk CountryCode = "PK"
          	CountryCodePl CountryCode = "PL"
          	CountryCodePm CountryCode = "PM"
          	CountryCodePn CountryCode = "PN"
          	CountryCodePr CountryCode = "PR"
          	CountryCodePt CountryCode = "PT"
          	CountryCodePw CountryCode = "PW"
          	CountryCodePy CountryCode = "PY"
          	CountryCodeQa CountryCode = "QA"
          	CountryCodeRo CountryCode = "RO"
          	CountryCodeRs CountryCode = "RS"
          	CountryCodeRu CountryCode = "RU"
          	CountryCodeRw CountryCode = "RW"
          	CountryCodeSa CountryCode = "SA"
          	CountryCodeSb CountryCode = "SB"
          	CountryCodeSc CountryCode = "SC"
          	CountryCodeSd CountryCode = "SD"
          	CountryCodeSe CountryCode = "SE"
          	CountryCodeSg CountryCode = "SG"
          	CountryCodeSh CountryCode = "SH"
          	CountryCodeSi CountryCode = "SI"
          	CountryCodeSk CountryCode = "SK"
          	CountryCodeSl CountryCode = "SL"
          	CountryCodeSm CountryCode = "SM"
          	CountryCodeSn CountryCode = "SN"
          	CountryCodeSo CountryCode = "SO"
          	CountryCodeSr CountryCode = "SR"
          	CountryCodeSt CountryCode = "ST"
          	CountryCodeSv CountryCode = "SV"
          	CountryCodeSy CountryCode = "SY"
          	CountryCodeSz CountryCode = "SZ"
          	CountryCodeTc CountryCode = "TC"
          	CountryCodeTd CountryCode = "TD"
          	CountryCodeTg CountryCode = "TG"
          	CountryCodeTh CountryCode = "TH"
          	CountryCodeTj CountryCode = "TJ"
          	CountryCodeTk CountryCode = "TK"
          	CountryCodeTl CountryCode = "TL"
          	CountryCodeTm CountryCode = "TM"
          	CountryCodeTn CountryCode = "TN"
          	CountryCodeTo CountryCode = "TO"
          	CountryCodeTr CountryCode = "TR"
          	CountryCodeTt CountryCode = "TT"
          	CountryCodeTv CountryCode = "TV"
          	CountryCodeTw CountryCode = "TW"
          	CountryCodeTz CountryCode = "TZ"
          	CountryCodeUa CountryCode = "UA"
          	CountryCodeUg CountryCode = "UG"
          	CountryCodeUs CountryCode = "US"
          	CountryCodeUy CountryCode = "UY"
          	CountryCodeUz CountryCode = "UZ"
          	CountryCodeVa CountryCode = "VA"
          	CountryCodeVc CountryCode = "VC"
          	CountryCodeVe CountryCode = "VE"
          	CountryCodeVg CountryCode = "VG"
          	CountryCodeVi CountryCode = "VI"
          	CountryCodeVn CountryCode = "VN"
          	CountryCodeVu CountryCode = "VU"
          	CountryCodeWf CountryCode = "WF"
          	CountryCodeWs CountryCode = "WS"
          	CountryCodeYe CountryCode = "YE"
          	CountryCodeYt CountryCode = "YT"
          	CountryCodeZa CountryCode = "ZA"
          	CountryCodeZm CountryCode = "ZM"
          	CountryCodeZw CountryCode = "ZW"
          )

            Enum values for CountryCode

            func (CountryCode) Values

            func (CountryCode) Values() []CountryCode

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

              type DomainAvailability string
              const (
              	DomainAvailabilityAvailable             DomainAvailability = "AVAILABLE"
              	DomainAvailabilityAvailableReserved     DomainAvailability = "AVAILABLE_RESERVED"
              	DomainAvailabilityAvailablePreorder     DomainAvailability = "AVAILABLE_PREORDER"
              	DomainAvailabilityUnavailable           DomainAvailability = "UNAVAILABLE"
              	DomainAvailabilityUnavailablePremium    DomainAvailability = "UNAVAILABLE_PREMIUM"
              	DomainAvailabilityUnavailableRestricted DomainAvailability = "UNAVAILABLE_RESTRICTED"
              	DomainAvailabilityReserved              DomainAvailability = "RESERVED"
              	DomainAvailabilityDontKnow              DomainAvailability = "DONT_KNOW"
              )

                Enum values for DomainAvailability

                func (DomainAvailability) Values

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

                  type DomainLimitExceeded struct {
                  	Message *string
                  }

                    The number of domains has exceeded the allowed threshold for the account.

                    func (*DomainLimitExceeded) Error

                    func (e *DomainLimitExceeded) Error() string

                    func (*DomainLimitExceeded) ErrorCode

                    func (e *DomainLimitExceeded) ErrorCode() string

                    func (*DomainLimitExceeded) ErrorFault

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

                    func (*DomainLimitExceeded) ErrorMessage

                    func (e *DomainLimitExceeded) ErrorMessage() string

                    type DomainSuggestion

                    type DomainSuggestion struct {
                    
                    	// Whether the domain name is available for registering. You can register only the
                    	// domains that are designated as AVAILABLE. Valid values: AVAILABLE The domain
                    	// name is available. AVAILABLE_RESERVED The domain name is reserved under specific
                    	// conditions. AVAILABLE_PREORDER The domain name is available and can be
                    	// preordered. DONT_KNOW The TLD registry didn't reply with a definitive answer
                    	// about whether the domain name is available. Route 53 can return this response
                    	// for a variety of reasons, for example, the registry is performing maintenance.
                    	// Try again later. PENDING The TLD registry didn't return a response in the
                    	// expected amount of time. When the response is delayed, it usually takes just a
                    	// few extra seconds. You can resubmit the request immediately. RESERVED The domain
                    	// name has been reserved for another person or organization. UNAVAILABLE The
                    	// domain name is not available. UNAVAILABLE_PREMIUM The domain name is not
                    	// available. UNAVAILABLE_RESTRICTED The domain name is forbidden.
                    	Availability *string
                    
                    	// A suggested domain name.
                    	DomainName *string
                    }

                      Information about one suggested domain name.

                      type DomainSummary

                      type DomainSummary struct {
                      
                      	// The name of the domain that the summary information applies to.
                      	//
                      	// This member is required.
                      	DomainName *string
                      
                      	// Indicates whether the domain is automatically renewed upon expiration.
                      	AutoRenew *bool
                      
                      	// Expiration date of the domain in Unix time format and Coordinated Universal Time
                      	// (UTC).
                      	Expiry *time.Time
                      
                      	// Indicates whether a domain is locked from unauthorized transfer to another
                      	// party.
                      	TransferLock *bool
                      }

                        Summary information about one domain.

                        type DomainTransferability

                        type DomainTransferability struct {
                        
                        	// Whether the domain name can be transferred to Route 53. You can transfer only
                        	// domains that have a value of TRANSFERABLE for Transferable. Valid values:
                        	// TRANSFERABLE The domain name can be transferred to Route 53. UNTRANSFERRABLE The
                        	// domain name can't be transferred to Route 53. DONT_KNOW Reserved for future use.
                        	Transferable Transferable
                        }

                          A complex type that contains information about whether the specified domain can be transferred to Route 53.

                          type DuplicateRequest

                          type DuplicateRequest struct {
                          	Message *string
                          }

                            The request is already in progress for the domain.

                            func (*DuplicateRequest) Error

                            func (e *DuplicateRequest) Error() string

                            func (*DuplicateRequest) ErrorCode

                            func (e *DuplicateRequest) ErrorCode() string

                            func (*DuplicateRequest) ErrorFault

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

                            func (*DuplicateRequest) ErrorMessage

                            func (e *DuplicateRequest) ErrorMessage() string

                            type ExtraParam

                            type ExtraParam struct {
                            
                            	// The name of an additional parameter that is required by a top-level domain. Here
                            	// are the top-level domains that require additional parameters and the names of
                            	// the parameters that they require: .com.au and .net.au
                            	//
                            	// * AU_ID_NUMBER
                            	//
                            	// *
                            	// AU_ID_TYPE Valid values include the following:
                            	//
                            	// * ABN (Australian business
                            	// number)
                            	//
                            	// * ACN (Australian company number)
                            	//
                            	// * TM (Trademark number)
                            	//
                            	// .ca
                            	//
                            	// *
                            	// BRAND_NUMBER
                            	//
                            	// * CA_BUSINESS_ENTITY_TYPE Valid values include the following:
                            	//
                            	// *
                            	// BANK (Bank)
                            	//
                            	// * COMMERCIAL_COMPANY (Commercial company)
                            	//
                            	// * COMPANY (Company)
                            	//
                            	// *
                            	// COOPERATION (Cooperation)
                            	//
                            	// * COOPERATIVE (Cooperative)
                            	//
                            	// * COOPRIX (Cooprix)
                            	//
                            	// *
                            	// CORP (Corporation)
                            	//
                            	// * CREDIT_UNION (Credit union)
                            	//
                            	// * FOMIA (Federation of mutual
                            	// insurance associations)
                            	//
                            	// * INC (Incorporated)
                            	//
                            	// * LTD (Limited)
                            	//
                            	// * LTEE
                            	// (Limitée)
                            	//
                            	// * LLC (Limited liability corporation)
                            	//
                            	// * LLP (Limited liability
                            	// partnership)
                            	//
                            	// * LTE (Lte.)
                            	//
                            	// * MBA (Mutual benefit association)
                            	//
                            	// * MIC (Mutual
                            	// insurance company)
                            	//
                            	// * NFP (Not-for-profit corporation)
                            	//
                            	// * SA (S.A.)
                            	//
                            	// *
                            	// SAVINGS_COMPANY (Savings company)
                            	//
                            	// * SAVINGS_UNION (Savings union)
                            	//
                            	// * SARL
                            	// (Société à responsabilité limitée)
                            	//
                            	// * TRUST (Trust)
                            	//
                            	// * ULC (Unlimited liability
                            	// corporation)
                            	//
                            	// * CA_LEGAL_TYPE When ContactType is PERSON, valid values include
                            	// the following:
                            	//
                            	// * ABO (Aboriginal Peoples indigenous to Canada)
                            	//
                            	// * CCT (Canadian
                            	// citizen)
                            	//
                            	// * LGR (Legal Representative of a Canadian Citizen or Permanent
                            	// Resident)
                            	//
                            	// * RES (Permanent resident of Canada)
                            	//
                            	// When ContactType is a value
                            	// other than PERSON, valid values include the following:
                            	//
                            	// * ASS (Canadian
                            	// unincorporated association)
                            	//
                            	// * CCO (Canadian corporation)
                            	//
                            	// * EDU (Canadian
                            	// educational institution)
                            	//
                            	// * GOV (Government or government entity in Canada)
                            	//
                            	// *
                            	// HOP (Canadian Hospital)
                            	//
                            	// * INB (Indian Band recognized by the Indian Act of
                            	// Canada)
                            	//
                            	// * LAM (Canadian Library, Archive, or Museum)
                            	//
                            	// * MAJ (Her/His Majesty
                            	// the Queen/King)
                            	//
                            	// * OMK (Official mark registered in Canada)
                            	//
                            	// * PLT (Canadian
                            	// Political Party)
                            	//
                            	// * PRT (Partnership Registered in Canada)
                            	//
                            	// * TDM (Trademark
                            	// registered in Canada)
                            	//
                            	// * TRD (Canadian Trade Union)
                            	//
                            	// * TRS (Trust established in
                            	// Canada)
                            	//
                            	// .es
                            	//
                            	// * ES_IDENTIFICATION Specify the applicable value:
                            	//
                            	// * For contacts
                            	// inside Spain: Enter your passport ID.
                            	//
                            	// * For contacts outside of Spain: Enter
                            	// the VAT identification number for the company. For .es domains, the value of
                            	// ContactType must be PERSON.
                            	//
                            	// * ES_IDENTIFICATION_TYPE Valid values include the
                            	// following:
                            	//
                            	// * DNI_AND_NIF (For Spanish contacts)
                            	//
                            	// * NIE (For foreigners with
                            	// legal residence)
                            	//
                            	// * OTHER (For contacts outside of Spain)
                            	//
                            	// * ES_LEGAL_FORM Valid
                            	// values include the following:
                            	//
                            	// * ASSOCIATION
                            	//
                            	// * CENTRAL_GOVERNMENT_BODY
                            	//
                            	// *
                            	// CIVIL_SOCIETY
                            	//
                            	// * COMMUNITY_OF_OWNERS
                            	//
                            	// * COMMUNITY_PROPERTY
                            	//
                            	// * CONSULATE
                            	//
                            	// *
                            	// COOPERATIVE
                            	//
                            	// * DESIGNATION_OF_ORIGIN_SUPERVISORY_COUNCIL
                            	//
                            	// *
                            	// ECONOMIC_INTEREST_GROUP
                            	//
                            	// * EMBASSY
                            	//
                            	// * ENTITY_MANAGING_NATURAL_AREAS
                            	//
                            	// *
                            	// FARM_PARTNERSHIP
                            	//
                            	// * FOUNDATION
                            	//
                            	// * GENERAL_AND_LIMITED_PARTNERSHIP
                            	//
                            	// *
                            	// GENERAL_PARTNERSHIP
                            	//
                            	// * INDIVIDUAL
                            	//
                            	// * LIMITED_COMPANY
                            	//
                            	// * LOCAL_AUTHORITY
                            	//
                            	// *
                            	// LOCAL_PUBLIC_ENTITY
                            	//
                            	// * MUTUAL_INSURANCE_COMPANY
                            	//
                            	// * NATIONAL_PUBLIC_ENTITY
                            	//
                            	// *
                            	// ORDER_OR_RELIGIOUS_INSTITUTION
                            	//
                            	// * OTHERS (Only for contacts outside of Spain)
                            	//
                            	// *
                            	// POLITICAL_PARTY
                            	//
                            	// * PROFESSIONAL_ASSOCIATION
                            	//
                            	// * PUBLIC_LAW_ASSOCIATION
                            	//
                            	// *
                            	// PUBLIC_LIMITED_COMPANY
                            	//
                            	// * REGIONAL_GOVERNMENT_BODY
                            	//
                            	// * REGIONAL_PUBLIC_ENTITY
                            	//
                            	// *
                            	// SAVINGS_BANK
                            	//
                            	// * SPANISH_OFFICE
                            	//
                            	// * SPORTS_ASSOCIATION
                            	//
                            	// * SPORTS_FEDERATION
                            	//
                            	// *
                            	// SPORTS_LIMITED_COMPANY
                            	//
                            	// * TEMPORARY_ALLIANCE_OF_ENTERPRISES
                            	//
                            	// * TRADE_UNION
                            	//
                            	// *
                            	// WORKER_OWNED_COMPANY
                            	//
                            	// * WORKER_OWNED_LIMITED_COMPANY
                            	//
                            	// .fi
                            	//
                            	// *
                            	// BIRTH_DATE_IN_YYYY_MM_DD
                            	//
                            	// * FI_BUSINESS_NUMBER
                            	//
                            	// * FI_ID_NUMBER
                            	//
                            	// * FI_NATIONALITY
                            	// Valid values include the following:
                            	//
                            	// * FINNISH
                            	//
                            	// * NOT_FINNISH
                            	//
                            	// *
                            	// FI_ORGANIZATION_TYPE Valid values include the following:
                            	//
                            	// * COMPANY
                            	//
                            	// *
                            	// CORPORATION
                            	//
                            	// * GOVERNMENT
                            	//
                            	// * INSTITUTION
                            	//
                            	// * POLITICAL_PARTY
                            	//
                            	// *
                            	// PUBLIC_COMMUNITY
                            	//
                            	// * TOWNSHIP
                            	//
                            	// .fr
                            	//
                            	// * BIRTH_CITY
                            	//
                            	// * BIRTH_COUNTRY
                            	//
                            	// *
                            	// BIRTH_DATE_IN_YYYY_MM_DD
                            	//
                            	// * BIRTH_DEPARTMENT: Specify the INSEE code that
                            	// corresponds with the department where the contact was born. If the contact was
                            	// born somewhere other than France or its overseas departments, specify 99. For
                            	// more information, including a list of departments and the corresponding INSEE
                            	// numbers, see the Wikipedia entry Departments of France
                            	// (https://en.wikipedia.org/wiki/Departments_of_France).
                            	//
                            	// * BRAND_NUMBER
                            	//
                            	// .it
                            	//
                            	// *
                            	// IT_NATIONALITY
                            	//
                            	// * IT_PIN
                            	//
                            	// * IT_REGISTRANT_ENTITY_TYPE Valid values include the
                            	// following:
                            	//
                            	// * FOREIGNERS
                            	//
                            	// * FREELANCE_WORKERS (Freelance workers and
                            	// professionals)
                            	//
                            	// * ITALIAN_COMPANIES (Italian companies and one-person
                            	// companies)
                            	//
                            	// * NON_PROFIT_ORGANIZATIONS
                            	//
                            	// * OTHER_SUBJECTS
                            	//
                            	// *
                            	// PUBLIC_ORGANIZATIONS
                            	//
                            	// .ru
                            	//
                            	// * BIRTH_DATE_IN_YYYY_MM_DD
                            	//
                            	// *
                            	// RU_PASSPORT_DATA
                            	//
                            	// .se
                            	//
                            	// * BIRTH_COUNTRY
                            	//
                            	// * SE_ID_NUMBER
                            	//
                            	// .sg
                            	//
                            	// *
                            	// SG_ID_NUMBER
                            	//
                            	// .co.uk, .me.uk, and .org.uk
                            	//
                            	// * UK_CONTACT_TYPE Valid values
                            	// include the following:
                            	//
                            	// * CRC (UK Corporation by Royal Charter)
                            	//
                            	// * FCORP (Non-UK
                            	// Corporation)
                            	//
                            	// * FIND (Non-UK Individual, representing self)
                            	//
                            	// * FOTHER (Non-UK
                            	// Entity that does not fit into any other category)
                            	//
                            	// * GOV (UK Government Body)
                            	//
                            	// *
                            	// IND (UK Individual (representing self))
                            	//
                            	// * IP (UK Industrial/Provident
                            	// Registered Company)
                            	//
                            	// * LLP (UK Limited Liability Partnership)
                            	//
                            	// * LTD (UK Limited
                            	// Company)
                            	//
                            	// * OTHER (UK Entity that does not fit into any other category)
                            	//
                            	// * PLC
                            	// (UK Public Limited Company)
                            	//
                            	// * PTNR (UK Partnership)
                            	//
                            	// * RCHAR (UK Registered
                            	// Charity)
                            	//
                            	// * SCH (UK School)
                            	//
                            	// * STAT (UK Statutory Body)
                            	//
                            	// * STRA (UK Sole
                            	// Trader)
                            	//
                            	// * UK_COMPANY_NUMBER
                            	//
                            	// In addition, many TLDs require a VAT_NUMBER.
                            	//
                            	// This member is required.
                            	Name ExtraParamName
                            
                            	// The value that corresponds with the name of an extra parameter.
                            	//
                            	// This member is required.
                            	Value *string
                            }

                              ExtraParam includes the following elements.

                              type ExtraParamName

                              type ExtraParamName string
                              const (
                              	ExtraParamNameDunsNumber                    ExtraParamName = "DUNS_NUMBER"
                              	ExtraParamNameBrandNumber                   ExtraParamName = "BRAND_NUMBER"
                              	ExtraParamNameBirthDepartment               ExtraParamName = "BIRTH_DEPARTMENT"
                              	ExtraParamNameBirthDateInYyyyMmDd           ExtraParamName = "BIRTH_DATE_IN_YYYY_MM_DD"
                              	ExtraParamNameBirthCountry                  ExtraParamName = "BIRTH_COUNTRY"
                              	ExtraParamNameBirthCity                     ExtraParamName = "BIRTH_CITY"
                              	ExtraParamNameDocumentNumber                ExtraParamName = "DOCUMENT_NUMBER"
                              	ExtraParamNameAuIdNumber                    ExtraParamName = "AU_ID_NUMBER"
                              	ExtraParamNameAuIdType                      ExtraParamName = "AU_ID_TYPE"
                              	ExtraParamNameCaLegalType                   ExtraParamName = "CA_LEGAL_TYPE"
                              	ExtraParamNameCaBusinessEntityType          ExtraParamName = "CA_BUSINESS_ENTITY_TYPE"
                              	ExtraParamNameCaLegalRepresentative         ExtraParamName = "CA_LEGAL_REPRESENTATIVE"
                              	ExtraParamNameCaLegalRepresentativeCapacity ExtraParamName = "CA_LEGAL_REPRESENTATIVE_CAPACITY"
                              	ExtraParamNameEsIdentification              ExtraParamName = "ES_IDENTIFICATION"
                              	ExtraParamNameEsIdentificationType          ExtraParamName = "ES_IDENTIFICATION_TYPE"
                              	ExtraParamNameEsLegalForm                   ExtraParamName = "ES_LEGAL_FORM"
                              	ExtraParamNameFiBusinessNumber              ExtraParamName = "FI_BUSINESS_NUMBER"
                              	ExtraParamNameOnwerFiIdNumber               ExtraParamName = "FI_ID_NUMBER"
                              	ExtraParamNameFiNationality                 ExtraParamName = "FI_NATIONALITY"
                              	ExtraParamNameFiOrganizationType            ExtraParamName = "FI_ORGANIZATION_TYPE"
                              	ExtraParamNameItNationality                 ExtraParamName = "IT_NATIONALITY"
                              	ExtraParamNameItPin                         ExtraParamName = "IT_PIN"
                              	ExtraParamNameItRegistrantEntityType        ExtraParamName = "IT_REGISTRANT_ENTITY_TYPE"
                              	ExtraParamNameRuPassportData                ExtraParamName = "RU_PASSPORT_DATA"
                              	ExtraParamNameSeIdNumber                    ExtraParamName = "SE_ID_NUMBER"
                              	ExtraParamNameSgIdNumber                    ExtraParamName = "SG_ID_NUMBER"
                              	ExtraParamNameVatNumber                     ExtraParamName = "VAT_NUMBER"
                              	ExtraParamNameUkContactType                 ExtraParamName = "UK_CONTACT_TYPE"
                              	ExtraParamNameUkCompanyNumber               ExtraParamName = "UK_COMPANY_NUMBER"
                              )

                                Enum values for ExtraParamName

                                func (ExtraParamName) Values

                                func (ExtraParamName) Values() []ExtraParamName

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

                                  type InvalidInput struct {
                                  	Message *string
                                  }

                                    The requested item is not acceptable. For example, for APIs that accept a domain name, the request might specify a domain name that doesn't belong to the account that submitted the request. For AcceptDomainTransferFromAnotherAwsAccount, the password might be invalid.

                                    func (*InvalidInput) Error

                                    func (e *InvalidInput) Error() string

                                    func (*InvalidInput) ErrorCode

                                    func (e *InvalidInput) ErrorCode() string

                                    func (*InvalidInput) ErrorFault

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

                                    func (*InvalidInput) ErrorMessage

                                    func (e *InvalidInput) ErrorMessage() string

                                    type Nameserver

                                    type Nameserver struct {
                                    
                                    	// The fully qualified host name of the name server. Constraint: Maximum 255
                                    	// characters
                                    	//
                                    	// This member is required.
                                    	Name *string
                                    
                                    	// Glue IP address of a name server entry. Glue IP addresses are required only when
                                    	// the name of the name server is a subdomain of the domain. For example, if your
                                    	// domain is example.com and the name server for the domain is ns.example.com, you
                                    	// need to specify the IP address for ns.example.com. Constraints: The list can
                                    	// contain only one IPv4 and one IPv6 address.
                                    	GlueIps []string
                                    }

                                      Nameserver includes the following elements.

                                      type OperationLimitExceeded

                                      type OperationLimitExceeded struct {
                                      	Message *string
                                      }

                                        The number of operations or jobs running exceeded the allowed threshold for the account.

                                        func (*OperationLimitExceeded) Error

                                        func (e *OperationLimitExceeded) Error() string

                                        func (*OperationLimitExceeded) ErrorCode

                                        func (e *OperationLimitExceeded) ErrorCode() string

                                        func (*OperationLimitExceeded) ErrorFault

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

                                        func (*OperationLimitExceeded) ErrorMessage

                                        func (e *OperationLimitExceeded) ErrorMessage() string

                                        type OperationStatus

                                        type OperationStatus string
                                        const (
                                        	OperationStatusSubmitted  OperationStatus = "SUBMITTED"
                                        	OperationStatusInProgress OperationStatus = "IN_PROGRESS"
                                        	OperationStatusError      OperationStatus = "ERROR"
                                        	OperationStatusSuccessful OperationStatus = "SUCCESSFUL"
                                        	OperationStatusFailed     OperationStatus = "FAILED"
                                        )

                                          Enum values for OperationStatus

                                          func (OperationStatus) Values

                                          func (OperationStatus) Values() []OperationStatus

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

                                            type OperationSummary struct {
                                            
                                            	// Identifier returned to track the requested action.
                                            	//
                                            	// This member is required.
                                            	OperationId *string
                                            
                                            	// The current status of the requested operation in the system.
                                            	//
                                            	// This member is required.
                                            	Status OperationStatus
                                            
                                            	// The date when the request was submitted.
                                            	//
                                            	// This member is required.
                                            	SubmittedDate *time.Time
                                            
                                            	// Type of the action requested.
                                            	//
                                            	// This member is required.
                                            	Type OperationType
                                            }

                                              OperationSummary includes the following elements.

                                              type OperationType

                                              type OperationType string
                                              const (
                                              	OperationTypeRegisterDomain            OperationType = "REGISTER_DOMAIN"
                                              	OperationTypeDeleteDomain              OperationType = "DELETE_DOMAIN"
                                              	OperationTypeTransferInDomain          OperationType = "TRANSFER_IN_DOMAIN"
                                              	OperationTypeUpdateDomainContact       OperationType = "UPDATE_DOMAIN_CONTACT"
                                              	OperationTypeUpdateNameserver          OperationType = "UPDATE_NAMESERVER"
                                              	OperationTypeChangePrivacyProtection   OperationType = "CHANGE_PRIVACY_PROTECTION"
                                              	OperationTypeDomainLock                OperationType = "DOMAIN_LOCK"
                                              	OperationTypeEnableAutorenew           OperationType = "ENABLE_AUTORENEW"
                                              	OperationTypeDisableAutorenew          OperationType = "DISABLE_AUTORENEW"
                                              	OperationTypeAddDnssec                 OperationType = "ADD_DNSSEC"
                                              	OperationTypeRemoveDnssec              OperationType = "REMOVE_DNSSEC"
                                              	OperationTypeExpireDomain              OperationType = "EXPIRE_DOMAIN"
                                              	OperationTypeTransferOutDomain         OperationType = "TRANSFER_OUT_DOMAIN"
                                              	OperationTypeChangeDomainOwner         OperationType = "CHANGE_DOMAIN_OWNER"
                                              	OperationTypeRenewDomain               OperationType = "RENEW_DOMAIN"
                                              	OperationTypePushDomain                OperationType = "PUSH_DOMAIN"
                                              	OperationTypeInternalTransferOutDomain OperationType = "INTERNAL_TRANSFER_OUT_DOMAIN"
                                              	OperationTypeInternalTransferInDomain  OperationType = "INTERNAL_TRANSFER_IN_DOMAIN"
                                              )

                                                Enum values for OperationType

                                                func (OperationType) Values

                                                func (OperationType) Values() []OperationType

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

                                                  type ReachabilityStatus string
                                                  const (
                                                  	ReachabilityStatusPending ReachabilityStatus = "PENDING"
                                                  	ReachabilityStatusDone    ReachabilityStatus = "DONE"
                                                  	ReachabilityStatusExpired ReachabilityStatus = "EXPIRED"
                                                  )

                                                    Enum values for ReachabilityStatus

                                                    func (ReachabilityStatus) Values

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

                                                      type TLDRulesViolation struct {
                                                      	Message *string
                                                      }

                                                        The top-level domain does not support this operation.

                                                        func (*TLDRulesViolation) Error

                                                        func (e *TLDRulesViolation) Error() string

                                                        func (*TLDRulesViolation) ErrorCode

                                                        func (e *TLDRulesViolation) ErrorCode() string

                                                        func (*TLDRulesViolation) ErrorFault

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

                                                        func (*TLDRulesViolation) ErrorMessage

                                                        func (e *TLDRulesViolation) ErrorMessage() string

                                                        type Tag

                                                        type Tag struct {
                                                        
                                                        	// The key (name) of a tag. Valid values: A-Z, a-z, 0-9, space, ".:/=+\-@"
                                                        	// Constraints: Each key can be 1-128 characters long.
                                                        	Key *string
                                                        
                                                        	// The value of a tag. Valid values: A-Z, a-z, 0-9, space, ".:/=+\-@" Constraints:
                                                        	// Each value can be 0-256 characters long.
                                                        	Value *string
                                                        }

                                                          Each tag includes the following elements.

                                                          type Transferable

                                                          type Transferable string
                                                          const (
                                                          	TransferableTransferable   Transferable = "TRANSFERABLE"
                                                          	TransferableUntransferable Transferable = "UNTRANSFERABLE"
                                                          	TransferableDontKnow       Transferable = "DONT_KNOW"
                                                          )

                                                            Enum values for Transferable

                                                            func (Transferable) Values

                                                            func (Transferable) Values() []Transferable

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

                                                              type UnsupportedTLD struct {
                                                              	Message *string
                                                              }

                                                                Amazon Route 53 does not support this top-level domain (TLD).

                                                                func (*UnsupportedTLD) Error

                                                                func (e *UnsupportedTLD) Error() string

                                                                func (*UnsupportedTLD) ErrorCode

                                                                func (e *UnsupportedTLD) ErrorCode() string

                                                                func (*UnsupportedTLD) ErrorFault

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

                                                                func (*UnsupportedTLD) ErrorMessage

                                                                func (e *UnsupportedTLD) ErrorMessage() string