custom_certificates

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

type CustomCertificateDeleteResponse struct {
	// Identifier
	ID   string                              `json:"id"`
	JSON customCertificateDeleteResponseJSON `json:"-"`
}

type CustomCertificateDeleteResponseEnvelope struct {
	Errors   []CustomCertificateDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CustomCertificateDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   CustomCertificateDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success CustomCertificateDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    customCertificateDeleteResponseEnvelopeJSON    `json:"-"`
}

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

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

type CustomCertificateDeleteResponseEnvelopeSuccess bool

type CustomCertificateEditParams 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[CustomCertificateEditParamsBundleMethod] `json:"bundle_method"`
	// The zone's SSL certificate or certificate and the intermediate(s).
	Certificate param.Field[string] `json:"certificate"`
	// Specify the region where your private key can be held locally for optimal TLS
	// performance. HTTPS connections to any excluded data center will still be fully
	// encrypted, but will incur some latency while Keyless SSL is used to complete the
	// handshake with the nearest allowed data center. Options allow distribution to
	// only to U.S. data centers, only to E.U. data centers, or only to highest
	// security data centers. Default distribution is to all Cloudflare datacenters,
	// for optimal performance.
	GeoRestrictions param.Field[CustomCertificateEditParamsGeoRestrictions] `json:"geo_restrictions"`
	// Specify the policy that determines the region where your private key will be
	// held locally. HTTPS connections to any excluded data center will still be fully
	// encrypted, but will incur some latency while Keyless SSL is used to complete the
	// handshake with the nearest allowed data center. Any combination of countries,
	// specified by their two letter country code
	// (https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements)
	// can be chosen, such as 'country: IN', as well as 'region: EU' which refers to
	// the EU region. If there are too few data centers satisfying the policy, it will
	// be rejected.
	Policy param.Field[string] `json:"policy"`
	// The zone's private key.
	PrivateKey param.Field[string] `json:"private_key"`
}

type CustomCertificateEditParamsBundleMethod string

type CustomCertificateEditParamsGeoRestrictions struct {
	Label param.Field[CustomCertificateEditParamsGeoRestrictionsLabel] `json:"label"`
}

type CustomCertificateEditParamsGeoRestrictionsLabel string

type CustomCertificateEditResponse interface {
	ImplementsCustomCertificatesCustomCertificateEditResponse()
}

type CustomCertificateEditResponseEnvelope struct {
	Errors   []CustomCertificateEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CustomCertificateEditResponseEnvelopeMessages `json:"messages,required"`
	Result   CustomCertificateEditResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success CustomCertificateEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    customCertificateEditResponseEnvelopeJSON    `json:"-"`
}

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

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

type CustomCertificateEditResponseEnvelopeSuccess bool

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

type CustomCertificateGetResponse interface {
	ImplementsCustomCertificatesCustomCertificateGetResponse()
}

type CustomCertificateGetResponseEnvelope struct {
	Errors   []CustomCertificateGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CustomCertificateGetResponseEnvelopeMessages `json:"messages,required"`
	Result   CustomCertificateGetResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success CustomCertificateGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    customCertificateGetResponseEnvelopeJSON    `json:"-"`
}

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

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

type CustomCertificateGetResponseEnvelopeSuccess bool

type CustomCertificateListParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Whether to match all search requirements or at least one (any).
	Match param.Field[CustomCertificateListParamsMatch] `query:"match"`
	// Page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// Number of zones per page.
	PerPage param.Field[float64] `query:"per_page"`
}

type CustomCertificateListParamsMatch string

type CustomCertificateNewParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The zone's SSL certificate or certificate and the intermediate(s).
	Certificate param.Field[string] `json:"certificate,required"`
	// The zone's private key.
	PrivateKey param.Field[string] `json:"private_key,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[CustomCertificateNewParamsBundleMethod] `json:"bundle_method"`
	// Specify the region where your private key can be held locally for optimal TLS
	// performance. HTTPS connections to any excluded data center will still be fully
	// encrypted, but will incur some latency while Keyless SSL is used to complete the
	// handshake with the nearest allowed data center. Options allow distribution to
	// only to U.S. data centers, only to E.U. data centers, or only to highest
	// security data centers. Default distribution is to all Cloudflare datacenters,
	// for optimal performance.
	GeoRestrictions param.Field[CustomCertificateNewParamsGeoRestrictions] `json:"geo_restrictions"`
	// Specify the policy that determines the region where your private key will be
	// held locally. HTTPS connections to any excluded data center will still be fully
	// encrypted, but will incur some latency while Keyless SSL is used to complete the
	// handshake with the nearest allowed data center. Any combination of countries,
	// specified by their two letter country code
	// (https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements)
	// can be chosen, such as 'country: IN', as well as 'region: EU' which refers to
	// the EU region. If there are too few data centers satisfying the policy, it will
	// be rejected.
	Policy param.Field[string] `json:"policy"`
	// The type 'legacy_custom' enables support for legacy clients which do not include
	// SNI in the TLS handshake.
	Type param.Field[CustomCertificateNewParamsType] `json:"type"`
}

type CustomCertificateNewParamsBundleMethod string

type CustomCertificateNewParamsGeoRestrictions struct {
	Label param.Field[CustomCertificateNewParamsGeoRestrictionsLabel] `json:"label"`
}

type CustomCertificateNewParamsGeoRestrictionsLabel string

type CustomCertificateNewParamsType string

type CustomCertificateNewResponse interface {
	ImplementsCustomCertificatesCustomCertificateNewResponse()
}

type CustomCertificateNewResponseEnvelope struct {
	Errors   []CustomCertificateNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []CustomCertificateNewResponseEnvelopeMessages `json:"messages,required"`
	Result   CustomCertificateNewResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success CustomCertificateNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    customCertificateNewResponseEnvelopeJSON    `json:"-"`
}

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

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

type CustomCertificateNewResponseEnvelopeSuccess bool

type CustomCertificateService struct {
	Options    []option.RequestOption
	Prioritize *PrioritizeService
}

type Error = apierror.Error

type PrioritizeService struct {
	Options []option.RequestOption
}

type PrioritizeUpdateParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Array of ordered certificates.
	Certificates param.Field[[]PrioritizeUpdateParamsCertificate] `json:"certificates,required"`
}

type PrioritizeUpdateParamsCertificate struct {
	// The order/priority in which the certificate will be used in a request. The
	// higher priority will break ties across overlapping 'legacy_custom' certificates,
	// but 'legacy_custom' certificates will always supercede 'sni_custom'
	// certificates.
	Priority param.Field[float64] `json:"priority"`
}

type PrioritizeUpdateResponseEnvelope struct {
	Errors   []PrioritizeUpdateResponseEnvelopeErrors       `json:"errors,required"`
	Messages []PrioritizeUpdateResponseEnvelopeMessages     `json:"messages,required"`
	Result   []TLSCertificatesAndHostnamesCustomCertificate `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    PrioritizeUpdateResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo PrioritizeUpdateResponseEnvelopeResultInfo `json:"result_info"`
	JSON       prioritizeUpdateResponseEnvelopeJSON       `json:"-"`
}

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

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

type PrioritizeUpdateResponseEnvelopeResultInfo struct {
	// Total number of results for the requested service
	Count float64 `json:"count"`
	// Current page within paginated list of results
	Page float64 `json:"page"`
	// Number of results per page of results
	PerPage float64 `json:"per_page"`
	// Total results available without any search parameters
	TotalCount float64                                        `json:"total_count"`
	JSON       prioritizeUpdateResponseEnvelopeResultInfoJSON `json:"-"`
}

type PrioritizeUpdateResponseEnvelopeSuccess bool

type TLSCertificatesAndHostnamesCustomCertificate struct {
	// Identifier
	ID string `json:"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 TLSCertificatesAndHostnamesCustomCertificateBundleMethod `json:"bundle_method,required"`
	// When the certificate from the authority expires.
	ExpiresOn time.Time `json:"expires_on,required" format:"date-time"`
	Hosts     []string  `json:"hosts,required"`
	// The certificate authority that issued the certificate.
	Issuer string `json:"issuer,required"`
	// When the certificate was last modified.
	ModifiedOn time.Time `json:"modified_on,required" format:"date-time"`
	// The order/priority in which the certificate will be used in a request. The
	// higher priority will break ties across overlapping 'legacy_custom' certificates,
	// but 'legacy_custom' certificates will always supercede 'sni_custom'
	// certificates.
	Priority float64 `json:"priority,required"`
	// The type of hash used for the certificate.
	Signature string `json:"signature,required"`
	// Status of the zone's custom SSL.
	Status TLSCertificatesAndHostnamesCustomCertificateStatus `json:"status,required"`
	// When the certificate was uploaded to Cloudflare.
	UploadedOn time.Time `json:"uploaded_on,required" format:"date-time"`
	// Identifier
	ZoneID string `json:"zone_id,required"`
	// Specify the region where your private key can be held locally for optimal TLS
	// performance. HTTPS connections to any excluded data center will still be fully
	// encrypted, but will incur some latency while Keyless SSL is used to complete the
	// handshake with the nearest allowed data center. Options allow distribution to
	// only to U.S. data centers, only to E.U. data centers, or only to highest
	// security data centers. Default distribution is to all Cloudflare datacenters,
	// for optimal performance.
	GeoRestrictions TLSCertificatesAndHostnamesCustomCertificateGeoRestrictions `json:"geo_restrictions"`
	KeylessServer   keyless_certificates.TLSCertificatesAndHostnamesBase        `json:"keyless_server"`
	// Specify the policy that determines the region where your private key will be
	// held locally. HTTPS connections to any excluded data center will still be fully
	// encrypted, but will incur some latency while Keyless SSL is used to complete the
	// handshake with the nearest allowed data center. Any combination of countries,
	// specified by their two letter country code
	// (https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements)
	// can be chosen, such as 'country: IN', as well as 'region: EU' which refers to
	// the EU region. If there are too few data centers satisfying the policy, it will
	// be rejected.
	Policy string                                           `json:"policy"`
	JSON   tlsCertificatesAndHostnamesCustomCertificateJSON `json:"-"`
}

type TLSCertificatesAndHostnamesCustomCertificateBundleMethod string

type TLSCertificatesAndHostnamesCustomCertificateGeoRestrictions struct {
	Label TLSCertificatesAndHostnamesCustomCertificateGeoRestrictionsLabel `json:"label"`
	JSON  tlsCertificatesAndHostnamesCustomCertificateGeoRestrictionsJSON  `json:"-"`
}

type TLSCertificatesAndHostnamesCustomCertificateGeoRestrictionsLabel string

type TLSCertificatesAndHostnamesCustomCertificateStatus string