ssl

type ASN = shared.ASN

type ASNParam = shared.ASNParam

type AnalyzeNewParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// 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[custom_hostnames.BundleMethod] `json:"bundle_method"`
	// The zone's SSL certificate or certificate and the intermediate(s).
	Certificate param.Field[string] `json:"certificate"`
}

type AnalyzeNewResponse = interface{}

type AnalyzeNewResponseEnvelope struct {
	Errors   []AnalyzeNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []AnalyzeNewResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success AnalyzeNewResponseEnvelopeSuccess `json:"success,required"`
	Result  AnalyzeNewResponse                `json:"result"`
	JSON    analyzeNewResponseEnvelopeJSON    `json:"-"`
}

type AnalyzeNewResponseEnvelopeErrors struct {
	Code             int64                                  `json:"code,required"`
	Message          string                                 `json:"message,required"`
	DocumentationURL string                                 `json:"documentation_url"`
	Source           AnalyzeNewResponseEnvelopeErrorsSource `json:"source"`
	JSON             analyzeNewResponseEnvelopeErrorsJSON   `json:"-"`
}

type AnalyzeNewResponseEnvelopeErrorsSource struct {
	Pointer string                                     `json:"pointer"`
	JSON    analyzeNewResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type AnalyzeNewResponseEnvelopeMessages struct {
	Code             int64                                    `json:"code,required"`
	Message          string                                   `json:"message,required"`
	DocumentationURL string                                   `json:"documentation_url"`
	Source           AnalyzeNewResponseEnvelopeMessagesSource `json:"source"`
	JSON             analyzeNewResponseEnvelopeMessagesJSON   `json:"-"`
}

type AnalyzeNewResponseEnvelopeMessagesSource struct {
	Pointer string                                       `json:"pointer"`
	JSON    analyzeNewResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type AnalyzeNewResponseEnvelopeSuccess bool

type AnalyzeService struct {
	Options []option.RequestOption
}

type AuditLog = shared.AuditLog

type AuditLogAction = shared.AuditLogAction

type AuditLogActor = shared.AuditLogActor

type AuditLogActorType = shared.AuditLogActorType

type AuditLogOwner = shared.AuditLogOwner

type AuditLogResource = shared.AuditLogResource

type CertificateCA = shared.CertificateCA

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

type CertificatePackDeleteResponse struct {
	// Identifier.
	ID   string                            `json:"id"`
	JSON certificatePackDeleteResponseJSON `json:"-"`
}

type CertificatePackDeleteResponseEnvelope struct {
	Errors   []CertificatePackDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CertificatePackDeleteResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success CertificatePackDeleteResponseEnvelopeSuccess `json:"success,required"`
	Result  CertificatePackDeleteResponse                `json:"result"`
	JSON    certificatePackDeleteResponseEnvelopeJSON    `json:"-"`
}

type CertificatePackDeleteResponseEnvelopeErrors struct {
	Code             int64                                             `json:"code,required"`
	Message          string                                            `json:"message,required"`
	DocumentationURL string                                            `json:"documentation_url"`
	Source           CertificatePackDeleteResponseEnvelopeErrorsSource `json:"source"`
	JSON             certificatePackDeleteResponseEnvelopeErrorsJSON   `json:"-"`
}

type CertificatePackDeleteResponseEnvelopeErrorsSource struct {
	Pointer string                                                `json:"pointer"`
	JSON    certificatePackDeleteResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type CertificatePackDeleteResponseEnvelopeMessages struct {
	Code             int64                                               `json:"code,required"`
	Message          string                                              `json:"message,required"`
	DocumentationURL string                                              `json:"documentation_url"`
	Source           CertificatePackDeleteResponseEnvelopeMessagesSource `json:"source"`
	JSON             certificatePackDeleteResponseEnvelopeMessagesJSON   `json:"-"`
}

type CertificatePackDeleteResponseEnvelopeMessagesSource struct {
	Pointer string                                                  `json:"pointer"`
	JSON    certificatePackDeleteResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type CertificatePackDeleteResponseEnvelopeSuccess bool

type CertificatePackEditParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Whether or not to add Cloudflare Branding for the order. This will add a
	// subdomain of sni.cloudflaressl.com as the Common Name if set to true.
	CloudflareBranding param.Field[bool] `json:"cloudflare_branding"`
}

type CertificatePackEditResponse struct {
	// Identifier.
	ID string `json:"id"`
	// Certificate Authority selected for the order. For information on any certificate
	// authority specific details or restrictions
	// [see this page for more details.](https://developers.cloudflare.com/ssl/reference/certificate-authorities)
	CertificateAuthority CertificatePackEditResponseCertificateAuthority `json:"certificate_authority"`
	// Whether or not to add Cloudflare Branding for the order. This will add a
	// subdomain of sni.cloudflaressl.com as the Common Name if set to true.
	CloudflareBranding bool `json:"cloudflare_branding"`
	// Comma separated list of valid host names for the certificate packs. Must contain
	// the zone apex, may not contain more than 50 hosts, and may not be empty.
	Hosts []Host `json:"hosts"`
	// Status of certificate pack.
	Status Status `json:"status"`
	// Type of certificate pack.
	Type CertificatePackEditResponseType `json:"type"`
	// Validation Method selected for the order.
	ValidationMethod CertificatePackEditResponseValidationMethod `json:"validation_method"`
	// Validity Days selected for the order.
	ValidityDays CertificatePackEditResponseValidityDays `json:"validity_days"`
	JSON         certificatePackEditResponseJSON         `json:"-"`
}

type CertificatePackEditResponseCertificateAuthority string

type CertificatePackEditResponseEnvelope struct {
	Errors   []CertificatePackEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CertificatePackEditResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success CertificatePackEditResponseEnvelopeSuccess `json:"success,required"`
	Result  CertificatePackEditResponse                `json:"result"`
	JSON    certificatePackEditResponseEnvelopeJSON    `json:"-"`
}

type CertificatePackEditResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code,required"`
	Message          string                                          `json:"message,required"`
	DocumentationURL string                                          `json:"documentation_url"`
	Source           CertificatePackEditResponseEnvelopeErrorsSource `json:"source"`
	JSON             certificatePackEditResponseEnvelopeErrorsJSON   `json:"-"`
}

type CertificatePackEditResponseEnvelopeErrorsSource struct {
	Pointer string                                              `json:"pointer"`
	JSON    certificatePackEditResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type CertificatePackEditResponseEnvelopeMessages struct {
	Code             int64                                             `json:"code,required"`
	Message          string                                            `json:"message,required"`
	DocumentationURL string                                            `json:"documentation_url"`
	Source           CertificatePackEditResponseEnvelopeMessagesSource `json:"source"`
	JSON             certificatePackEditResponseEnvelopeMessagesJSON   `json:"-"`
}

type CertificatePackEditResponseEnvelopeMessagesSource struct {
	Pointer string                                                `json:"pointer"`
	JSON    certificatePackEditResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type CertificatePackEditResponseEnvelopeSuccess bool

type CertificatePackEditResponseType string

type CertificatePackEditResponseValidationMethod string

type CertificatePackEditResponseValidityDays int64

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

type CertificatePackGetResponse = interface{}

type CertificatePackGetResponseEnvelope struct {
	Errors   []CertificatePackGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CertificatePackGetResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success CertificatePackGetResponseEnvelopeSuccess `json:"success,required"`
	Result  CertificatePackGetResponse                `json:"result"`
	JSON    certificatePackGetResponseEnvelopeJSON    `json:"-"`
}

type CertificatePackGetResponseEnvelopeErrors struct {
	Code             int64                                          `json:"code,required"`
	Message          string                                         `json:"message,required"`
	DocumentationURL string                                         `json:"documentation_url"`
	Source           CertificatePackGetResponseEnvelopeErrorsSource `json:"source"`
	JSON             certificatePackGetResponseEnvelopeErrorsJSON   `json:"-"`
}

type CertificatePackGetResponseEnvelopeErrorsSource struct {
	Pointer string                                             `json:"pointer"`
	JSON    certificatePackGetResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type CertificatePackGetResponseEnvelopeMessages struct {
	Code             int64                                            `json:"code,required"`
	Message          string                                           `json:"message,required"`
	DocumentationURL string                                           `json:"documentation_url"`
	Source           CertificatePackGetResponseEnvelopeMessagesSource `json:"source"`
	JSON             certificatePackGetResponseEnvelopeMessagesJSON   `json:"-"`
}

type CertificatePackGetResponseEnvelopeMessagesSource struct {
	Pointer string                                               `json:"pointer"`
	JSON    certificatePackGetResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type CertificatePackGetResponseEnvelopeSuccess bool

type CertificatePackListParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Include Certificate Packs of all statuses, not just active ones.
	Status param.Field[CertificatePackListParamsStatus] `query:"status"`
}

type CertificatePackListParamsStatus string

type CertificatePackListResponse = interface{}

type CertificatePackNewParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Certificate Authority selected for the order. For information on any certificate
	// authority specific details or restrictions
	// [see this page for more details.](https://developers.cloudflare.com/ssl/reference/certificate-authorities)
	CertificateAuthority param.Field[CertificatePackNewParamsCertificateAuthority] `json:"certificate_authority,required"`
	// Comma separated list of valid host names for the certificate packs. Must contain
	// the zone apex, may not contain more than 50 hosts, and may not be empty.
	Hosts param.Field[[]HostParam] `json:"hosts,required"`
	// Type of certificate pack.
	Type param.Field[CertificatePackNewParamsType] `json:"type,required"`
	// Validation Method selected for the order.
	ValidationMethod param.Field[CertificatePackNewParamsValidationMethod] `json:"validation_method,required"`
	// Validity Days selected for the order.
	ValidityDays param.Field[CertificatePackNewParamsValidityDays] `json:"validity_days,required"`
	// Whether or not to add Cloudflare Branding for the order. This will add a
	// subdomain of sni.cloudflaressl.com as the Common Name if set to true.
	CloudflareBranding param.Field[bool] `json:"cloudflare_branding"`
}

type CertificatePackNewParamsCertificateAuthority string

type CertificatePackNewParamsType string

type CertificatePackNewParamsValidationMethod string

type CertificatePackNewParamsValidityDays int64

type CertificatePackNewResponse struct {
	// Identifier.
	ID string `json:"id"`
	// Certificate Authority selected for the order. For information on any certificate
	// authority specific details or restrictions
	// [see this page for more details.](https://developers.cloudflare.com/ssl/reference/certificate-authorities)
	CertificateAuthority CertificatePackNewResponseCertificateAuthority `json:"certificate_authority"`
	// Whether or not to add Cloudflare Branding for the order. This will add a
	// subdomain of sni.cloudflaressl.com as the Common Name if set to true.
	CloudflareBranding bool `json:"cloudflare_branding"`
	// Comma separated list of valid host names for the certificate packs. Must contain
	// the zone apex, may not contain more than 50 hosts, and may not be empty.
	Hosts []Host `json:"hosts"`
	// Status of certificate pack.
	Status Status `json:"status"`
	// Type of certificate pack.
	Type CertificatePackNewResponseType `json:"type"`
	// Validation Method selected for the order.
	ValidationMethod CertificatePackNewResponseValidationMethod `json:"validation_method"`
	// Validity Days selected for the order.
	ValidityDays CertificatePackNewResponseValidityDays `json:"validity_days"`
	JSON         certificatePackNewResponseJSON         `json:"-"`
}

type CertificatePackNewResponseCertificateAuthority string

type CertificatePackNewResponseEnvelope struct {
	Errors   []CertificatePackNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CertificatePackNewResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success CertificatePackNewResponseEnvelopeSuccess `json:"success,required"`
	Result  CertificatePackNewResponse                `json:"result"`
	JSON    certificatePackNewResponseEnvelopeJSON    `json:"-"`
}

type CertificatePackNewResponseEnvelopeErrors struct {
	Code             int64                                          `json:"code,required"`
	Message          string                                         `json:"message,required"`
	DocumentationURL string                                         `json:"documentation_url"`
	Source           CertificatePackNewResponseEnvelopeErrorsSource `json:"source"`
	JSON             certificatePackNewResponseEnvelopeErrorsJSON   `json:"-"`
}

type CertificatePackNewResponseEnvelopeErrorsSource struct {
	Pointer string                                             `json:"pointer"`
	JSON    certificatePackNewResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type CertificatePackNewResponseEnvelopeMessages struct {
	Code             int64                                            `json:"code,required"`
	Message          string                                           `json:"message,required"`
	DocumentationURL string                                           `json:"documentation_url"`
	Source           CertificatePackNewResponseEnvelopeMessagesSource `json:"source"`
	JSON             certificatePackNewResponseEnvelopeMessagesJSON   `json:"-"`
}

type CertificatePackNewResponseEnvelopeMessagesSource struct {
	Pointer string                                               `json:"pointer"`
	JSON    certificatePackNewResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type CertificatePackNewResponseEnvelopeSuccess bool

type CertificatePackNewResponseType string

type CertificatePackNewResponseValidationMethod string

type CertificatePackNewResponseValidityDays int64

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

type CertificatePackQuotaGetResponse struct {
	Advanced CertificatePackQuotaGetResponseAdvanced `json:"advanced"`
	JSON     certificatePackQuotaGetResponseJSON     `json:"-"`
}

type CertificatePackQuotaGetResponseAdvanced struct {
	// Quantity Allocated.
	Allocated int64 `json:"allocated"`
	// Quantity Used.
	Used int64                                       `json:"used"`
	JSON certificatePackQuotaGetResponseAdvancedJSON `json:"-"`
}

type CertificatePackQuotaGetResponseEnvelope struct {
	Errors   []CertificatePackQuotaGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CertificatePackQuotaGetResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success CertificatePackQuotaGetResponseEnvelopeSuccess `json:"success,required"`
	Result  CertificatePackQuotaGetResponse                `json:"result"`
	JSON    certificatePackQuotaGetResponseEnvelopeJSON    `json:"-"`
}

type CertificatePackQuotaGetResponseEnvelopeErrors struct {
	Code             int64                                               `json:"code,required"`
	Message          string                                              `json:"message,required"`
	DocumentationURL string                                              `json:"documentation_url"`
	Source           CertificatePackQuotaGetResponseEnvelopeErrorsSource `json:"source"`
	JSON             certificatePackQuotaGetResponseEnvelopeErrorsJSON   `json:"-"`
}

type CertificatePackQuotaGetResponseEnvelopeErrorsSource struct {
	Pointer string                                                  `json:"pointer"`
	JSON    certificatePackQuotaGetResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type CertificatePackQuotaGetResponseEnvelopeMessages struct {
	Code             int64                                                 `json:"code,required"`
	Message          string                                                `json:"message,required"`
	DocumentationURL string                                                `json:"documentation_url"`
	Source           CertificatePackQuotaGetResponseEnvelopeMessagesSource `json:"source"`
	JSON             certificatePackQuotaGetResponseEnvelopeMessagesJSON   `json:"-"`
}

type CertificatePackQuotaGetResponseEnvelopeMessagesSource struct {
	Pointer string                                                    `json:"pointer"`
	JSON    certificatePackQuotaGetResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type CertificatePackQuotaGetResponseEnvelopeSuccess bool

type CertificatePackQuotaService struct {
	Options []option.RequestOption
}

type CertificatePackService struct {
	Options []option.RequestOption
	Quota   *CertificatePackQuotaService
}

type CertificateRequestType = shared.CertificateRequestType

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelStatus = shared.CloudflareTunnelStatus

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type Error = apierror.Error

type ErrorData = shared.ErrorData

type ErrorDataSource = shared.ErrorDataSource

type Host = string

type HostParam = string

type Member = shared.Member

type MemberPoliciesAccess = shared.MemberPoliciesAccess

type MemberPoliciesPermissionGroup = shared.MemberPoliciesPermissionGroup

type MemberPoliciesPermissionGroupsMeta = shared.MemberPoliciesPermissionGroupsMeta

type MemberPoliciesResourceGroup = shared.MemberPoliciesResourceGroup

type MemberPoliciesResourceGroupsMeta = shared.MemberPoliciesResourceGroupsMeta

type MemberPoliciesResourceGroupsScope = shared.MemberPoliciesResourceGroupsScope

type MemberPoliciesResourceGroupsScopeObject = shared.MemberPoliciesResourceGroupsScopeObject

type MemberPolicy = shared.MemberPolicy

type MemberStatus = shared.MemberStatus

type MemberUser = shared.MemberUser

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type RatePlan = shared.RatePlan

type RatePlanID = shared.RatePlanID

type RatePlanParam = shared.RatePlanParam

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

type RecommendationGetResponse struct {
	// Identifier of a recommendation result.
	ID         string                         `json:"id"`
	ModifiedOn time.Time                      `json:"modified_on" format:"date-time"`
	Value      RecommendationGetResponseValue `json:"value"`
	JSON       recommendationGetResponseJSON  `json:"-"`
}

type RecommendationGetResponseEnvelope struct {
	Errors   []RecommendationGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RecommendationGetResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success RecommendationGetResponseEnvelopeSuccess `json:"success,required"`
	Result  RecommendationGetResponse                `json:"result"`
	JSON    recommendationGetResponseEnvelopeJSON    `json:"-"`
}

type RecommendationGetResponseEnvelopeErrors struct {
	Code             int64                                         `json:"code,required"`
	Message          string                                        `json:"message,required"`
	DocumentationURL string                                        `json:"documentation_url"`
	Source           RecommendationGetResponseEnvelopeErrorsSource `json:"source"`
	JSON             recommendationGetResponseEnvelopeErrorsJSON   `json:"-"`
}

type RecommendationGetResponseEnvelopeErrorsSource struct {
	Pointer string                                            `json:"pointer"`
	JSON    recommendationGetResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type RecommendationGetResponseEnvelopeMessages struct {
	Code             int64                                           `json:"code,required"`
	Message          string                                          `json:"message,required"`
	DocumentationURL string                                          `json:"documentation_url"`
	Source           RecommendationGetResponseEnvelopeMessagesSource `json:"source"`
	JSON             recommendationGetResponseEnvelopeMessagesJSON   `json:"-"`
}

type RecommendationGetResponseEnvelopeMessagesSource struct {
	Pointer string                                              `json:"pointer"`
	JSON    recommendationGetResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type RecommendationGetResponseEnvelopeSuccess bool

type RecommendationGetResponseValue string

type RecommendationService struct {
	Options []option.RequestOption
}

type RequestValidity float64

type ResponseInfo = shared.ResponseInfo

type ResponseInfoSource = shared.ResponseInfoSource

type Role = shared.Role

type RoleParam = shared.RoleParam

type RolePermissions = shared.RolePermissions

type RolePermissionsParam = shared.RolePermissionsParam

type SSLService struct {
	Options          []option.RequestOption
	Analyze          *AnalyzeService
	CertificatePacks *CertificatePackService
	Recommendations  *RecommendationService
	Universal        *UniversalService
	Verification     *VerificationService
}

type SortDirection = shared.SortDirection

type Status string

type Subscription = shared.Subscription

type SubscriptionFrequency = shared.SubscriptionFrequency

type SubscriptionParam = shared.SubscriptionParam

type SubscriptionState = shared.SubscriptionState

type Token = shared.Token

type TokenCondition = shared.TokenCondition

type TokenConditionCIDRList = shared.TokenConditionCIDRList

type TokenConditionCIDRListParam = shared.TokenConditionCIDRListParam

type TokenConditionParam = shared.TokenConditionParam

type TokenConditionRequestIP = shared.TokenConditionRequestIP

type TokenConditionRequestIPParam = shared.TokenConditionRequestIPParam

type TokenParam = shared.TokenParam

type TokenPolicy = shared.TokenPolicy

type TokenPolicyEffect = shared.TokenPolicyEffect

type TokenPolicyParam = shared.TokenPolicyParam

type TokenPolicyPermissionGroup = shared.TokenPolicyPermissionGroup

type TokenPolicyPermissionGroupParam = shared.TokenPolicyPermissionGroupParam

type TokenPolicyPermissionGroupsMeta = shared.TokenPolicyPermissionGroupsMeta

type TokenPolicyPermissionGroupsMetaParam = shared.TokenPolicyPermissionGroupsMetaParam

type TokenStatus = shared.TokenStatus

type TokenValue = shared.TokenValue

type UniversalSSLSettings struct {
	// Disabling Universal SSL removes any currently active Universal SSL certificates
	// for your zone from the edge and prevents any future Universal SSL certificates
	// from being ordered. If there are no advanced certificates or custom certificates
	// uploaded for the domain, visitors will be unable to access the domain over
	// HTTPS.
	//
	// By disabling Universal SSL, you understand that the following Cloudflare
	// settings and preferences will result in visitors being unable to visit your
	// domain unless you have uploaded a custom certificate or purchased an advanced
	// certificate.
	//
	// - HSTS
	// - Always Use HTTPS
	// - Opportunistic Encryption
	// - Onion Routing
	// - Any Page Rules redirecting traffic to HTTPS
	//
	// Similarly, any HTTP redirect to HTTPS at the origin while the Cloudflare proxy
	// is enabled will result in users being unable to visit your site without a valid
	// certificate at Cloudflare's edge.
	//
	// If you do not have a valid custom or advanced certificate at Cloudflare's edge
	// and are unsure if any of the above Cloudflare settings are enabled, or if any
	// HTTP redirects exist at your origin, we advise leaving Universal SSL enabled for
	// your domain.
	Enabled bool                     `json:"enabled"`
	JSON    universalSSLSettingsJSON `json:"-"`
}

type UniversalSSLSettingsParam struct {
	// Disabling Universal SSL removes any currently active Universal SSL certificates
	// for your zone from the edge and prevents any future Universal SSL certificates
	// from being ordered. If there are no advanced certificates or custom certificates
	// uploaded for the domain, visitors will be unable to access the domain over
	// HTTPS.
	//
	// By disabling Universal SSL, you understand that the following Cloudflare
	// settings and preferences will result in visitors being unable to visit your
	// domain unless you have uploaded a custom certificate or purchased an advanced
	// certificate.
	//
	// - HSTS
	// - Always Use HTTPS
	// - Opportunistic Encryption
	// - Onion Routing
	// - Any Page Rules redirecting traffic to HTTPS
	//
	// Similarly, any HTTP redirect to HTTPS at the origin while the Cloudflare proxy
	// is enabled will result in users being unable to visit your site without a valid
	// certificate at Cloudflare's edge.
	//
	// If you do not have a valid custom or advanced certificate at Cloudflare's edge
	// and are unsure if any of the above Cloudflare settings are enabled, or if any
	// HTTP redirects exist at your origin, we advise leaving Universal SSL enabled for
	// your domain.
	Enabled param.Field[bool] `json:"enabled"`
}

type UniversalService struct {
	Options  []option.RequestOption
	Settings *UniversalSettingService
}

type UniversalSettingEditParams struct {
	// Identifier.
	ZoneID               param.Field[string]       `path:"zone_id,required"`
	UniversalSSLSettings UniversalSSLSettingsParam `json:"universal_ssl_settings,required"`
}

type UniversalSettingEditResponseEnvelope struct {
	Errors   []UniversalSettingEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []UniversalSettingEditResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success UniversalSettingEditResponseEnvelopeSuccess `json:"success,required"`
	Result  UniversalSSLSettings                        `json:"result"`
	JSON    universalSettingEditResponseEnvelopeJSON    `json:"-"`
}

type UniversalSettingEditResponseEnvelopeErrors struct {
	Code             int64                                            `json:"code,required"`
	Message          string                                           `json:"message,required"`
	DocumentationURL string                                           `json:"documentation_url"`
	Source           UniversalSettingEditResponseEnvelopeErrorsSource `json:"source"`
	JSON             universalSettingEditResponseEnvelopeErrorsJSON   `json:"-"`
}

type UniversalSettingEditResponseEnvelopeErrorsSource struct {
	Pointer string                                               `json:"pointer"`
	JSON    universalSettingEditResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type UniversalSettingEditResponseEnvelopeMessages struct {
	Code             int64                                              `json:"code,required"`
	Message          string                                             `json:"message,required"`
	DocumentationURL string                                             `json:"documentation_url"`
	Source           UniversalSettingEditResponseEnvelopeMessagesSource `json:"source"`
	JSON             universalSettingEditResponseEnvelopeMessagesJSON   `json:"-"`
}

type UniversalSettingEditResponseEnvelopeMessagesSource struct {
	Pointer string                                                 `json:"pointer"`
	JSON    universalSettingEditResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type UniversalSettingEditResponseEnvelopeSuccess bool

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

type UniversalSettingGetResponseEnvelope struct {
	Errors   []UniversalSettingGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []UniversalSettingGetResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success UniversalSettingGetResponseEnvelopeSuccess `json:"success,required"`
	Result  UniversalSSLSettings                       `json:"result"`
	JSON    universalSettingGetResponseEnvelopeJSON    `json:"-"`
}

type UniversalSettingGetResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code,required"`
	Message          string                                          `json:"message,required"`
	DocumentationURL string                                          `json:"documentation_url"`
	Source           UniversalSettingGetResponseEnvelopeErrorsSource `json:"source"`
	JSON             universalSettingGetResponseEnvelopeErrorsJSON   `json:"-"`
}

type UniversalSettingGetResponseEnvelopeErrorsSource struct {
	Pointer string                                              `json:"pointer"`
	JSON    universalSettingGetResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type UniversalSettingGetResponseEnvelopeMessages struct {
	Code             int64                                             `json:"code,required"`
	Message          string                                            `json:"message,required"`
	DocumentationURL string                                            `json:"documentation_url"`
	Source           UniversalSettingGetResponseEnvelopeMessagesSource `json:"source"`
	JSON             universalSettingGetResponseEnvelopeMessagesJSON   `json:"-"`
}

type UniversalSettingGetResponseEnvelopeMessagesSource struct {
	Pointer string                                                `json:"pointer"`
	JSON    universalSettingGetResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type UniversalSettingGetResponseEnvelopeSuccess bool

type UniversalSettingService struct {
	Options []option.RequestOption
}

type ValidationMethod string

type Verification struct {
	// Current status of certificate.
	CertificateStatus VerificationCertificateStatus `json:"certificate_status,required"`
	// Certificate Authority is manually reviewing the order.
	BrandCheck bool `json:"brand_check"`
	// Certificate Pack UUID.
	CERTPackUUID string `json:"cert_pack_uuid"`
	// Certificate's signature algorithm.
	Signature VerificationSignature `json:"signature"`
	// Validation method in use for a certificate pack order.
	ValidationMethod ValidationMethod `json:"validation_method"`
	// Certificate's required verification information.
	VerificationInfo VerificationVerificationInfo `json:"verification_info"`
	// Status of the required verification information, omitted if verification status
	// is unknown.
	VerificationStatus bool `json:"verification_status"`
	// Method of verification.
	VerificationType VerificationVerificationType `json:"verification_type"`
	JSON             verificationJSON             `json:"-"`
}

type VerificationCertificateStatus string

type VerificationEditParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Desired validation method.
	ValidationMethod param.Field[VerificationEditParamsValidationMethod] `json:"validation_method,required"`
}

type VerificationEditParamsValidationMethod string

type VerificationEditResponse struct {
	// Result status.
	Status string `json:"status"`
	// Desired validation method.
	ValidationMethod VerificationEditResponseValidationMethod `json:"validation_method"`
	JSON             verificationEditResponseJSON             `json:"-"`
}

type VerificationEditResponseEnvelope struct {
	Errors   []VerificationEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []VerificationEditResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success VerificationEditResponseEnvelopeSuccess `json:"success,required"`
	Result  VerificationEditResponse                `json:"result"`
	JSON    verificationEditResponseEnvelopeJSON    `json:"-"`
}

type VerificationEditResponseEnvelopeErrors struct {
	Code             int64                                        `json:"code,required"`
	Message          string                                       `json:"message,required"`
	DocumentationURL string                                       `json:"documentation_url"`
	Source           VerificationEditResponseEnvelopeErrorsSource `json:"source"`
	JSON             verificationEditResponseEnvelopeErrorsJSON   `json:"-"`
}

type VerificationEditResponseEnvelopeErrorsSource struct {
	Pointer string                                           `json:"pointer"`
	JSON    verificationEditResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type VerificationEditResponseEnvelopeMessages struct {
	Code             int64                                          `json:"code,required"`
	Message          string                                         `json:"message,required"`
	DocumentationURL string                                         `json:"documentation_url"`
	Source           VerificationEditResponseEnvelopeMessagesSource `json:"source"`
	JSON             verificationEditResponseEnvelopeMessagesJSON   `json:"-"`
}

type VerificationEditResponseEnvelopeMessagesSource struct {
	Pointer string                                             `json:"pointer"`
	JSON    verificationEditResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type VerificationEditResponseEnvelopeSuccess bool

type VerificationEditResponseValidationMethod string

type VerificationGetParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Immediately retry SSL Verification.
	Retry param.Field[VerificationGetParamsRetry] `query:"retry"`
}

type VerificationGetParamsRetry bool

type VerificationGetResponseEnvelope struct {
	Result []Verification                      `json:"result"`
	JSON   verificationGetResponseEnvelopeJSON `json:"-"`
}

type VerificationService struct {
	Options []option.RequestOption
}

type VerificationSignature string

type VerificationVerificationInfo struct {
	// Name of CNAME record.
	RecordName VerificationVerificationInfoRecordName `json:"record_name"`
	// Target of CNAME record.
	RecordTarget VerificationVerificationInfoRecordTarget `json:"record_target"`
	JSON         verificationVerificationInfoJSON         `json:"-"`
}

type VerificationVerificationInfoRecordName string

type VerificationVerificationInfoRecordTarget string

type VerificationVerificationType string