custom_hostnames

type CustomHostnameDeleteParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
}

type CustomHostnameDeleteResponse struct {
	// Identifier
	ID   string                           `json:"id"`
	JSON customHostnameDeleteResponseJSON `json:"-"`
}

type CustomHostnameEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// These are per-hostname (customer) settings.
	CustomMetadata param.Field[CustomHostnameEditParamsCustomMetadata] `json:"custom_metadata"`
	// a valid hostname that’s been added to your DNS zone as an A, AAAA, or CNAME
	// record.
	CustomOriginServer param.Field[string] `json:"custom_origin_server"`
	// A hostname that will be sent to your custom origin server as SNI for TLS
	// handshake. This can be a valid subdomain of the zone or custom origin server
	// name or the string ':request_host_header:' which will cause the host header in
	// the request to be used as SNI. Not configurable with default/fallback origin
	// server.
	CustomOriginSni param.Field[string] `json:"custom_origin_sni"`
	// SSL properties used when creating the custom hostname.
	SSL param.Field[CustomHostnameEditParamsSSL] `json:"ssl"`
}

type CustomHostnameEditParamsCustomMetadata struct {
	// Unique metadata for this hostname.
	Key param.Field[string] `json:"key"`
}

type CustomHostnameEditParamsSSL struct {
	// A ubiquitous bundle has the highest probability of being verified everywhere,
	// even by clients using outdated or unusual trust stores. An optimal bundle uses
	// the shortest chain and newest intermediates. And the force bundle verifies the
	// chain, but does not otherwise modify it.
	BundleMethod param.Field[CustomHostnameEditParamsSSLBundleMethod] `json:"bundle_method"`
	// The Certificate Authority that will issue the certificate
	CertificateAuthority param.Field[CustomHostnameEditParamsSSLCertificateAuthority] `json:"certificate_authority"`
	// If a custom uploaded certificate is used.
	CustomCertificate param.Field[string] `json:"custom_certificate"`
	// The key for a custom uploaded certificate.
	CustomKey param.Field[string] `json:"custom_key"`
	// Domain control validation (DCV) method used for this hostname.
	Method param.Field[CustomHostnameEditParamsSSLMethod] `json:"method"`
	// SSL specific settings.
	Settings param.Field[CustomHostnameEditParamsSSLSettings] `json:"settings"`
	// Level of validation to be used for this hostname. Domain validation (dv) must be
	// used.
	Type param.Field[CustomHostnameEditParamsSSLType] `json:"type"`
	// Indicates whether the certificate covers a wildcard.
	Wildcard param.Field[bool] `json:"wildcard"`
}

type CustomHostnameEditParamsSSLBundleMethod string

type CustomHostnameEditParamsSSLCertificateAuthority string

type CustomHostnameEditParamsSSLMethod string

type CustomHostnameEditParamsSSLSettings struct {
	// An allowlist of ciphers for TLS termination. These ciphers must be in the
	// BoringSSL format.
	Ciphers param.Field[[]string] `json:"ciphers"`
	// Whether or not Early Hints is enabled.
	EarlyHints param.Field[CustomHostnameEditParamsSSLSettingsEarlyHints] `json:"early_hints"`
	// Whether or not HTTP2 is enabled.
	HTTP2 param.Field[CustomHostnameEditParamsSSLSettingsHTTP2] `json:"http2"`
	// The minimum TLS version supported.
	MinTLSVersion param.Field[CustomHostnameEditParamsSSLSettingsMinTLSVersion] `json:"min_tls_version"`
	// Whether or not TLS 1.3 is enabled.
	TLS1_3 param.Field[CustomHostnameEditParamsSSLSettingsTLS1_3] `json:"tls_1_3"`
}

type CustomHostnameEditParamsSSLSettingsEarlyHints string

type CustomHostnameEditParamsSSLSettingsHTTP2 string

type CustomHostnameEditParamsSSLSettingsMinTLSVersion string

type CustomHostnameEditParamsSSLSettingsTLS1_3 string

type CustomHostnameEditParamsSSLType string

type CustomHostnameEditResponse struct {
	// Identifier
	ID string `json:"id,required"`
	// The custom hostname that will point to your hostname via CNAME.
	Hostname string `json:"hostname,required"`
	// SSL properties for the custom hostname.
	SSL  CustomHostnameEditResponseSSL  `json:"ssl,required"`
	JSON customHostnameEditResponseJSON `json:"-"`
}

type CustomHostnameEditResponseEnvelope struct {
	Errors   []CustomHostnameEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CustomHostnameEditResponseEnvelopeMessages `json:"messages,required"`
	Result   CustomHostnameEditResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success CustomHostnameEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    customHostnameEditResponseEnvelopeJSON    `json:"-"`
}

type CustomHostnameEditResponseEnvelopeErrors struct {
	Code    int64                                        `json:"code,required"`
	Message string                                       `json:"message,required"`
	JSON    customHostnameEditResponseEnvelopeErrorsJSON `json:"-"`
}

type CustomHostnameEditResponseEnvelopeMessages struct {
	Code    int64                                          `json:"code,required"`
	Message string                                         `json:"message,required"`
	JSON    customHostnameEditResponseEnvelopeMessagesJSON `json:"-"`
}

type CustomHostnameEditResponseEnvelopeSuccess bool

type CustomHostnameEditResponseSSL struct {
	// Custom hostname SSL identifier tag.
	ID string `json:"id"`
	// A ubiquitous bundle has the highest probability of being verified everywhere,
	// even by clients using outdated or unusual trust stores. An optimal bundle uses
	// the shortest chain and newest intermediates. And the force bundle verifies the
	// chain, but does not otherwise modify it.
	BundleMethod CustomHostnameEditResponseSSLBundleMethod `json:"bundle_method"`
	// The Certificate Authority that will issue the certificate
	CertificateAuthority CustomHostnameEditResponseSSLCertificateAuthority `json:"certificate_authority"`
	// If a custom uploaded certificate is used.
	CustomCertificate string `json:"custom_certificate"`
	// The identifier for the Custom CSR that was used.
	CustomCsrID string `json:"custom_csr_id"`
	// The key for a custom uploaded certificate.
	CustomKey string `json:"custom_key"`
	// The time the custom certificate expires on.
	ExpiresOn time.Time `json:"expires_on" format:"date-time"`
	// A list of Hostnames on a custom uploaded certificate.
	Hosts []interface{} `json:"hosts"`
	// The issuer on a custom uploaded certificate.
	Issuer string `json:"issuer"`
	// Domain control validation (DCV) method used for this hostname.
	Method CustomHostnameEditResponseSSLMethod `json:"method"`
	// The serial number on a custom uploaded certificate.
	SerialNumber string `json:"serial_number"`
	// SSL specific settings.
	Settings CustomHostnameEditResponseSSLSettings `json:"settings"`
	// The signature on a custom uploaded certificate.
	Signature string `json:"signature"`
	// Status of the hostname's SSL certificates.
	Status CustomHostnameEditResponseSSLStatus `json:"status"`
	// Level of validation to be used for this hostname. Domain validation (dv) must be
	// used.
	Type CustomHostnameEditResponseSSLType `json:"type"`
	// The time the custom certificate was uploaded.
	UploadedOn time.Time `json:"uploaded_on" format:"date-time"`
	// Domain validation errors that have been received by the certificate authority
	// (CA).
	ValidationErrors  []CustomHostnameEditResponseSSLValidationError  `json:"validation_errors"`
	ValidationRecords []CustomHostnameEditResponseSSLValidationRecord `json:"validation_records"`
	// Indicates whether the certificate covers a wildcard.
	Wildcard bool                              `json:"wildcard"`
	JSON     customHostnameEditResponseSSLJSON `json:"-"`
}

type CustomHostnameEditResponseSSLBundleMethod string

type CustomHostnameEditResponseSSLCertificateAuthority string

type CustomHostnameEditResponseSSLMethod string

type CustomHostnameEditResponseSSLSettings struct {
	// An allowlist of ciphers for TLS termination. These ciphers must be in the
	// BoringSSL format.
	Ciphers []string `json:"ciphers"`
	// Whether or not Early Hints is enabled.
	EarlyHints CustomHostnameEditResponseSSLSettingsEarlyHints `json:"early_hints"`
	// Whether or not HTTP2 is enabled.
	HTTP2 CustomHostnameEditResponseSSLSettingsHTTP2 `json:"http2"`
	// The minimum TLS version supported.
	MinTLSVersion CustomHostnameEditResponseSSLSettingsMinTLSVersion `json:"min_tls_version"`
	// Whether or not TLS 1.3 is enabled.
	TLS1_3 CustomHostnameEditResponseSSLSettingsTLS1_3 `json:"tls_1_3"`
	JSON   customHostnameEditResponseSSLSettingsJSON   `json:"-"`
}

type CustomHostnameEditResponseSSLSettingsEarlyHints string

type CustomHostnameEditResponseSSLSettingsHTTP2 string

type CustomHostnameEditResponseSSLSettingsMinTLSVersion string

type CustomHostnameEditResponseSSLSettingsTLS1_3 string

type CustomHostnameEditResponseSSLStatus string

type CustomHostnameEditResponseSSLType string

type CustomHostnameEditResponseSSLValidationError struct {
	// A domain validation error.
	Message string                                           `json:"message"`
	JSON    customHostnameEditResponseSSLValidationErrorJSON `json:"-"`
}

type CustomHostnameEditResponseSSLValidationRecord struct {
	// The set of email addresses that the certificate authority (CA) will use to
	// complete domain validation.
	Emails []interface{} `json:"emails"`
	// The content that the certificate authority (CA) will expect to find at the
	// http_url during the domain validation.
	HTTPBody string `json:"http_body"`
	// The url that will be checked during domain validation.
	HTTPURL string `json:"http_url"`
	// The hostname that the certificate authority (CA) will check for a TXT record
	// during domain validation .
	TXTName string `json:"txt_name"`
	// The TXT record that the certificate authority (CA) will check during domain
	// validation.
	TXTValue string                                            `json:"txt_value"`
	JSON     customHostnameEditResponseSSLValidationRecordJSON `json:"-"`
}

type CustomHostnameGetParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
}

type CustomHostnameGetResponse struct {
	// Identifier
	ID string `json:"id,required"`
	// The custom hostname that will point to your hostname via CNAME.
	Hostname string `json:"hostname,required"`
	// SSL properties for the custom hostname.
	SSL  CustomHostnameGetResponseSSL  `json:"ssl,required"`
	JSON customHostnameGetResponseJSON `json:"-"`
}

type CustomHostnameGetResponseEnvelope struct {
	Errors   []CustomHostnameGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CustomHostnameGetResponseEnvelopeMessages `json:"messages,required"`
	Result   CustomHostnameGetResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success CustomHostnameGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    customHostnameGetResponseEnvelopeJSON    `json:"-"`
}

type CustomHostnameGetResponseEnvelopeErrors struct {
	Code    int64                                       `json:"code,required"`
	Message string                                      `json:"message,required"`
	JSON    customHostnameGetResponseEnvelopeErrorsJSON `json:"-"`
}

type CustomHostnameGetResponseEnvelopeMessages struct {
	Code    int64                                         `json:"code,required"`
	Message string                                        `json:"message,required"`
	JSON    customHostnameGetResponseEnvelopeMessagesJSON `json:"-"`
}

type CustomHostnameGetResponseEnvelopeSuccess bool

type CustomHostnameGetResponseSSL struct {
	// Custom hostname SSL identifier tag.
	ID string `json:"id"`
	// A ubiquitous bundle has the highest probability of being verified everywhere,
	// even by clients using outdated or unusual trust stores. An optimal bundle uses
	// the shortest chain and newest intermediates. And the force bundle verifies the
	// chain, but does not otherwise modify it.
	BundleMethod CustomHostnameGetResponseSSLBundleMethod `json:"bundle_method"`
	// The Certificate Authority that will issue the certificate
	CertificateAuthority CustomHostnameGetResponseSSLCertificateAuthority `json:"certificate_authority"`
	// If a custom uploaded certificate is used.
	CustomCertificate string `json:"custom_certificate"`
	// The identifier for the Custom CSR that was used.
	CustomCsrID string `json:"custom_csr_id"`
	// The key for a custom uploaded certificate.
	CustomKey string `json:"custom_key"`
	// The time the custom certificate expires on.
	ExpiresOn time.Time `json:"expires_on" format:"date-time"`
	// A list of Hostnames on a custom uploaded certificate.
	Hosts []interface{} `json:"hosts"`
	// The issuer on a custom uploaded certificate.
	Issuer string `json:"issuer"`
	// Domain control validation (DCV) method used for this hostname.
	Method CustomHostnameGetResponseSSLMethod `json:"method"`
	// The serial number on a custom uploaded certificate.
	SerialNumber string `json:"serial_number"`
	// SSL specific settings.
	Settings CustomHostnameGetResponseSSLSettings `json:"settings"`
	// The signature on a custom uploaded certificate.
	Signature string `json:"signature"`
	// Status of the hostname's SSL certificates.
	Status CustomHostnameGetResponseSSLStatus `json:"status"`
	// Level of validation to be used for this hostname. Domain validation (dv) must be
	// used.
	Type CustomHostnameGetResponseSSLType `json:"type"`
	// The time the custom certificate was uploaded.
	UploadedOn time.Time `json:"uploaded_on" format:"date-time"`
	// Domain validation errors that have been received by the certificate authority
	// (CA).
	ValidationErrors  []CustomHostnameGetResponseSSLValidationError  `json:"validation_errors"`
	ValidationRecords []CustomHostnameGetResponseSSLValidationRecord `json:"validation_records"`
	// Indicates whether the certificate covers a wildcard.
	Wildcard bool                             `json:"wildcard"`
	JSON     customHostnameGetResponseSSLJSON `json:"-"`
}

type CustomHostnameGetResponseSSLBundleMethod string

type CustomHostnameGetResponseSSLCertificateAuthority string

type CustomHostnameGetResponseSSLMethod string

type CustomHostnameGetResponseSSLSettings struct {
	// An allowlist of ciphers for TLS termination. These ciphers must be in the
	// BoringSSL format.
	Ciphers []string `json:"ciphers"`
	// Whether or not Early Hints is enabled.
	EarlyHints CustomHostnameGetResponseSSLSettingsEarlyHints `json:"early_hints"`
	// Whether or not HTTP2 is enabled.
	HTTP2 CustomHostnameGetResponseSSLSettingsHTTP2 `json:"http2"`
	// The minimum TLS version supported.
	MinTLSVersion CustomHostnameGetResponseSSLSettingsMinTLSVersion `json:"min_tls_version"`
	// Whether or not TLS 1.3 is enabled.
	TLS1_3 CustomHostnameGetResponseSSLSettingsTLS1_3 `json:"tls_1_3"`
	JSON   customHostnameGetResponseSSLSettingsJSON   `json:"-"`
}

type CustomHostnameGetResponseSSLSettingsEarlyHints string

type CustomHostnameGetResponseSSLSettingsHTTP2 string

type CustomHostnameGetResponseSSLSettingsMinTLSVersion string

type CustomHostnameGetResponseSSLSettingsTLS1_3 string

type CustomHostnameGetResponseSSLStatus string

type CustomHostnameGetResponseSSLType string

type CustomHostnameGetResponseSSLValidationError struct {
	// A domain validation error.
	Message string                                          `json:"message"`
	JSON    customHostnameGetResponseSSLValidationErrorJSON `json:"-"`
}

type CustomHostnameGetResponseSSLValidationRecord struct {
	// The set of email addresses that the certificate authority (CA) will use to
	// complete domain validation.
	Emails []interface{} `json:"emails"`
	// The content that the certificate authority (CA) will expect to find at the
	// http_url during the domain validation.
	HTTPBody string `json:"http_body"`
	// The url that will be checked during domain validation.
	HTTPURL string `json:"http_url"`
	// The hostname that the certificate authority (CA) will check for a TXT record
	// during domain validation .
	TXTName string `json:"txt_name"`
	// The TXT record that the certificate authority (CA) will check during domain
	// validation.
	TXTValue string                                           `json:"txt_value"`
	JSON     customHostnameGetResponseSSLValidationRecordJSON `json:"-"`
}

type CustomHostnameListParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Hostname ID to match against. This ID was generated and returned during the
	// initial custom_hostname creation. This parameter cannot be used with the
	// 'hostname' parameter.
	ID param.Field[string] `query:"id"`
	// Direction to order hostnames.
	Direction param.Field[CustomHostnameListParamsDirection] `query:"direction"`
	// Fully qualified domain name to match against. This parameter cannot be used with
	// the 'id' parameter.
	Hostname param.Field[string] `query:"hostname"`
	// Field to order hostnames by.
	Order param.Field[CustomHostnameListParamsOrder] `query:"order"`
	// Page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// Number of hostnames per page.
	PerPage param.Field[float64] `query:"per_page"`
	// Whether to filter hostnames based on if they have SSL enabled.
	SSL param.Field[CustomHostnameListParamsSSL] `query:"ssl"`
}

type CustomHostnameListParamsDirection string

type CustomHostnameListParamsOrder string

type CustomHostnameListParamsSSL float64

type CustomHostnameListResponse struct {
	// Identifier
	ID string `json:"id,required"`
	// The custom hostname that will point to your hostname via CNAME.
	Hostname string `json:"hostname,required"`
	// SSL properties for the custom hostname.
	SSL  CustomHostnameListResponseSSL  `json:"ssl,required"`
	JSON customHostnameListResponseJSON `json:"-"`
}

type CustomHostnameListResponseSSL struct {
	// Custom hostname SSL identifier tag.
	ID string `json:"id"`
	// A ubiquitous bundle has the highest probability of being verified everywhere,
	// even by clients using outdated or unusual trust stores. An optimal bundle uses
	// the shortest chain and newest intermediates. And the force bundle verifies the
	// chain, but does not otherwise modify it.
	BundleMethod CustomHostnameListResponseSSLBundleMethod `json:"bundle_method"`
	// The Certificate Authority that will issue the certificate
	CertificateAuthority CustomHostnameListResponseSSLCertificateAuthority `json:"certificate_authority"`
	// If a custom uploaded certificate is used.
	CustomCertificate string `json:"custom_certificate"`
	// The identifier for the Custom CSR that was used.
	CustomCsrID string `json:"custom_csr_id"`
	// The key for a custom uploaded certificate.
	CustomKey string `json:"custom_key"`
	// The time the custom certificate expires on.
	ExpiresOn time.Time `json:"expires_on" format:"date-time"`
	// A list of Hostnames on a custom uploaded certificate.
	Hosts []interface{} `json:"hosts"`
	// The issuer on a custom uploaded certificate.
	Issuer string `json:"issuer"`
	// Domain control validation (DCV) method used for this hostname.
	Method CustomHostnameListResponseSSLMethod `json:"method"`
	// The serial number on a custom uploaded certificate.
	SerialNumber string `json:"serial_number"`
	// SSL specific settings.
	Settings CustomHostnameListResponseSSLSettings `json:"settings"`
	// The signature on a custom uploaded certificate.
	Signature string `json:"signature"`
	// Status of the hostname's SSL certificates.
	Status CustomHostnameListResponseSSLStatus `json:"status"`
	// Level of validation to be used for this hostname. Domain validation (dv) must be
	// used.
	Type CustomHostnameListResponseSSLType `json:"type"`
	// The time the custom certificate was uploaded.
	UploadedOn time.Time `json:"uploaded_on" format:"date-time"`
	// Domain validation errors that have been received by the certificate authority
	// (CA).
	ValidationErrors  []CustomHostnameListResponseSSLValidationError  `json:"validation_errors"`
	ValidationRecords []CustomHostnameListResponseSSLValidationRecord `json:"validation_records"`
	// Indicates whether the certificate covers a wildcard.
	Wildcard bool                              `json:"wildcard"`
	JSON     customHostnameListResponseSSLJSON `json:"-"`
}

type CustomHostnameListResponseSSLBundleMethod string

type CustomHostnameListResponseSSLCertificateAuthority string

type CustomHostnameListResponseSSLMethod string

type CustomHostnameListResponseSSLSettings struct {
	// An allowlist of ciphers for TLS termination. These ciphers must be in the
	// BoringSSL format.
	Ciphers []string `json:"ciphers"`
	// Whether or not Early Hints is enabled.
	EarlyHints CustomHostnameListResponseSSLSettingsEarlyHints `json:"early_hints"`
	// Whether or not HTTP2 is enabled.
	HTTP2 CustomHostnameListResponseSSLSettingsHTTP2 `json:"http2"`
	// The minimum TLS version supported.
	MinTLSVersion CustomHostnameListResponseSSLSettingsMinTLSVersion `json:"min_tls_version"`
	// Whether or not TLS 1.3 is enabled.
	TLS1_3 CustomHostnameListResponseSSLSettingsTLS1_3 `json:"tls_1_3"`
	JSON   customHostnameListResponseSSLSettingsJSON   `json:"-"`
}

type CustomHostnameListResponseSSLSettingsEarlyHints string

type CustomHostnameListResponseSSLSettingsHTTP2 string

type CustomHostnameListResponseSSLSettingsMinTLSVersion string

type CustomHostnameListResponseSSLSettingsTLS1_3 string

type CustomHostnameListResponseSSLStatus string

type CustomHostnameListResponseSSLType string

type CustomHostnameListResponseSSLValidationError struct {
	// A domain validation error.
	Message string                                           `json:"message"`
	JSON    customHostnameListResponseSSLValidationErrorJSON `json:"-"`
}

type CustomHostnameListResponseSSLValidationRecord struct {
	// The set of email addresses that the certificate authority (CA) will use to
	// complete domain validation.
	Emails []interface{} `json:"emails"`
	// The content that the certificate authority (CA) will expect to find at the
	// http_url during the domain validation.
	HTTPBody string `json:"http_body"`
	// The url that will be checked during domain validation.
	HTTPURL string `json:"http_url"`
	// The hostname that the certificate authority (CA) will check for a TXT record
	// during domain validation .
	TXTName string `json:"txt_name"`
	// The TXT record that the certificate authority (CA) will check during domain
	// validation.
	TXTValue string                                            `json:"txt_value"`
	JSON     customHostnameListResponseSSLValidationRecordJSON `json:"-"`
}

type CustomHostnameNewParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The custom hostname that will point to your hostname via CNAME.
	Hostname param.Field[string] `json:"hostname,required"`
	// SSL properties used when creating the custom hostname.
	SSL param.Field[CustomHostnameNewParamsSSL] `json:"ssl,required"`
	// These are per-hostname (customer) settings.
	CustomMetadata param.Field[CustomHostnameNewParamsCustomMetadata] `json:"custom_metadata"`
}

type CustomHostnameNewParamsCustomMetadata struct {
	// Unique metadata for this hostname.
	Key param.Field[string] `json:"key"`
}

type CustomHostnameNewParamsSSL struct {
	// A ubiquitous bundle has the highest probability of being verified everywhere,
	// even by clients using outdated or unusual trust stores. An optimal bundle uses
	// the shortest chain and newest intermediates. And the force bundle verifies the
	// chain, but does not otherwise modify it.
	BundleMethod param.Field[CustomHostnameNewParamsSSLBundleMethod] `json:"bundle_method"`
	// The Certificate Authority that will issue the certificate
	CertificateAuthority param.Field[CustomHostnameNewParamsSSLCertificateAuthority] `json:"certificate_authority"`
	// If a custom uploaded certificate is used.
	CustomCertificate param.Field[string] `json:"custom_certificate"`
	// The key for a custom uploaded certificate.
	CustomKey param.Field[string] `json:"custom_key"`
	// Domain control validation (DCV) method used for this hostname.
	Method param.Field[CustomHostnameNewParamsSSLMethod] `json:"method"`
	// SSL specific settings.
	Settings param.Field[CustomHostnameNewParamsSSLSettings] `json:"settings"`
	// Level of validation to be used for this hostname. Domain validation (dv) must be
	// used.
	Type param.Field[CustomHostnameNewParamsSSLType] `json:"type"`
	// Indicates whether the certificate covers a wildcard.
	Wildcard param.Field[bool] `json:"wildcard"`
}

type CustomHostnameNewParamsSSLBundleMethod string

type CustomHostnameNewParamsSSLCertificateAuthority string

type CustomHostnameNewParamsSSLMethod string

type CustomHostnameNewParamsSSLSettings struct {
	// An allowlist of ciphers for TLS termination. These ciphers must be in the
	// BoringSSL format.
	Ciphers param.Field[[]string] `json:"ciphers"`
	// Whether or not Early Hints is enabled.
	EarlyHints param.Field[CustomHostnameNewParamsSSLSettingsEarlyHints] `json:"early_hints"`
	// Whether or not HTTP2 is enabled.
	HTTP2 param.Field[CustomHostnameNewParamsSSLSettingsHTTP2] `json:"http2"`
	// The minimum TLS version supported.
	MinTLSVersion param.Field[CustomHostnameNewParamsSSLSettingsMinTLSVersion] `json:"min_tls_version"`
	// Whether or not TLS 1.3 is enabled.
	TLS1_3 param.Field[CustomHostnameNewParamsSSLSettingsTLS1_3] `json:"tls_1_3"`
}

type CustomHostnameNewParamsSSLSettingsEarlyHints string

type CustomHostnameNewParamsSSLSettingsHTTP2 string

type CustomHostnameNewParamsSSLSettingsMinTLSVersion string

type CustomHostnameNewParamsSSLSettingsTLS1_3 string

type CustomHostnameNewParamsSSLType string

type CustomHostnameNewResponse struct {
	// Identifier
	ID string `json:"id,required"`
	// The custom hostname that will point to your hostname via CNAME.
	Hostname string `json:"hostname,required"`
	// SSL properties for the custom hostname.
	SSL  CustomHostnameNewResponseSSL  `json:"ssl,required"`
	JSON customHostnameNewResponseJSON `json:"-"`
}

type CustomHostnameNewResponseEnvelope struct {
	Errors   []CustomHostnameNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CustomHostnameNewResponseEnvelopeMessages `json:"messages,required"`
	Result   CustomHostnameNewResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success CustomHostnameNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    customHostnameNewResponseEnvelopeJSON    `json:"-"`
}

type CustomHostnameNewResponseEnvelopeErrors struct {
	Code    int64                                       `json:"code,required"`
	Message string                                      `json:"message,required"`
	JSON    customHostnameNewResponseEnvelopeErrorsJSON `json:"-"`
}

type CustomHostnameNewResponseEnvelopeMessages struct {
	Code    int64                                         `json:"code,required"`
	Message string                                        `json:"message,required"`
	JSON    customHostnameNewResponseEnvelopeMessagesJSON `json:"-"`
}

type CustomHostnameNewResponseEnvelopeSuccess bool

type CustomHostnameNewResponseSSL struct {
	// Custom hostname SSL identifier tag.
	ID string `json:"id"`
	// A ubiquitous bundle has the highest probability of being verified everywhere,
	// even by clients using outdated or unusual trust stores. An optimal bundle uses
	// the shortest chain and newest intermediates. And the force bundle verifies the
	// chain, but does not otherwise modify it.
	BundleMethod CustomHostnameNewResponseSSLBundleMethod `json:"bundle_method"`
	// The Certificate Authority that will issue the certificate
	CertificateAuthority CustomHostnameNewResponseSSLCertificateAuthority `json:"certificate_authority"`
	// If a custom uploaded certificate is used.
	CustomCertificate string `json:"custom_certificate"`
	// The identifier for the Custom CSR that was used.
	CustomCsrID string `json:"custom_csr_id"`
	// The key for a custom uploaded certificate.
	CustomKey string `json:"custom_key"`
	// The time the custom certificate expires on.
	ExpiresOn time.Time `json:"expires_on" format:"date-time"`
	// A list of Hostnames on a custom uploaded certificate.
	Hosts []interface{} `json:"hosts"`
	// The issuer on a custom uploaded certificate.
	Issuer string `json:"issuer"`
	// Domain control validation (DCV) method used for this hostname.
	Method CustomHostnameNewResponseSSLMethod `json:"method"`
	// The serial number on a custom uploaded certificate.
	SerialNumber string `json:"serial_number"`
	// SSL specific settings.
	Settings CustomHostnameNewResponseSSLSettings `json:"settings"`
	// The signature on a custom uploaded certificate.
	Signature string `json:"signature"`
	// Status of the hostname's SSL certificates.
	Status CustomHostnameNewResponseSSLStatus `json:"status"`
	// Level of validation to be used for this hostname. Domain validation (dv) must be
	// used.
	Type CustomHostnameNewResponseSSLType `json:"type"`
	// The time the custom certificate was uploaded.
	UploadedOn time.Time `json:"uploaded_on" format:"date-time"`
	// Domain validation errors that have been received by the certificate authority
	// (CA).
	ValidationErrors  []CustomHostnameNewResponseSSLValidationError  `json:"validation_errors"`
	ValidationRecords []CustomHostnameNewResponseSSLValidationRecord `json:"validation_records"`
	// Indicates whether the certificate covers a wildcard.
	Wildcard bool                             `json:"wildcard"`
	JSON     customHostnameNewResponseSSLJSON `json:"-"`
}

type CustomHostnameNewResponseSSLBundleMethod string

type CustomHostnameNewResponseSSLCertificateAuthority string

type CustomHostnameNewResponseSSLMethod string

type CustomHostnameNewResponseSSLSettings struct {
	// An allowlist of ciphers for TLS termination. These ciphers must be in the
	// BoringSSL format.
	Ciphers []string `json:"ciphers"`
	// Whether or not Early Hints is enabled.
	EarlyHints CustomHostnameNewResponseSSLSettingsEarlyHints `json:"early_hints"`
	// Whether or not HTTP2 is enabled.
	HTTP2 CustomHostnameNewResponseSSLSettingsHTTP2 `json:"http2"`
	// The minimum TLS version supported.
	MinTLSVersion CustomHostnameNewResponseSSLSettingsMinTLSVersion `json:"min_tls_version"`
	// Whether or not TLS 1.3 is enabled.
	TLS1_3 CustomHostnameNewResponseSSLSettingsTLS1_3 `json:"tls_1_3"`
	JSON   customHostnameNewResponseSSLSettingsJSON   `json:"-"`
}

type CustomHostnameNewResponseSSLSettingsEarlyHints string

type CustomHostnameNewResponseSSLSettingsHTTP2 string

type CustomHostnameNewResponseSSLSettingsMinTLSVersion string

type CustomHostnameNewResponseSSLSettingsTLS1_3 string

type CustomHostnameNewResponseSSLStatus string

type CustomHostnameNewResponseSSLType string

type CustomHostnameNewResponseSSLValidationError struct {
	// A domain validation error.
	Message string                                          `json:"message"`
	JSON    customHostnameNewResponseSSLValidationErrorJSON `json:"-"`
}

type CustomHostnameNewResponseSSLValidationRecord struct {
	// The set of email addresses that the certificate authority (CA) will use to
	// complete domain validation.
	Emails []interface{} `json:"emails"`
	// The content that the certificate authority (CA) will expect to find at the
	// http_url during the domain validation.
	HTTPBody string `json:"http_body"`
	// The url that will be checked during domain validation.
	HTTPURL string `json:"http_url"`
	// The hostname that the certificate authority (CA) will check for a TXT record
	// during domain validation .
	TXTName string `json:"txt_name"`
	// The TXT record that the certificate authority (CA) will check during domain
	// validation.
	TXTValue string                                           `json:"txt_value"`
	JSON     customHostnameNewResponseSSLValidationRecordJSON `json:"-"`
}

type CustomHostnameService struct {
	Options        []option.RequestOption
	FallbackOrigin *FallbackOriginService
}

type Error = apierror.Error

type FallbackOriginDeleteParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
}

type FallbackOriginDeleteResponse interface {
	ImplementsCustomHostnamesFallbackOriginDeleteResponse()
}

type FallbackOriginDeleteResponseEnvelope struct {
	Errors   []FallbackOriginDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []FallbackOriginDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   FallbackOriginDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success FallbackOriginDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    fallbackOriginDeleteResponseEnvelopeJSON    `json:"-"`
}

type FallbackOriginDeleteResponseEnvelopeErrors struct {
	Code    int64                                          `json:"code,required"`
	Message string                                         `json:"message,required"`
	JSON    fallbackOriginDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

type FallbackOriginDeleteResponseEnvelopeMessages struct {
	Code    int64                                            `json:"code,required"`
	Message string                                           `json:"message,required"`
	JSON    fallbackOriginDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

type FallbackOriginDeleteResponseEnvelopeSuccess bool

type FallbackOriginGetParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
}

type FallbackOriginGetResponse interface {
	ImplementsCustomHostnamesFallbackOriginGetResponse()
}

type FallbackOriginGetResponseEnvelope struct {
	Errors   []FallbackOriginGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []FallbackOriginGetResponseEnvelopeMessages `json:"messages,required"`
	Result   FallbackOriginGetResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success FallbackOriginGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    fallbackOriginGetResponseEnvelopeJSON    `json:"-"`
}

type FallbackOriginGetResponseEnvelopeErrors struct {
	Code    int64                                       `json:"code,required"`
	Message string                                      `json:"message,required"`
	JSON    fallbackOriginGetResponseEnvelopeErrorsJSON `json:"-"`
}

type FallbackOriginGetResponseEnvelopeMessages struct {
	Code    int64                                         `json:"code,required"`
	Message string                                        `json:"message,required"`
	JSON    fallbackOriginGetResponseEnvelopeMessagesJSON `json:"-"`
}

type FallbackOriginGetResponseEnvelopeSuccess bool

type FallbackOriginService struct {
	Options []option.RequestOption
}

type FallbackOriginUpdateParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Your origin hostname that requests to your custom hostnames will be sent to.
	Origin param.Field[string] `json:"origin,required"`
}

type FallbackOriginUpdateResponse interface {
	ImplementsCustomHostnamesFallbackOriginUpdateResponse()
}

type FallbackOriginUpdateResponseEnvelope struct {
	Errors   []FallbackOriginUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []FallbackOriginUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   FallbackOriginUpdateResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success FallbackOriginUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    fallbackOriginUpdateResponseEnvelopeJSON    `json:"-"`
}

type FallbackOriginUpdateResponseEnvelopeErrors struct {
	Code    int64                                          `json:"code,required"`
	Message string                                         `json:"message,required"`
	JSON    fallbackOriginUpdateResponseEnvelopeErrorsJSON `json:"-"`
}

type FallbackOriginUpdateResponseEnvelopeMessages struct {
	Code    int64                                            `json:"code,required"`
	Message string                                           `json:"message,required"`
	JSON    fallbackOriginUpdateResponseEnvelopeMessagesJSON `json:"-"`
}

type FallbackOriginUpdateResponseEnvelopeSuccess bool