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 AnalyzeNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo   `json:"errors,required"`
	Messages []shared.ResponseInfo   `json:"messages,required"`
	Result   AnalyzeNewResponseUnion `json:"result,required"`
	// Whether the API call was successful
	Success AnalyzeNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    analyzeNewResponseEnvelopeJSON    `json:"-"`
}

type AnalyzeNewResponseEnvelopeSuccess bool

type AnalyzeNewResponseUnion interface {
	ImplementsSSLAnalyzeNewResponseUnion()
}

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 CertificatePackDeleteParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	Body   interface{}         `json:"body,required"`
}

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

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

type CertificatePackDeleteResponseEnvelopeSuccess bool

type CertificatePackEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	Body   interface{}         `json:"body,required"`
}

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
	// sni.cloudflaressl.com as the Common Name if set 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 CertificatePackEditResponseStatus `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   []shared.ResponseInfo       `json:"errors,required"`
	Messages []shared.ResponseInfo       `json:"messages,required"`
	Result   CertificatePackEditResponse `json:"result,required"`
	// Whether the API call was successful
	Success CertificatePackEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    certificatePackEditResponseEnvelopeJSON    `json:"-"`
}

type CertificatePackEditResponseEnvelopeSuccess bool

type CertificatePackEditResponseStatus string

type CertificatePackEditResponseType string

type CertificatePackEditResponseValidationMethod string

type CertificatePackEditResponseValidityDays int64

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

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

type CertificatePackGetResponseEnvelopeSuccess bool

type CertificatePackGetResponseUnion interface {
	ImplementsSSLCertificatePackGetResponseUnion()
}

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 CertificatePackOrderNewParams 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[CertificatePackOrderNewParamsCertificateAuthority] `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[CertificatePackOrderNewParamsType] `json:"type,required"`
	// Validation Method selected for the order.
	ValidationMethod param.Field[CertificatePackOrderNewParamsValidationMethod] `json:"validation_method,required"`
	// Validity Days selected for the order.
	ValidityDays param.Field[CertificatePackOrderNewParamsValidityDays] `json:"validity_days,required"`
	// Whether or not to add Cloudflare Branding for the order. This will add
	// sni.cloudflaressl.com as the Common Name if set true.
	CloudflareBranding param.Field[bool] `json:"cloudflare_branding"`
}

type CertificatePackOrderNewParamsCertificateAuthority string

type CertificatePackOrderNewParamsType string

type CertificatePackOrderNewParamsValidationMethod string

type CertificatePackOrderNewParamsValidityDays int64

type CertificatePackOrderNewResponse 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 CertificatePackOrderNewResponseCertificateAuthority `json:"certificate_authority"`
	// Whether or not to add Cloudflare Branding for the order. This will add
	// sni.cloudflaressl.com as the Common Name if set 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 CertificatePackOrderNewResponseStatus `json:"status"`
	// Type of certificate pack.
	Type CertificatePackOrderNewResponseType `json:"type"`
	// Validation Method selected for the order.
	ValidationMethod CertificatePackOrderNewResponseValidationMethod `json:"validation_method"`
	// Validity Days selected for the order.
	ValidityDays CertificatePackOrderNewResponseValidityDays `json:"validity_days"`
	JSON         certificatePackOrderNewResponseJSON         `json:"-"`
}

type CertificatePackOrderNewResponseCertificateAuthority string

type CertificatePackOrderNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo           `json:"errors,required"`
	Messages []shared.ResponseInfo           `json:"messages,required"`
	Result   CertificatePackOrderNewResponse `json:"result,required"`
	// Whether the API call was successful
	Success CertificatePackOrderNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    certificatePackOrderNewResponseEnvelopeJSON    `json:"-"`
}

type CertificatePackOrderNewResponseEnvelopeSuccess bool

type CertificatePackOrderNewResponseStatus string

type CertificatePackOrderNewResponseType string

type CertificatePackOrderNewResponseValidationMethod string

type CertificatePackOrderNewResponseValidityDays int64

type CertificatePackOrderService struct {
	Options []option.RequestOption
}

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   []shared.ResponseInfo           `json:"errors,required"`
	Messages []shared.ResponseInfo           `json:"messages,required"`
	Result   CertificatePackQuotaGetResponse `json:"result,required"`
	// Whether the API call was successful
	Success CertificatePackQuotaGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    certificatePackQuotaGetResponseEnvelopeJSON    `json:"-"`
}

type CertificatePackQuotaGetResponseEnvelopeSuccess bool

type CertificatePackQuotaService struct {
	Options []option.RequestOption
}

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

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type Error = apierror.Error

type ErrorData = shared.ErrorData

type Host = string

type HostParam = string

type Member = shared.Member

type MemberParam = shared.MemberParam

type MemberRole = shared.MemberRole

type MemberRoleParam = shared.MemberRoleParam

type MemberRolesPermissions = shared.MemberRolesPermissions

type MemberRolesPermissionsParam = shared.MemberRolesPermissionsParam

type MemberUser = shared.MemberUser

type MemberUserParam = shared.MemberUserParam

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type RecommendationGetResponse struct {
	// Identifier of a recommedation 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   []shared.ResponseInfo     `json:"errors,required"`
	Messages []shared.ResponseInfo     `json:"messages,required"`
	Result   RecommendationGetResponse `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RecommendationGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    recommendationGetResponseEnvelopeJSON    `json:"-"`
}

type RecommendationGetResponseEnvelopeSuccess bool

type RecommendationGetResponseValue string

type RecommendationService struct {
	Options []option.RequestOption
}

type ResponseInfo = shared.ResponseInfo

type Role = shared.Role

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

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   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   UniversalSSLSettings  `json:"result,required"`
	// Whether the API call was successful
	Success UniversalSettingEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    universalSettingEditResponseEnvelopeJSON    `json:"-"`
}

type UniversalSettingEditResponseEnvelopeSuccess bool

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

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

type UniversalSettingGetResponseEnvelopeSuccess bool

type UniversalSettingService struct {
	Options []option.RequestOption
}

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 VerificationValidationMethod `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   []shared.ResponseInfo    `json:"errors,required"`
	Messages []shared.ResponseInfo    `json:"messages,required"`
	Result   VerificationEditResponse `json:"result,required"`
	// Whether the API call was successful
	Success VerificationEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    verificationEditResponseEnvelopeJSON    `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 VerificationValidationMethod 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