zones

package
v2.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 24, 2024 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

View Source 
const AuditLogActorTypeAdmin = shared.AuditLogActorTypeAdmin

This is an alias to an internal value.

View Source 
const AuditLogActorTypeCloudflare = shared.AuditLogActorTypeCloudflare

This is an alias to an internal value.

View Source 
const AuditLogActorTypeUser = shared.AuditLogActorTypeUser

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeCNI = shared.CloudflareTunnelTunTypeCNI

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeCfdTunnel = shared.CloudflareTunnelTunTypeCfdTunnel

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeGRE = shared.CloudflareTunnelTunTypeGRE

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeIPSec = shared.CloudflareTunnelTunTypeIPSec

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeWARPConnector = shared.CloudflareTunnelTunTypeWARPConnector

This is an alias to an internal value.

Variables

This section is empty.

Functions

This section is empty.

Types

type ASN added in v2.1.0 

type ASN = shared.ASN

This is an alias to an internal type.

type ASNParam added in v2.1.0 

type ASNParam = shared.ASNParam

This is an alias to an internal type.

type ActivationCheckService 

type ActivationCheckService struct {
	Options []option.RequestOption
}

ActivationCheckService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewActivationCheckService method instead.

func NewActivationCheckService 

func NewActivationCheckService(opts ...option.RequestOption) (r *ActivationCheckService)

NewActivationCheckService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ActivationCheckService) Trigger 

func (r *ActivationCheckService) Trigger(ctx context.Context, body ActivationCheckTriggerParams, opts ...option.RequestOption) (res *ActivationCheckTriggerResponse, err error)

Triggeres a new activation check for a PENDING Zone. This can be triggered every 5 min for paygo/ent customers, every hour for FREE Zones.

type ActivationCheckTriggerParams 

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

type ActivationCheckTriggerResponse 

type ActivationCheckTriggerResponse struct {
	// Identifier
	ID   string                             `json:"id"`
	JSON activationCheckTriggerResponseJSON `json:"-"`
}

func (*ActivationCheckTriggerResponse) UnmarshalJSON 

func (r *ActivationCheckTriggerResponse) UnmarshalJSON(data []byte) (err error)

type ActivationCheckTriggerResponseEnvelope 

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

func (*ActivationCheckTriggerResponseEnvelope) UnmarshalJSON 

func (r *ActivationCheckTriggerResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type ActivationCheckTriggerResponseEnvelopeSuccess 

type ActivationCheckTriggerResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	ActivationCheckTriggerResponseEnvelopeSuccessTrue ActivationCheckTriggerResponseEnvelopeSuccess = true
)

func (ActivationCheckTriggerResponseEnvelopeSuccess) IsKnown 

func (r ActivationCheckTriggerResponseEnvelopeSuccess) IsKnown() bool

type AdvancedDDoS 

type AdvancedDDoS struct {
	// ID of the zone setting.
	ID AdvancedDDoSID `json:"id,required"`
	// Current value of the zone setting.
	Value AdvancedDDoSValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable AdvancedDDoSEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time        `json:"modified_on,nullable" format:"date-time"`
	JSON       advancedDDoSJSON `json:"-"`
}

Advanced protection from Distributed Denial of Service (DDoS) attacks on your website. This is an uneditable value that is 'on' in the case of Business and Enterprise zones.

func (*AdvancedDDoS) UnmarshalJSON 

func (r *AdvancedDDoS) UnmarshalJSON(data []byte) (err error)

type AdvancedDDoSEditable 

type AdvancedDDoSEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	AdvancedDDoSEditableTrue  AdvancedDDoSEditable = true
	AdvancedDDoSEditableFalse AdvancedDDoSEditable = false
)

func (AdvancedDDoSEditable) IsKnown 

func (r AdvancedDDoSEditable) IsKnown() bool

type AdvancedDDoSID 

type AdvancedDDoSID string

ID of the zone setting. 

const (
	AdvancedDDoSIDAdvancedDDoS AdvancedDDoSID = "advanced_ddos"
)

func (AdvancedDDoSID) IsKnown 

func (r AdvancedDDoSID) IsKnown() bool

type AdvancedDDoSValue 

type AdvancedDDoSValue string

Current value of the zone setting. 

const (
	AdvancedDDoSValueOn  AdvancedDDoSValue = "on"
	AdvancedDDoSValueOff AdvancedDDoSValue = "off"
)

func (AdvancedDDoSValue) IsKnown 

func (r AdvancedDDoSValue) IsKnown() bool

type AlwaysOnline 

type AlwaysOnline struct {
	// ID of the zone setting.
	ID AlwaysOnlineID `json:"id,required"`
	// Current value of the zone setting.
	Value AlwaysOnlineValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable AlwaysOnlineEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time        `json:"modified_on,nullable" format:"date-time"`
	JSON       alwaysOnlineJSON `json:"-"`
}

When enabled, Cloudflare serves limited copies of web pages available from the [Internet Archive's Wayback Machine](https://archive.org/web/) if your server is offline. Refer to [Always Online](https://developers.cloudflare.com/cache/about/always-online) for more information.

func (*AlwaysOnline) UnmarshalJSON 

func (r *AlwaysOnline) UnmarshalJSON(data []byte) (err error)

type AlwaysOnlineEditable 

type AlwaysOnlineEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	AlwaysOnlineEditableTrue  AlwaysOnlineEditable = true
	AlwaysOnlineEditableFalse AlwaysOnlineEditable = false
)

func (AlwaysOnlineEditable) IsKnown 

func (r AlwaysOnlineEditable) IsKnown() bool

type AlwaysOnlineID 

type AlwaysOnlineID string

ID of the zone setting. 

const (
	AlwaysOnlineIDAlwaysOnline AlwaysOnlineID = "always_online"
)

func (AlwaysOnlineID) IsKnown 

func (r AlwaysOnlineID) IsKnown() bool

type AlwaysOnlineValue 

type AlwaysOnlineValue string

Current value of the zone setting. 

const (
	AlwaysOnlineValueOn  AlwaysOnlineValue = "on"
	AlwaysOnlineValueOff AlwaysOnlineValue = "off"
)

func (AlwaysOnlineValue) IsKnown 

func (r AlwaysOnlineValue) IsKnown() bool

type AlwaysUseHTTPS 

type AlwaysUseHTTPS struct {
	// ID of the zone setting.
	ID AlwaysUseHTTPSID `json:"id,required"`
	// Current value of the zone setting.
	Value AlwaysUseHTTPSValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable AlwaysUseHTTPSEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time          `json:"modified_on,nullable" format:"date-time"`
	JSON       alwaysUseHTTPSJSON `json:"-"`
}

Reply to all requests for URLs that use "http" with a 301 redirect to the equivalent "https" URL. If you only want to redirect for a subset of requests, consider creating an "Always use HTTPS" page rule.

func (*AlwaysUseHTTPS) UnmarshalJSON 

func (r *AlwaysUseHTTPS) UnmarshalJSON(data []byte) (err error)

type AlwaysUseHTTPSEditable 

type AlwaysUseHTTPSEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	AlwaysUseHTTPSEditableTrue  AlwaysUseHTTPSEditable = true
	AlwaysUseHTTPSEditableFalse AlwaysUseHTTPSEditable = false
)

func (AlwaysUseHTTPSEditable) IsKnown 

func (r AlwaysUseHTTPSEditable) IsKnown() bool

type AlwaysUseHTTPSID 

type AlwaysUseHTTPSID string

ID of the zone setting. 

const (
	AlwaysUseHTTPSIDAlwaysUseHTTPS AlwaysUseHTTPSID = "always_use_https"
)

func (AlwaysUseHTTPSID) IsKnown 

func (r AlwaysUseHTTPSID) IsKnown() bool

type AlwaysUseHTTPSValue 

type AlwaysUseHTTPSValue string

Current value of the zone setting. 

const (
	AlwaysUseHTTPSValueOn  AlwaysUseHTTPSValue = "on"
	AlwaysUseHTTPSValueOff AlwaysUseHTTPSValue = "off"
)

func (AlwaysUseHTTPSValue) IsKnown 

func (r AlwaysUseHTTPSValue) IsKnown() bool

type AuditLog 

type AuditLog = shared.AuditLog

This is an alias to an internal type.

type AuditLogAction 

type AuditLogAction = shared.AuditLogAction

This is an alias to an internal type.

type AuditLogActor 

type AuditLogActor = shared.AuditLogActor

This is an alias to an internal type.

type AuditLogActorType 

type AuditLogActorType = shared.AuditLogActorType

The type of actor, whether a User, Cloudflare Admin, or an Automated System.

This is an alias to an internal type.

type AuditLogOwner 

type AuditLogOwner = shared.AuditLogOwner

This is an alias to an internal type.

type AuditLogResource 

type AuditLogResource = shared.AuditLogResource

This is an alias to an internal type.

type AutomaticHTTPSRewrites 

type AutomaticHTTPSRewrites struct {
	// ID of the zone setting.
	ID AutomaticHTTPSRewritesID `json:"id,required"`
	// Current value of the zone setting.
	Value AutomaticHTTPSRewritesValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable AutomaticHTTPSRewritesEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time                  `json:"modified_on,nullable" format:"date-time"`
	JSON       automaticHTTPSRewritesJSON `json:"-"`
}

Enable the Automatic HTTPS Rewrites feature for this zone.

func (*AutomaticHTTPSRewrites) UnmarshalJSON 

func (r *AutomaticHTTPSRewrites) UnmarshalJSON(data []byte) (err error)

type AutomaticHTTPSRewritesEditable 

type AutomaticHTTPSRewritesEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	AutomaticHTTPSRewritesEditableTrue  AutomaticHTTPSRewritesEditable = true
	AutomaticHTTPSRewritesEditableFalse AutomaticHTTPSRewritesEditable = false
)

func (AutomaticHTTPSRewritesEditable) IsKnown 

func (r AutomaticHTTPSRewritesEditable) IsKnown() bool

type AutomaticHTTPSRewritesID 

type AutomaticHTTPSRewritesID string

ID of the zone setting. 

const (
	AutomaticHTTPSRewritesIDAutomaticHTTPSRewrites AutomaticHTTPSRewritesID = "automatic_https_rewrites"
)

func (AutomaticHTTPSRewritesID) IsKnown 

func (r AutomaticHTTPSRewritesID) IsKnown() bool

type AutomaticHTTPSRewritesValue 

type AutomaticHTTPSRewritesValue string

Current value of the zone setting. 

const (
	AutomaticHTTPSRewritesValueOn  AutomaticHTTPSRewritesValue = "on"
	AutomaticHTTPSRewritesValueOff AutomaticHTTPSRewritesValue = "off"
)

func (AutomaticHTTPSRewritesValue) IsKnown 

func (r AutomaticHTTPSRewritesValue) IsKnown() bool

type AutomaticPlatformOptimization 

type AutomaticPlatformOptimization struct {
	// Indicates whether or not
	// [cache by device type](https://developers.cloudflare.com/automatic-platform-optimization/reference/cache-device-type/)
	// is enabled.
	CacheByDeviceType bool `json:"cache_by_device_type,required"`
	// Indicates whether or not Cloudflare proxy is enabled.
	Cf bool `json:"cf,required"`
	// Indicates whether or not Automatic Platform Optimization is enabled.
	Enabled bool `json:"enabled,required"`
	// An array of hostnames where Automatic Platform Optimization for WordPress is
	// activated.
	Hostnames []string `json:"hostnames,required" format:"hostname"`
	// Indicates whether or not site is powered by WordPress.
	Wordpress bool `json:"wordpress,required"`
	// Indicates whether or not
	// [Cloudflare for WordPress plugin](https://wordpress.org/plugins/cloudflare/) is
	// installed.
	WpPlugin bool                              `json:"wp_plugin,required"`
	JSON     automaticPlatformOptimizationJSON `json:"-"`
}

func (*AutomaticPlatformOptimization) UnmarshalJSON 

func (r *AutomaticPlatformOptimization) UnmarshalJSON(data []byte) (err error)

type AutomaticPlatformOptimizationParam 

type AutomaticPlatformOptimizationParam struct {
	// Indicates whether or not
	// [cache by device type](https://developers.cloudflare.com/automatic-platform-optimization/reference/cache-device-type/)
	// is enabled.
	CacheByDeviceType param.Field[bool] `json:"cache_by_device_type,required"`
	// Indicates whether or not Cloudflare proxy is enabled.
	Cf param.Field[bool] `json:"cf,required"`
	// Indicates whether or not Automatic Platform Optimization is enabled.
	Enabled param.Field[bool] `json:"enabled,required"`
	// An array of hostnames where Automatic Platform Optimization for WordPress is
	// activated.
	Hostnames param.Field[[]string] `json:"hostnames,required" format:"hostname"`
	// Indicates whether or not site is powered by WordPress.
	Wordpress param.Field[bool] `json:"wordpress,required"`
	// Indicates whether or not
	// [Cloudflare for WordPress plugin](https://wordpress.org/plugins/cloudflare/) is
	// installed.
	WpPlugin param.Field[bool] `json:"wp_plugin,required"`
}

func (AutomaticPlatformOptimizationParam) MarshalJSON 

func (r AutomaticPlatformOptimizationParam) MarshalJSON() (data []byte, err error)

type Brotli 

type Brotli struct {
	// ID of the zone setting.
	ID BrotliID `json:"id,required"`
	// Current value of the zone setting.
	Value BrotliValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable BrotliEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time  `json:"modified_on,nullable" format:"date-time"`
	JSON       brotliJSON `json:"-"`
}

When the client requesting an asset supports the Brotli compression algorithm, Cloudflare will serve a Brotli compressed version of the asset.

func (*Brotli) UnmarshalJSON 

func (r *Brotli) UnmarshalJSON(data []byte) (err error)

type BrotliEditable 

type BrotliEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	BrotliEditableTrue  BrotliEditable = true
	BrotliEditableFalse BrotliEditable = false
)

func (BrotliEditable) IsKnown 

func (r BrotliEditable) IsKnown() bool

type BrotliID 

type BrotliID string

ID of the zone setting. 

const (
	BrotliIDBrotli BrotliID = "brotli"
)

func (BrotliID) IsKnown 

func (r BrotliID) IsKnown() bool

type BrotliValue 

type BrotliValue string

Current value of the zone setting. 

const (
	BrotliValueOff BrotliValue = "off"
	BrotliValueOn  BrotliValue = "on"
)

func (BrotliValue) IsKnown 

func (r BrotliValue) IsKnown() bool

type BrowserCacheTTL 

type BrowserCacheTTL struct {
	// ID of the zone setting.
	ID BrowserCacheTTLID `json:"id,required"`
	// Current value of the zone setting.
	Value BrowserCacheTTLValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable BrowserCacheTTLEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time           `json:"modified_on,nullable" format:"date-time"`
	JSON       browserCacheTTLJSON `json:"-"`
}

Browser Cache TTL (in seconds) specifies how long Cloudflare-cached resources will remain on your visitors' computers. Cloudflare will honor any larger times specified by your server. (https://support.cloudflare.com/hc/en-us/articles/200168276).

func (*BrowserCacheTTL) UnmarshalJSON 

func (r *BrowserCacheTTL) UnmarshalJSON(data []byte) (err error)

type BrowserCacheTTLEditable 

type BrowserCacheTTLEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	BrowserCacheTTLEditableTrue  BrowserCacheTTLEditable = true
	BrowserCacheTTLEditableFalse BrowserCacheTTLEditable = false
)

func (BrowserCacheTTLEditable) IsKnown 

func (r BrowserCacheTTLEditable) IsKnown() bool

type BrowserCacheTTLID 

type BrowserCacheTTLID string

ID of the zone setting. 

const (
	BrowserCacheTTLIDBrowserCacheTTL BrowserCacheTTLID = "browser_cache_ttl"
)

func (BrowserCacheTTLID) IsKnown 

func (r BrowserCacheTTLID) IsKnown() bool

type BrowserCacheTTLValue 

type BrowserCacheTTLValue float64

Current value of the zone setting. 

const (
	BrowserCacheTTLValue0        BrowserCacheTTLValue = 0
	BrowserCacheTTLValue30       BrowserCacheTTLValue = 30
	BrowserCacheTTLValue60       BrowserCacheTTLValue = 60
	BrowserCacheTTLValue120      BrowserCacheTTLValue = 120
	BrowserCacheTTLValue300      BrowserCacheTTLValue = 300
	BrowserCacheTTLValue1200     BrowserCacheTTLValue = 1200
	BrowserCacheTTLValue1800     BrowserCacheTTLValue = 1800
	BrowserCacheTTLValue3600     BrowserCacheTTLValue = 3600
	BrowserCacheTTLValue7200     BrowserCacheTTLValue = 7200
	BrowserCacheTTLValue10800    BrowserCacheTTLValue = 10800
	BrowserCacheTTLValue14400    BrowserCacheTTLValue = 14400
	BrowserCacheTTLValue18000    BrowserCacheTTLValue = 18000
	BrowserCacheTTLValue28800    BrowserCacheTTLValue = 28800
	BrowserCacheTTLValue43200    BrowserCacheTTLValue = 43200
	BrowserCacheTTLValue57600    BrowserCacheTTLValue = 57600
	BrowserCacheTTLValue72000    BrowserCacheTTLValue = 72000
	BrowserCacheTTLValue86400    BrowserCacheTTLValue = 86400
	BrowserCacheTTLValue172800   BrowserCacheTTLValue = 172800
	BrowserCacheTTLValue259200   BrowserCacheTTLValue = 259200
	BrowserCacheTTLValue345600   BrowserCacheTTLValue = 345600
	BrowserCacheTTLValue432000   BrowserCacheTTLValue = 432000
	BrowserCacheTTLValue691200   BrowserCacheTTLValue = 691200
	BrowserCacheTTLValue1382400  BrowserCacheTTLValue = 1382400
	BrowserCacheTTLValue2073600  BrowserCacheTTLValue = 2073600
	BrowserCacheTTLValue2678400  BrowserCacheTTLValue = 2678400
	BrowserCacheTTLValue5356800  BrowserCacheTTLValue = 5356800
	BrowserCacheTTLValue16070400 BrowserCacheTTLValue = 16070400
	BrowserCacheTTLValue31536000 BrowserCacheTTLValue = 31536000
)

func (BrowserCacheTTLValue) IsKnown 

func (r BrowserCacheTTLValue) IsKnown() bool

type BrowserCheck 

type BrowserCheck struct {
	// ID of the zone setting.
	ID BrowserCheckID `json:"id,required"`
	// Current value of the zone setting.
	Value BrowserCheckValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable BrowserCheckEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time        `json:"modified_on,nullable" format:"date-time"`
	JSON       browserCheckJSON `json:"-"`
}

Browser Integrity Check is similar to Bad Behavior and looks for common HTTP headers abused most commonly by spammers and denies access to your page. It will also challenge visitors that do not have a user agent or a non standard user agent (also commonly used by abuse bots, crawlers or visitors). (https://support.cloudflare.com/hc/en-us/articles/200170086).

func (*BrowserCheck) UnmarshalJSON 

func (r *BrowserCheck) UnmarshalJSON(data []byte) (err error)

type BrowserCheckEditable 

type BrowserCheckEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	BrowserCheckEditableTrue  BrowserCheckEditable = true
	BrowserCheckEditableFalse BrowserCheckEditable = false
)

func (BrowserCheckEditable) IsKnown 

func (r BrowserCheckEditable) IsKnown() bool

type BrowserCheckID 

type BrowserCheckID string

ID of the zone setting. 

const (
	BrowserCheckIDBrowserCheck BrowserCheckID = "browser_check"
)

func (BrowserCheckID) IsKnown 

func (r BrowserCheckID) IsKnown() bool

type BrowserCheckValue 

type BrowserCheckValue string

Current value of the zone setting. 

const (
	BrowserCheckValueOn  BrowserCheckValue = "on"
	BrowserCheckValueOff BrowserCheckValue = "off"
)

func (BrowserCheckValue) IsKnown 

func (r BrowserCheckValue) IsKnown() bool

type CacheLevel 

type CacheLevel struct {
	// ID of the zone setting.
	ID CacheLevelID `json:"id,required"`
	// Current value of the zone setting.
	Value CacheLevelValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable CacheLevelEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time      `json:"modified_on,nullable" format:"date-time"`
	JSON       cacheLevelJSON `json:"-"`
}

Cache Level functions based off the setting level. The basic setting will cache most static resources (i.e., css, images, and JavaScript). The simplified setting will ignore the query string when delivering a cached resource. The aggressive setting will cache all static resources, including ones with a query string. (https://support.cloudflare.com/hc/en-us/articles/200168256).

func (*CacheLevel) UnmarshalJSON 

func (r *CacheLevel) UnmarshalJSON(data []byte) (err error)

type CacheLevelEditable 

type CacheLevelEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	CacheLevelEditableTrue  CacheLevelEditable = true
	CacheLevelEditableFalse CacheLevelEditable = false
)

func (CacheLevelEditable) IsKnown 

func (r CacheLevelEditable) IsKnown() bool

type CacheLevelID 

type CacheLevelID string

ID of the zone setting. 

const (
	CacheLevelIDCacheLevel CacheLevelID = "cache_level"
)

func (CacheLevelID) IsKnown 

func (r CacheLevelID) IsKnown() bool

type CacheLevelValue 

type CacheLevelValue string

Current value of the zone setting. 

const (
	CacheLevelValueAggressive CacheLevelValue = "aggressive"
	CacheLevelValueBasic      CacheLevelValue = "basic"
	CacheLevelValueSimplified CacheLevelValue = "simplified"
)

func (CacheLevelValue) IsKnown 

func (r CacheLevelValue) IsKnown() bool

type ChallengeTTL 

type ChallengeTTL struct {
	// ID of the zone setting.
	ID ChallengeTTLID `json:"id,required"`
	// Current value of the zone setting.
	Value ChallengeTTLValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable ChallengeTTLEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time        `json:"modified_on,nullable" format:"date-time"`
	JSON       challengeTTLJSON `json:"-"`
}

Specify how long a visitor is allowed access to your site after successfully completing a challenge (such as a CAPTCHA). After the TTL has expired the visitor will have to complete a new challenge. We recommend a 15 - 45 minute setting and will attempt to honor any setting above 45 minutes. (https://support.cloudflare.com/hc/en-us/articles/200170136).

func (*ChallengeTTL) UnmarshalJSON 

func (r *ChallengeTTL) UnmarshalJSON(data []byte) (err error)

type ChallengeTTLEditable 

type ChallengeTTLEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	ChallengeTTLEditableTrue  ChallengeTTLEditable = true
	ChallengeTTLEditableFalse ChallengeTTLEditable = false
)

func (ChallengeTTLEditable) IsKnown 

func (r ChallengeTTLEditable) IsKnown() bool

type ChallengeTTLID 

type ChallengeTTLID string

ID of the zone setting. 

const (
	ChallengeTTLIDChallengeTTL ChallengeTTLID = "challenge_ttl"
)

func (ChallengeTTLID) IsKnown 

func (r ChallengeTTLID) IsKnown() bool

type ChallengeTTLValue 

type ChallengeTTLValue float64

Current value of the zone setting. 

const (
	ChallengeTTLValue300      ChallengeTTLValue = 300
	ChallengeTTLValue900      ChallengeTTLValue = 900
	ChallengeTTLValue1800     ChallengeTTLValue = 1800
	ChallengeTTLValue2700     ChallengeTTLValue = 2700
	ChallengeTTLValue3600     ChallengeTTLValue = 3600
	ChallengeTTLValue7200     ChallengeTTLValue = 7200
	ChallengeTTLValue10800    ChallengeTTLValue = 10800
	ChallengeTTLValue14400    ChallengeTTLValue = 14400
	ChallengeTTLValue28800    ChallengeTTLValue = 28800
	ChallengeTTLValue57600    ChallengeTTLValue = 57600
	ChallengeTTLValue86400    ChallengeTTLValue = 86400
	ChallengeTTLValue604800   ChallengeTTLValue = 604800
	ChallengeTTLValue2592000  ChallengeTTLValue = 2592000
	ChallengeTTLValue31536000 ChallengeTTLValue = 31536000
)

func (ChallengeTTLValue) IsKnown 

func (r ChallengeTTLValue) IsKnown() bool

type Ciphers 

type Ciphers struct {
	// ID of the zone setting.
	ID CiphersID `json:"id,required"`
	// Current value of the zone setting.
	Value []string `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable CiphersEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time   `json:"modified_on,nullable" format:"date-time"`
	JSON       ciphersJSON `json:"-"`
}

An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format.

func (*Ciphers) UnmarshalJSON 

func (r *Ciphers) UnmarshalJSON(data []byte) (err error)

type CiphersEditable 

type CiphersEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	CiphersEditableTrue  CiphersEditable = true
	CiphersEditableFalse CiphersEditable = false
)

func (CiphersEditable) IsKnown 

func (r CiphersEditable) IsKnown() bool

type CiphersID 

type CiphersID string

ID of the zone setting. 

const (
	CiphersIDCiphers CiphersID = "ciphers"
)

func (CiphersID) IsKnown 

func (r CiphersID) IsKnown() bool

type CloudflareTunnel 

type CloudflareTunnel = shared.CloudflareTunnel

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

This is an alias to an internal type.

type CloudflareTunnelConnection 

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

This is an alias to an internal type.

type CloudflareTunnelTunType 

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

The type of tunnel.

This is an alias to an internal type.

type CustomNameserverGetParams 

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

type CustomNameserverGetResponseArray 

type CustomNameserverGetResponseArray []interface{}

func (CustomNameserverGetResponseArray) ImplementsZonesCustomNameserverGetResponseUnion 

func (r CustomNameserverGetResponseArray) ImplementsZonesCustomNameserverGetResponseUnion()

type CustomNameserverGetResponseEnvelope 

type CustomNameserverGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo            `json:"errors,required"`
	Messages []shared.ResponseInfo            `json:"messages,required"`
	Result   CustomNameserverGetResponseUnion `json:"result,required,nullable"`
	// Whether the API call was successful
	Success CustomNameserverGetResponseEnvelopeSuccess `json:"success,required"`
	// Whether zone uses account-level custom nameservers.
	Enabled bool `json:"enabled"`
	// The number of the name server set to assign to the zone.
	NSSet      float64                                       `json:"ns_set"`
	ResultInfo CustomNameserverGetResponseEnvelopeResultInfo `json:"result_info"`
	JSON       customNameserverGetResponseEnvelopeJSON       `json:"-"`
}

func (*CustomNameserverGetResponseEnvelope) UnmarshalJSON 

func (r *CustomNameserverGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type CustomNameserverGetResponseEnvelopeResultInfo 

type CustomNameserverGetResponseEnvelopeResultInfo 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       customNameserverGetResponseEnvelopeResultInfoJSON `json:"-"`
}

func (*CustomNameserverGetResponseEnvelopeResultInfo) UnmarshalJSON 

func (r *CustomNameserverGetResponseEnvelopeResultInfo) UnmarshalJSON(data []byte) (err error)

type CustomNameserverGetResponseEnvelopeSuccess 

type CustomNameserverGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	CustomNameserverGetResponseEnvelopeSuccessTrue CustomNameserverGetResponseEnvelopeSuccess = true
)

func (CustomNameserverGetResponseEnvelopeSuccess) IsKnown 

func (r CustomNameserverGetResponseEnvelopeSuccess) IsKnown() bool

type CustomNameserverGetResponseUnion 

type CustomNameserverGetResponseUnion interface {
	ImplementsZonesCustomNameserverGetResponseUnion()
}

Union satisfied by zones.CustomNameserverGetResponseUnknown, zones.CustomNameserverGetResponseArray or shared.UnionString.

type CustomNameserverService 

type CustomNameserverService struct {
	Options []option.RequestOption
}

CustomNameserverService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCustomNameserverService method instead.

func NewCustomNameserverService 

func NewCustomNameserverService(opts ...option.RequestOption) (r *CustomNameserverService)

NewCustomNameserverService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CustomNameserverService) Get 

func (r *CustomNameserverService) Get(ctx context.Context, query CustomNameserverGetParams, opts ...option.RequestOption) (res *CustomNameserverGetResponseUnion, err error)

Get metadata for account-level custom nameservers on a zone.

func (*CustomNameserverService) Update 

func (r *CustomNameserverService) Update(ctx context.Context, params CustomNameserverUpdateParams, opts ...option.RequestOption) (res *CustomNameserverUpdateResponseUnion, err error)

Set metadata for account-level custom nameservers on a zone.

If you would like new zones in the account to use account custom nameservers by default, use PUT /accounts/:identifier to set the account setting use_account_custom_ns_by_default to true.

type CustomNameserverUpdateParams 

type CustomNameserverUpdateParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Whether zone uses account-level custom nameservers.
	Enabled param.Field[bool] `json:"enabled"`
	// The number of the name server set to assign to the zone.
	NSSet param.Field[float64] `json:"ns_set"`
}

func (CustomNameserverUpdateParams) MarshalJSON 

func (r CustomNameserverUpdateParams) MarshalJSON() (data []byte, err error)

type CustomNameserverUpdateResponseArray 

type CustomNameserverUpdateResponseArray []interface{}

func (CustomNameserverUpdateResponseArray) ImplementsZonesCustomNameserverUpdateResponseUnion 

func (r CustomNameserverUpdateResponseArray) ImplementsZonesCustomNameserverUpdateResponseUnion()

type CustomNameserverUpdateResponseEnvelope 

type CustomNameserverUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo               `json:"errors,required"`
	Messages []shared.ResponseInfo               `json:"messages,required"`
	Result   CustomNameserverUpdateResponseUnion `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    CustomNameserverUpdateResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo CustomNameserverUpdateResponseEnvelopeResultInfo `json:"result_info"`
	JSON       customNameserverUpdateResponseEnvelopeJSON       `json:"-"`
}

func (*CustomNameserverUpdateResponseEnvelope) UnmarshalJSON 

func (r *CustomNameserverUpdateResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type CustomNameserverUpdateResponseEnvelopeResultInfo 

type CustomNameserverUpdateResponseEnvelopeResultInfo 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       customNameserverUpdateResponseEnvelopeResultInfoJSON `json:"-"`
}

func (*CustomNameserverUpdateResponseEnvelopeResultInfo) UnmarshalJSON 

func (r *CustomNameserverUpdateResponseEnvelopeResultInfo) UnmarshalJSON(data []byte) (err error)

type CustomNameserverUpdateResponseEnvelopeSuccess 

type CustomNameserverUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	CustomNameserverUpdateResponseEnvelopeSuccessTrue CustomNameserverUpdateResponseEnvelopeSuccess = true
)

func (CustomNameserverUpdateResponseEnvelopeSuccess) IsKnown 

func (r CustomNameserverUpdateResponseEnvelopeSuccess) IsKnown() bool

type CustomNameserverUpdateResponseUnion 

type CustomNameserverUpdateResponseUnion interface {
	ImplementsZonesCustomNameserverUpdateResponseUnion()
}

Union satisfied by zones.CustomNameserverUpdateResponseUnknown, zones.CustomNameserverUpdateResponseArray or shared.UnionString.

type DNSSetting 

type DNSSetting struct {
	// Whether to enable Foundation DNS Advanced Nameservers on the zone.
	FoundationDNS bool `json:"foundation_dns"`
	// Whether to enable multi-provider DNS, which causes Cloudflare to activate the
	// zone even when non-Cloudflare NS records exist, and to respect NS records at the
	// zone apex during outbound zone transfers.
	MultiProvider bool `json:"multi_provider"`
	// Settings determining the nameservers through which the zone should be available.
	Nameservers Nameserver `json:"nameservers"`
	// Allows a Secondary DNS zone to use (proxied) override records and CNAME
	// flattening at the zone apex.
	SecondaryOverrides bool           `json:"secondary_overrides"`
	JSON               dnsSettingJSON `json:"-"`
}

func (*DNSSetting) UnmarshalJSON 

func (r *DNSSetting) UnmarshalJSON(data []byte) (err error)

type DNSSettingEditParams 

type DNSSettingEditParams struct {
	// Identifier
	ZoneID     param.Field[string] `path:"zone_id,required"`
	DNSSetting DNSSettingParam     `json:"dns_setting,required"`
}

func (DNSSettingEditParams) MarshalJSON 

func (r DNSSettingEditParams) MarshalJSON() (data []byte, err error)

type DNSSettingEditResponseEnvelope 

type DNSSettingEditResponseEnvelope struct {
	Errors             []shared.ResponseInfo `json:"errors,required"`
	FoundationDNS      interface{}           `json:"foundation_dns,required"`
	Messages           []shared.ResponseInfo `json:"messages,required"`
	MultiProvider      interface{}           `json:"multi_provider,required"`
	Nameservers        interface{}           `json:"nameservers,required"`
	SecondaryOverrides interface{}           `json:"secondary_overrides,required"`
	// Whether the API call was successful
	Success DNSSettingEditResponseEnvelopeSuccess `json:"success,required"`
	Result  DNSSetting                            `json:"result"`
	JSON    dnsSettingEditResponseEnvelopeJSON    `json:"-"`
}

func (*DNSSettingEditResponseEnvelope) UnmarshalJSON 

func (r *DNSSettingEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type DNSSettingEditResponseEnvelopeSuccess 

type DNSSettingEditResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	DNSSettingEditResponseEnvelopeSuccessTrue DNSSettingEditResponseEnvelopeSuccess = true
)

func (DNSSettingEditResponseEnvelopeSuccess) IsKnown 

func (r DNSSettingEditResponseEnvelopeSuccess) IsKnown() bool

type DNSSettingGetParams 

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

type DNSSettingGetResponseEnvelope 

type DNSSettingGetResponseEnvelope struct {
	Errors             []shared.ResponseInfo `json:"errors,required"`
	FoundationDNS      interface{}           `json:"foundation_dns,required"`
	Messages           []shared.ResponseInfo `json:"messages,required"`
	MultiProvider      interface{}           `json:"multi_provider,required"`
	Nameservers        interface{}           `json:"nameservers,required"`
	SecondaryOverrides interface{}           `json:"secondary_overrides,required"`
	// Whether the API call was successful
	Success DNSSettingGetResponseEnvelopeSuccess `json:"success,required"`
	Result  DNSSetting                           `json:"result"`
	JSON    dnsSettingGetResponseEnvelopeJSON    `json:"-"`
}

func (*DNSSettingGetResponseEnvelope) UnmarshalJSON 

func (r *DNSSettingGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type DNSSettingGetResponseEnvelopeSuccess 

type DNSSettingGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	DNSSettingGetResponseEnvelopeSuccessTrue DNSSettingGetResponseEnvelopeSuccess = true
)

func (DNSSettingGetResponseEnvelopeSuccess) IsKnown 

func (r DNSSettingGetResponseEnvelopeSuccess) IsKnown() bool

type DNSSettingParam 

type DNSSettingParam struct {
	// Whether to enable Foundation DNS Advanced Nameservers on the zone.
	FoundationDNS param.Field[bool] `json:"foundation_dns"`
	// Whether to enable multi-provider DNS, which causes Cloudflare to activate the
	// zone even when non-Cloudflare NS records exist, and to respect NS records at the
	// zone apex during outbound zone transfers.
	MultiProvider param.Field[bool] `json:"multi_provider"`
	// Settings determining the nameservers through which the zone should be available.
	Nameservers param.Field[NameserverParam] `json:"nameservers"`
	// Allows a Secondary DNS zone to use (proxied) override records and CNAME
	// flattening at the zone apex.
	SecondaryOverrides param.Field[bool] `json:"secondary_overrides"`
}

func (DNSSettingParam) MarshalJSON 

func (r DNSSettingParam) MarshalJSON() (data []byte, err error)

type DNSSettingService 

type DNSSettingService struct {
	Options []option.RequestOption
}

DNSSettingService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDNSSettingService method instead.

func NewDNSSettingService 

func NewDNSSettingService(opts ...option.RequestOption) (r *DNSSettingService)

NewDNSSettingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DNSSettingService) Edit 

func (r *DNSSettingService) Edit(ctx context.Context, params DNSSettingEditParams, opts ...option.RequestOption) (res *DNSSetting, err error)

Update DNS settings for a zone

func (*DNSSettingService) Get 

func (r *DNSSettingService) Get(ctx context.Context, query DNSSettingGetParams, opts ...option.RequestOption) (res *DNSSetting, err error)

Show DNS settings for a zone

type DevelopmentMode 

type DevelopmentMode struct {
	// ID of the zone setting.
	ID DevelopmentModeID `json:"id,required"`
	// Current value of the zone setting.
	Value DevelopmentModeValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable DevelopmentModeEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,nullable" format:"date-time"`
	// Value of the zone setting. Notes: The interval (in seconds) from when
	// development mode expires (positive integer) or last expired (negative integer)
	// for the domain. If development mode has never been enabled, this value is false.
	TimeRemaining float64             `json:"time_remaining"`
	JSON          developmentModeJSON `json:"-"`
}

Development Mode temporarily allows you to enter development mode for your websites if you need to make changes to your site. This will bypass Cloudflare's accelerated cache and slow down your site, but is useful if you are making changes to cacheable content (like images, css, or JavaScript) and would like to see those changes right away. Once entered, development mode will last for 3 hours and then automatically toggle off.

func (*DevelopmentMode) UnmarshalJSON 

func (r *DevelopmentMode) UnmarshalJSON(data []byte) (err error)

type DevelopmentModeEditable 

type DevelopmentModeEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	DevelopmentModeEditableTrue  DevelopmentModeEditable = true
	DevelopmentModeEditableFalse DevelopmentModeEditable = false
)

func (DevelopmentModeEditable) IsKnown 

func (r DevelopmentModeEditable) IsKnown() bool

type DevelopmentModeID 

type DevelopmentModeID string

ID of the zone setting. 

const (
	DevelopmentModeIDDevelopmentMode DevelopmentModeID = "development_mode"
)

func (DevelopmentModeID) IsKnown 

func (r DevelopmentModeID) IsKnown() bool

type DevelopmentModeValue 

type DevelopmentModeValue string

Current value of the zone setting. 

const (
	DevelopmentModeValueOn  DevelopmentModeValue = "on"
	DevelopmentModeValueOff DevelopmentModeValue = "off"
)

func (DevelopmentModeValue) IsKnown 

func (r DevelopmentModeValue) IsKnown() bool

type EarlyHints 

type EarlyHints struct {
	// ID of the zone setting.
	ID EarlyHintsID `json:"id,required"`
	// Current value of the zone setting.
	Value EarlyHintsValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable EarlyHintsEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time      `json:"modified_on,nullable" format:"date-time"`
	JSON       earlyHintsJSON `json:"-"`
}

When enabled, Cloudflare will attempt to speed up overall page loads by serving `103` responses with `Link` headers from the final response. Refer to [Early Hints](https://developers.cloudflare.com/cache/about/early-hints) for more information.

func (*EarlyHints) UnmarshalJSON 

func (r *EarlyHints) UnmarshalJSON(data []byte) (err error)

type EarlyHintsEditable 

type EarlyHintsEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	EarlyHintsEditableTrue  EarlyHintsEditable = true
	EarlyHintsEditableFalse EarlyHintsEditable = false
)

func (EarlyHintsEditable) IsKnown 

func (r EarlyHintsEditable) IsKnown() bool

type EarlyHintsID 

type EarlyHintsID string

ID of the zone setting. 

const (
	EarlyHintsIDEarlyHints EarlyHintsID = "early_hints"
)

func (EarlyHintsID) IsKnown 

func (r EarlyHintsID) IsKnown() bool

type EarlyHintsValue 

type EarlyHintsValue string

Current value of the zone setting. 

const (
	EarlyHintsValueOn  EarlyHintsValue = "on"
	EarlyHintsValueOff EarlyHintsValue = "off"
)

func (EarlyHintsValue) IsKnown 

func (r EarlyHintsValue) IsKnown() bool

type EmailObfuscation 

type EmailObfuscation struct {
	// ID of the zone setting.
	ID EmailObfuscationID `json:"id,required"`
	// Current value of the zone setting.
	Value EmailObfuscationValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable EmailObfuscationEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time            `json:"modified_on,nullable" format:"date-time"`
	JSON       emailObfuscationJSON `json:"-"`
}

Encrypt email adresses on your web page from bots, while keeping them visible to humans. (https://support.cloudflare.com/hc/en-us/articles/200170016).

func (*EmailObfuscation) UnmarshalJSON 

func (r *EmailObfuscation) UnmarshalJSON(data []byte) (err error)

type EmailObfuscationEditable 

type EmailObfuscationEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	EmailObfuscationEditableTrue  EmailObfuscationEditable = true
	EmailObfuscationEditableFalse EmailObfuscationEditable = false
)

func (EmailObfuscationEditable) IsKnown 

func (r EmailObfuscationEditable) IsKnown() bool

type EmailObfuscationID 

type EmailObfuscationID string

ID of the zone setting. 

const (
	EmailObfuscationIDEmailObfuscation EmailObfuscationID = "email_obfuscation"
)

func (EmailObfuscationID) IsKnown 

func (r EmailObfuscationID) IsKnown() bool

type EmailObfuscationValue 

type EmailObfuscationValue string

Current value of the zone setting. 

const (
	EmailObfuscationValueOn  EmailObfuscationValue = "on"
	EmailObfuscationValueOff EmailObfuscationValue = "off"
)

func (EmailObfuscationValue) IsKnown 

func (r EmailObfuscationValue) IsKnown() bool

type Error 

type Error = apierror.Error

type ErrorData 

type ErrorData = shared.ErrorData

This is an alias to an internal type.

type FontSettings 

type FontSettings struct {
	// ID of the zone setting.
	ID FontSettingsID `json:"id,required"`
	// Current value of the zone setting.
	Value FontSettingsValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable FontSettingsEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time        `json:"modified_on,nullable" format:"date-time"`
	JSON       fontSettingsJSON `json:"-"`
}

Enhance your website's font delivery with Cloudflare Fonts. Deliver Google Hosted fonts from your own domain, boost performance, and enhance user privacy. Refer to the Cloudflare Fonts documentation for more information.

func (*FontSettings) UnmarshalJSON 

func (r *FontSettings) UnmarshalJSON(data []byte) (err error)

type FontSettingsEditable 

type FontSettingsEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	FontSettingsEditableTrue  FontSettingsEditable = true
	FontSettingsEditableFalse FontSettingsEditable = false
)

func (FontSettingsEditable) IsKnown 

func (r FontSettingsEditable) IsKnown() bool

type FontSettingsID 

type FontSettingsID string

ID of the zone setting. 

const (
	FontSettingsIDFonts FontSettingsID = "fonts"
)

func (FontSettingsID) IsKnown 

func (r FontSettingsID) IsKnown() bool

type FontSettingsValue 

type FontSettingsValue string

Current value of the zone setting. 

const (
	FontSettingsValueOn  FontSettingsValue = "on"
	FontSettingsValueOff FontSettingsValue = "off"
)

func (FontSettingsValue) IsKnown 

func (r FontSettingsValue) IsKnown() bool

type H2Prioritization 

type H2Prioritization struct {
	// ID of the zone setting.
	ID H2PrioritizationID `json:"id,required"`
	// Current value of the zone setting.
	Value H2PrioritizationValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable H2PrioritizationEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time            `json:"modified_on,nullable" format:"date-time"`
	JSON       h2PrioritizationJSON `json:"-"`
}

HTTP/2 Edge Prioritization optimises the delivery of resources served through HTTP/2 to improve page load performance. It also supports fine control of content delivery when used in conjunction with Workers.

func (*H2Prioritization) UnmarshalJSON 

func (r *H2Prioritization) UnmarshalJSON(data []byte) (err error)

type H2PrioritizationEditable 

type H2PrioritizationEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	H2PrioritizationEditableTrue  H2PrioritizationEditable = true
	H2PrioritizationEditableFalse H2PrioritizationEditable = false
)

func (H2PrioritizationEditable) IsKnown 

func (r H2PrioritizationEditable) IsKnown() bool

type H2PrioritizationID 

type H2PrioritizationID string

ID of the zone setting. 

const (
	H2PrioritizationIDH2Prioritization H2PrioritizationID = "h2_prioritization"
)

func (H2PrioritizationID) IsKnown 

func (r H2PrioritizationID) IsKnown() bool

type H2PrioritizationParam 

type H2PrioritizationParam struct {
	// ID of the zone setting.
	ID param.Field[H2PrioritizationID] `json:"id,required"`
	// Current value of the zone setting.
	Value param.Field[H2PrioritizationValue] `json:"value,required"`
}

HTTP/2 Edge Prioritization optimises the delivery of resources served through HTTP/2 to improve page load performance. It also supports fine control of content delivery when used in conjunction with Workers.

func (H2PrioritizationParam) MarshalJSON 

func (r H2PrioritizationParam) MarshalJSON() (data []byte, err error)

type H2PrioritizationValue 

type H2PrioritizationValue string

Current value of the zone setting. 

const (
	H2PrioritizationValueOn     H2PrioritizationValue = "on"
	H2PrioritizationValueOff    H2PrioritizationValue = "off"
	H2PrioritizationValueCustom H2PrioritizationValue = "custom"
)

func (H2PrioritizationValue) IsKnown 

func (r H2PrioritizationValue) IsKnown() bool

type HTTP2 

type HTTP2 struct {
	// ID of the zone setting.
	ID HTTP2ID `json:"id,required"`
	// Current value of the zone setting.
	Value HTTP2Value `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable HTTP2Editable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,nullable" format:"date-time"`
	JSON       http2JSON `json:"-"`
}

HTTP2 enabled for this zone.

func (*HTTP2) UnmarshalJSON 

func (r *HTTP2) UnmarshalJSON(data []byte) (err error)

type HTTP2Editable 

type HTTP2Editable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	HTTP2EditableTrue  HTTP2Editable = true
	HTTP2EditableFalse HTTP2Editable = false
)

func (HTTP2Editable) IsKnown 

func (r HTTP2Editable) IsKnown() bool

type HTTP2ID 

type HTTP2ID string

ID of the zone setting. 

const (
	HTTP2IDHTTP2 HTTP2ID = "http2"
)

func (HTTP2ID) IsKnown 

func (r HTTP2ID) IsKnown() bool

type HTTP2Value 

type HTTP2Value string

Current value of the zone setting. 

const (
	HTTP2ValueOn  HTTP2Value = "on"
	HTTP2ValueOff HTTP2Value = "off"
)

func (HTTP2Value) IsKnown 

func (r HTTP2Value) IsKnown() bool

type HTTP3 

type HTTP3 struct {
	// ID of the zone setting.
	ID HTTP3ID `json:"id,required"`
	// Current value of the zone setting.
	Value HTTP3Value `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable HTTP3Editable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,nullable" format:"date-time"`
	JSON       http3JSON `json:"-"`
}

HTTP3 enabled for this zone.

func (*HTTP3) UnmarshalJSON 

func (r *HTTP3) UnmarshalJSON(data []byte) (err error)

type HTTP3Editable 

type HTTP3Editable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	HTTP3EditableTrue  HTTP3Editable = true
	HTTP3EditableFalse HTTP3Editable = false
)

func (HTTP3Editable) IsKnown 

func (r HTTP3Editable) IsKnown() bool

type HTTP3ID 

type HTTP3ID string

ID of the zone setting. 

const (
	HTTP3IDHTTP3 HTTP3ID = "http3"
)

func (HTTP3ID) IsKnown 

func (r HTTP3ID) IsKnown() bool

type HTTP3Value 

type HTTP3Value string

Current value of the zone setting. 

const (
	HTTP3ValueOn  HTTP3Value = "on"
	HTTP3ValueOff HTTP3Value = "off"
)

func (HTTP3Value) IsKnown 

func (r HTTP3Value) IsKnown() bool

type HoldDeleteParams 

type HoldDeleteParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// If `hold_after` is provided, the hold will be temporarily disabled, then
	// automatically re-enabled by the system at the time specified in this
	// RFC3339-formatted timestamp. Otherwise, the hold will be disabled indefinitely.
	HoldAfter param.Field[string] `query:"hold_after"`
}

func (HoldDeleteParams) URLQuery 

func (r HoldDeleteParams) URLQuery() (v url.Values)

URLQuery serializes HoldDeleteParams's query parameters as `url.Values`.

type HoldDeleteResponseEnvelope 

type HoldDeleteResponseEnvelope struct {
	Result ZoneHold                       `json:"result"`
	JSON   holdDeleteResponseEnvelopeJSON `json:"-"`
}

func (*HoldDeleteResponseEnvelope) UnmarshalJSON 

func (r *HoldDeleteResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type HoldGetParams 

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

type HoldGetResponseEnvelope 

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

func (*HoldGetResponseEnvelope) UnmarshalJSON 

func (r *HoldGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type HoldGetResponseEnvelopeSuccess 

type HoldGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HoldGetResponseEnvelopeSuccessTrue HoldGetResponseEnvelopeSuccess = true
)

func (HoldGetResponseEnvelopeSuccess) IsKnown 

func (r HoldGetResponseEnvelopeSuccess) IsKnown() bool

type HoldNewParams 

type HoldNewParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// If provided, the zone hold will extend to block any subdomain of the given zone,
	// as well as SSL4SaaS Custom Hostnames. For example, a zone hold on a zone with
	// the hostname 'example.com' and include_subdomains=true will block 'example.com',
	// 'staging.example.com', 'api.staging.example.com', etc.
	IncludeSubdomains param.Field[bool] `query:"include_subdomains"`
}

func (HoldNewParams) URLQuery 

func (r HoldNewParams) URLQuery() (v url.Values)

URLQuery serializes HoldNewParams's query parameters as `url.Values`.

type HoldNewResponseEnvelope 

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

func (*HoldNewResponseEnvelope) UnmarshalJSON 

func (r *HoldNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type HoldNewResponseEnvelopeSuccess 

type HoldNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HoldNewResponseEnvelopeSuccessTrue HoldNewResponseEnvelopeSuccess = true
)

func (HoldNewResponseEnvelopeSuccess) IsKnown 

func (r HoldNewResponseEnvelopeSuccess) IsKnown() bool

type HoldService 

type HoldService struct {
	Options []option.RequestOption
}

HoldService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewHoldService method instead.

func NewHoldService 

func NewHoldService(opts ...option.RequestOption) (r *HoldService)

NewHoldService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*HoldService) Delete 

func (r *HoldService) Delete(ctx context.Context, params HoldDeleteParams, opts ...option.RequestOption) (res *ZoneHold, err error)

Stop enforcement of a zone hold on the zone, permanently or temporarily, allowing the creation and activation of zones with this zone's hostname.

func (*HoldService) Get 

func (r *HoldService) Get(ctx context.Context, query HoldGetParams, opts ...option.RequestOption) (res *ZoneHold, err error)

Retrieve whether the zone is subject to a zone hold, and metadata about the hold.

func (*HoldService) New 

func (r *HoldService) New(ctx context.Context, params HoldNewParams, opts ...option.RequestOption) (res *ZoneHold, err error)

Enforce a zone hold on the zone, blocking the creation and activation of zones with this zone's hostname.

type HotlinkProtection 

type HotlinkProtection struct {
	// ID of the zone setting.
	ID HotlinkProtectionID `json:"id,required"`
	// Current value of the zone setting.
	Value HotlinkProtectionValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable HotlinkProtectionEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time             `json:"modified_on,nullable" format:"date-time"`
	JSON       hotlinkProtectionJSON `json:"-"`
}

When enabled, the Hotlink Protection option ensures that other sites cannot suck up your bandwidth by building pages that use images hosted on your site. Anytime a request for an image on your site hits Cloudflare, we check to ensure that it's not another site requesting them. People will still be able to download and view images from your page, but other sites won't be able to steal them for use on their own pages. (https://support.cloudflare.com/hc/en-us/articles/200170026).

func (*HotlinkProtection) UnmarshalJSON 

func (r *HotlinkProtection) UnmarshalJSON(data []byte) (err error)

type HotlinkProtectionEditable 

type HotlinkProtectionEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	HotlinkProtectionEditableTrue  HotlinkProtectionEditable = true
	HotlinkProtectionEditableFalse HotlinkProtectionEditable = false
)

func (HotlinkProtectionEditable) IsKnown 

func (r HotlinkProtectionEditable) IsKnown() bool

type HotlinkProtectionID 

type HotlinkProtectionID string

ID of the zone setting. 

const (
	HotlinkProtectionIDHotlinkProtection HotlinkProtectionID = "hotlink_protection"
)

func (HotlinkProtectionID) IsKnown 

func (r HotlinkProtectionID) IsKnown() bool

type HotlinkProtectionValue 

type HotlinkProtectionValue string

Current value of the zone setting. 

const (
	HotlinkProtectionValueOn  HotlinkProtectionValue = "on"
	HotlinkProtectionValueOff HotlinkProtectionValue = "off"
)

func (HotlinkProtectionValue) IsKnown 

func (r HotlinkProtectionValue) IsKnown() bool

type IPGeolocation 

type IPGeolocation struct {
	// ID of the zone setting.
	ID IPGeolocationID `json:"id,required"`
	// Current value of the zone setting.
	Value IPGeolocationValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable IPGeolocationEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time         `json:"modified_on,nullable" format:"date-time"`
	JSON       ipGeolocationJSON `json:"-"`
}

Enable IP Geolocation to have Cloudflare geolocate visitors to your website and pass the country code to you. (https://support.cloudflare.com/hc/en-us/articles/200168236).

func (*IPGeolocation) UnmarshalJSON 

func (r *IPGeolocation) UnmarshalJSON(data []byte) (err error)

type IPGeolocationEditable 

type IPGeolocationEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	IPGeolocationEditableTrue  IPGeolocationEditable = true
	IPGeolocationEditableFalse IPGeolocationEditable = false
)

func (IPGeolocationEditable) IsKnown 

func (r IPGeolocationEditable) IsKnown() bool

type IPGeolocationID 

type IPGeolocationID string

ID of the zone setting. 

const (
	IPGeolocationIDIPGeolocation IPGeolocationID = "ip_geolocation"
)

func (IPGeolocationID) IsKnown 

func (r IPGeolocationID) IsKnown() bool

type IPGeolocationValue 

type IPGeolocationValue string

Current value of the zone setting. 

const (
	IPGeolocationValueOn  IPGeolocationValue = "on"
	IPGeolocationValueOff IPGeolocationValue = "off"
)

func (IPGeolocationValue) IsKnown 

func (r IPGeolocationValue) IsKnown() bool

type IPV6 

type IPV6 struct {
	// ID of the zone setting.
	ID IPV6ID `json:"id,required"`
	// Current value of the zone setting.
	Value IPV6Value `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable IPV6Editable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,nullable" format:"date-time"`
	JSON       ipv6JSON  `json:"-"`
}

Enable IPv6 on all subdomains that are Cloudflare enabled. (https://support.cloudflare.com/hc/en-us/articles/200168586).

func (*IPV6) UnmarshalJSON 

func (r *IPV6) UnmarshalJSON(data []byte) (err error)

type IPV6Editable 

type IPV6Editable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	IPV6EditableTrue  IPV6Editable = true
	IPV6EditableFalse IPV6Editable = false
)

func (IPV6Editable) IsKnown 

func (r IPV6Editable) IsKnown() bool

type IPV6ID 

type IPV6ID string

ID of the zone setting. 

const (
	IPV6IDIPV6 IPV6ID = "ipv6"
)

func (IPV6ID) IsKnown 

func (r IPV6ID) IsKnown() bool

type IPV6Value 

type IPV6Value string

Current value of the zone setting. 

const (
	IPV6ValueOff IPV6Value = "off"
	IPV6ValueOn  IPV6Value = "on"
)

func (IPV6Value) IsKnown 

func (r IPV6Value) IsKnown() bool

type ImageResizing 

type ImageResizing struct {
	// ID of the zone setting.
	ID ImageResizingID `json:"id,required"`
	// Current value of the zone setting.
	Value ImageResizingValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable ImageResizingEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time         `json:"modified_on,nullable" format:"date-time"`
	JSON       imageResizingJSON `json:"-"`
}

Image Resizing provides on-demand resizing, conversion and optimisation for images served through Cloudflare's network. Refer to the [Image Resizing documentation](https://developers.cloudflare.com/images/) for more information.

func (*ImageResizing) UnmarshalJSON 

func (r *ImageResizing) UnmarshalJSON(data []byte) (err error)

type ImageResizingEditable 

type ImageResizingEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	ImageResizingEditableTrue  ImageResizingEditable = true
	ImageResizingEditableFalse ImageResizingEditable = false
)

func (ImageResizingEditable) IsKnown 

func (r ImageResizingEditable) IsKnown() bool

type ImageResizingID 

type ImageResizingID string

ID of the zone setting. 

const (
	ImageResizingIDImageResizing ImageResizingID = "image_resizing"
)

func (ImageResizingID) IsKnown 

func (r ImageResizingID) IsKnown() bool

type ImageResizingParam 

type ImageResizingParam struct {
	// ID of the zone setting.
	ID param.Field[ImageResizingID] `json:"id,required"`
	// Current value of the zone setting.
	Value param.Field[ImageResizingValue] `json:"value,required"`
}

Image Resizing provides on-demand resizing, conversion and optimisation for images served through Cloudflare's network. Refer to the [Image Resizing documentation](https://developers.cloudflare.com/images/) for more information.

func (ImageResizingParam) MarshalJSON 

func (r ImageResizingParam) MarshalJSON() (data []byte, err error)

type ImageResizingValue 

type ImageResizingValue string

Current value of the zone setting. 

const (
	ImageResizingValueOn   ImageResizingValue = "on"
	ImageResizingValueOff  ImageResizingValue = "off"
	ImageResizingValueOpen ImageResizingValue = "open"
)

func (ImageResizingValue) IsKnown 

func (r ImageResizingValue) IsKnown() bool

type Member added in v2.1.0 

type Member = shared.Member

This is an alias to an internal type.

type MemberParam added in v2.1.0 

type MemberParam = shared.MemberParam

This is an alias to an internal type.

type MemberRole added in v2.1.0 

type MemberRole = shared.MemberRole

This is an alias to an internal type.

type MemberRoleParam added in v2.1.0 

type MemberRoleParam = shared.MemberRoleParam

This is an alias to an internal type.

type MemberRolesPermissions added in v2.1.0 

type MemberRolesPermissions = shared.MemberRolesPermissions

This is an alias to an internal type.

type MemberRolesPermissionsParam added in v2.1.0 

type MemberRolesPermissionsParam = shared.MemberRolesPermissionsParam

This is an alias to an internal type.

type MemberUser added in v2.1.0 

type MemberUser = shared.MemberUser

This is an alias to an internal type.

type MemberUserParam added in v2.1.0 

type MemberUserParam = shared.MemberUserParam

This is an alias to an internal type.

type MinTLSVersion 

type MinTLSVersion struct {
	// ID of the zone setting.
	ID MinTLSVersionID `json:"id,required"`
	// Current value of the zone setting.
	Value MinTLSVersionValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable MinTLSVersionEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time         `json:"modified_on,nullable" format:"date-time"`
	JSON       minTLSVersionJSON `json:"-"`
}

Only accepts HTTPS requests that use at least the TLS protocol version specified. For example, if TLS 1.1 is selected, TLS 1.0 connections will be rejected, while 1.1, 1.2, and 1.3 (if enabled) will be permitted.

func (*MinTLSVersion) UnmarshalJSON 

func (r *MinTLSVersion) UnmarshalJSON(data []byte) (err error)

type MinTLSVersionEditable 

type MinTLSVersionEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	MinTLSVersionEditableTrue  MinTLSVersionEditable = true
	MinTLSVersionEditableFalse MinTLSVersionEditable = false
)

func (MinTLSVersionEditable) IsKnown 

func (r MinTLSVersionEditable) IsKnown() bool

type MinTLSVersionID 

type MinTLSVersionID string

ID of the zone setting. 

const (
	MinTLSVersionIDMinTLSVersion MinTLSVersionID = "min_tls_version"
)

func (MinTLSVersionID) IsKnown 

func (r MinTLSVersionID) IsKnown() bool

type MinTLSVersionValue 

type MinTLSVersionValue string

Current value of the zone setting. 

const (
	MinTLSVersionValue1_0 MinTLSVersionValue = "1.0"
	MinTLSVersionValue1_1 MinTLSVersionValue = "1.1"
	MinTLSVersionValue1_2 MinTLSVersionValue = "1.2"
	MinTLSVersionValue1_3 MinTLSVersionValue = "1.3"
)

func (MinTLSVersionValue) IsKnown 

func (r MinTLSVersionValue) IsKnown() bool

type Minify 

type Minify struct {
	// Zone setting identifier.
	ID MinifyID `json:"id,required"`
	// Current value of the zone setting.
	Value MinifyValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable MinifyEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time  `json:"modified_on,nullable" format:"date-time"`
	JSON       minifyJSON `json:"-"`
}

Automatically minify certain assets for your website. Refer to [Using Cloudflare Auto Minify](https://support.cloudflare.com/hc/en-us/articles/200168196) for more information.

func (*Minify) UnmarshalJSON 

func (r *Minify) UnmarshalJSON(data []byte) (err error)

type MinifyEditable 

type MinifyEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	MinifyEditableTrue  MinifyEditable = true
	MinifyEditableFalse MinifyEditable = false
)

func (MinifyEditable) IsKnown 

func (r MinifyEditable) IsKnown() bool

type MinifyID 

type MinifyID string

Zone setting identifier. 

const (
	MinifyIDMinify MinifyID = "minify"
)

func (MinifyID) IsKnown 

func (r MinifyID) IsKnown() bool

type MinifyValue 

type MinifyValue struct {
	// Automatically minify all CSS files for your website.
	Css MinifyValueCss `json:"css"`
	// Automatically minify all HTML files for your website.
	HTML MinifyValueHTML `json:"html"`
	// Automatically minify all JavaScript files for your website.
	JS   MinifyValueJS   `json:"js"`
	JSON minifyValueJSON `json:"-"`
}

Current value of the zone setting.

func (*MinifyValue) UnmarshalJSON 

func (r *MinifyValue) UnmarshalJSON(data []byte) (err error)

type MinifyValueCss 

type MinifyValueCss string

Automatically minify all CSS files for your website. 

const (
	MinifyValueCssOn  MinifyValueCss = "on"
	MinifyValueCssOff MinifyValueCss = "off"
)

func (MinifyValueCss) IsKnown 

func (r MinifyValueCss) IsKnown() bool

type MinifyValueHTML 

type MinifyValueHTML string

Automatically minify all HTML files for your website. 

const (
	MinifyValueHTMLOn  MinifyValueHTML = "on"
	MinifyValueHTMLOff MinifyValueHTML = "off"
)

func (MinifyValueHTML) IsKnown 

func (r MinifyValueHTML) IsKnown() bool

type MinifyValueJS 

type MinifyValueJS string

Automatically minify all JavaScript files for your website. 

const (
	MinifyValueJSOn  MinifyValueJS = "on"
	MinifyValueJSOff MinifyValueJS = "off"
)

func (MinifyValueJS) IsKnown 

func (r MinifyValueJS) IsKnown() bool

type Mirage 

type Mirage struct {
	// ID of the zone setting.
	ID MirageID `json:"id,required"`
	// Current value of the zone setting.
	Value MirageValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable MirageEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time  `json:"modified_on,nullable" format:"date-time"`
	JSON       mirageJSON `json:"-"`
}

Automatically optimize image loading for website visitors on mobile devices. Refer to [our blog post](http://blog.cloudflare.com/mirage2-solving-mobile-speed) for more information.

func (*Mirage) UnmarshalJSON 

func (r *Mirage) UnmarshalJSON(data []byte) (err error)

type MirageEditable 

type MirageEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	MirageEditableTrue  MirageEditable = true
	MirageEditableFalse MirageEditable = false
)

func (MirageEditable) IsKnown 

func (r MirageEditable) IsKnown() bool

type MirageID 

type MirageID string

ID of the zone setting. 

const (
	MirageIDMirage MirageID = "mirage"
)

func (MirageID) IsKnown 

func (r MirageID) IsKnown() bool

type MirageValue 

type MirageValue string

Current value of the zone setting. 

const (
	MirageValueOn  MirageValue = "on"
	MirageValueOff MirageValue = "off"
)

func (MirageValue) IsKnown 

func (r MirageValue) IsKnown() bool

type MobileRedirect 

type MobileRedirect struct {
	// Identifier of the zone setting.
	ID MobileRedirectID `json:"id,required"`
	// Current value of the zone setting.
	Value MobileRedirectValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable MobileRedirectEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time          `json:"modified_on,nullable" format:"date-time"`
	JSON       mobileRedirectJSON `json:"-"`
}

Automatically redirect visitors on mobile devices to a mobile-optimized subdomain. Refer to [Understanding Cloudflare Mobile Redirect](https://support.cloudflare.com/hc/articles/200168336) for more information.

func (*MobileRedirect) UnmarshalJSON 

func (r *MobileRedirect) UnmarshalJSON(data []byte) (err error)

type MobileRedirectEditable 

type MobileRedirectEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	MobileRedirectEditableTrue  MobileRedirectEditable = true
	MobileRedirectEditableFalse MobileRedirectEditable = false
)

func (MobileRedirectEditable) IsKnown 

func (r MobileRedirectEditable) IsKnown() bool

type MobileRedirectID 

type MobileRedirectID string

Identifier of the zone setting. 

const (
	MobileRedirectIDMobileRedirect MobileRedirectID = "mobile_redirect"
)

func (MobileRedirectID) IsKnown 

func (r MobileRedirectID) IsKnown() bool

type MobileRedirectValue 

type MobileRedirectValue struct {
	// Which subdomain prefix you wish to redirect visitors on mobile devices to
	// (subdomain must already exist).
	MobileSubdomain string `json:"mobile_subdomain,nullable"`
	// Whether or not mobile redirect is enabled.
	Status MobileRedirectValueStatus `json:"status"`
	// Whether to drop the current page path and redirect to the mobile subdomain URL
	// root, or keep the path and redirect to the same page on the mobile subdomain.
	StripURI bool                    `json:"strip_uri"`
	JSON     mobileRedirectValueJSON `json:"-"`
}

Current value of the zone setting.

func (*MobileRedirectValue) UnmarshalJSON 

func (r *MobileRedirectValue) UnmarshalJSON(data []byte) (err error)

type MobileRedirectValueStatus 

type MobileRedirectValueStatus string

Whether or not mobile redirect is enabled. 

const (
	MobileRedirectValueStatusOn  MobileRedirectValueStatus = "on"
	MobileRedirectValueStatusOff MobileRedirectValueStatus = "off"
)

func (MobileRedirectValueStatus) IsKnown 

func (r MobileRedirectValueStatus) IsKnown() bool

type NEL 

type NEL struct {
	// Zone setting identifier.
	ID NELID `json:"id,required"`
	// Current value of the zone setting.
	Value NELValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable NELEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,nullable" format:"date-time"`
	JSON       nelJSON   `json:"-"`
}

Enable Network Error Logging reporting on your zone. (Beta)

func (*NEL) UnmarshalJSON 

func (r *NEL) UnmarshalJSON(data []byte) (err error)

type NELEditable 

type NELEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	NELEditableTrue  NELEditable = true
	NELEditableFalse NELEditable = false
)

func (NELEditable) IsKnown 

func (r NELEditable) IsKnown() bool

type NELID 

type NELID string

Zone setting identifier. 

const (
	NELIDNEL NELID = "nel"
)

func (NELID) IsKnown 

func (r NELID) IsKnown() bool

type NELParam 

type NELParam struct {
	// Zone setting identifier.
	ID param.Field[NELID] `json:"id,required"`
	// Current value of the zone setting.
	Value param.Field[NELValueParam] `json:"value,required"`
}

Enable Network Error Logging reporting on your zone. (Beta)

func (NELParam) MarshalJSON 

func (r NELParam) MarshalJSON() (data []byte, err error)

type NELValue 

type NELValue struct {
	Enabled bool         `json:"enabled"`
	JSON    nelValueJSON `json:"-"`
}

Current value of the zone setting.

func (*NELValue) UnmarshalJSON 

func (r *NELValue) UnmarshalJSON(data []byte) (err error)

type NELValueParam 

type NELValueParam struct {
	Enabled param.Field[bool] `json:"enabled"`
}

Current value of the zone setting.

func (NELValueParam) MarshalJSON 

func (r NELValueParam) MarshalJSON() (data []byte, err error)

type Nameserver 

type Nameserver struct {
	// Nameserver type
	Type NameserverType `json:"type,required"`
	JSON nameserverJSON `json:"-"`
}

Settings determining the nameservers through which the zone should be available.

func (*Nameserver) UnmarshalJSON 

func (r *Nameserver) UnmarshalJSON(data []byte) (err error)

type NameserverParam 

type NameserverParam struct {
	// Nameserver type
	Type param.Field[NameserverType] `json:"type,required"`
}

Settings determining the nameservers through which the zone should be available.

func (NameserverParam) MarshalJSON 

func (r NameserverParam) MarshalJSON() (data []byte, err error)

type NameserverType 

type NameserverType string

Nameserver type 

const (
	NameserverTypeCloudflareStandard NameserverType = "cloudflare.standard"
)

func (NameserverType) IsKnown 

func (r NameserverType) IsKnown() bool

type OpportunisticEncryption 

type OpportunisticEncryption struct {
	// ID of the zone setting.
	ID OpportunisticEncryptionID `json:"id,required"`
	// Current value of the zone setting.
	Value OpportunisticEncryptionValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable OpportunisticEncryptionEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time                   `json:"modified_on,nullable" format:"date-time"`
	JSON       opportunisticEncryptionJSON `json:"-"`
}

Enables the Opportunistic Encryption feature for a zone.

func (*OpportunisticEncryption) UnmarshalJSON 

func (r *OpportunisticEncryption) UnmarshalJSON(data []byte) (err error)

type OpportunisticEncryptionEditable 

type OpportunisticEncryptionEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	OpportunisticEncryptionEditableTrue  OpportunisticEncryptionEditable = true
	OpportunisticEncryptionEditableFalse OpportunisticEncryptionEditable = false
)

func (OpportunisticEncryptionEditable) IsKnown 

func (r OpportunisticEncryptionEditable) IsKnown() bool

type OpportunisticEncryptionID 

type OpportunisticEncryptionID string

ID of the zone setting. 

const (
	OpportunisticEncryptionIDOpportunisticEncryption OpportunisticEncryptionID = "opportunistic_encryption"
)

func (OpportunisticEncryptionID) IsKnown 

func (r OpportunisticEncryptionID) IsKnown() bool

type OpportunisticEncryptionValue 

type OpportunisticEncryptionValue string

Current value of the zone setting. 

const (
	OpportunisticEncryptionValueOn  OpportunisticEncryptionValue = "on"
	OpportunisticEncryptionValueOff OpportunisticEncryptionValue = "off"
)

func (OpportunisticEncryptionValue) IsKnown 

func (r OpportunisticEncryptionValue) IsKnown() bool

type OpportunisticOnion 

type OpportunisticOnion struct {
	// ID of the zone setting.
	ID OpportunisticOnionID `json:"id,required"`
	// Current value of the zone setting.
	Value OpportunisticOnionValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable OpportunisticOnionEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time              `json:"modified_on,nullable" format:"date-time"`
	JSON       opportunisticOnionJSON `json:"-"`
}

Add an Alt-Svc header to all legitimate requests from Tor, allowing the connection to use our onion services instead of exit nodes.

func (*OpportunisticOnion) UnmarshalJSON 

func (r *OpportunisticOnion) UnmarshalJSON(data []byte) (err error)

type OpportunisticOnionEditable 

type OpportunisticOnionEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	OpportunisticOnionEditableTrue  OpportunisticOnionEditable = true
	OpportunisticOnionEditableFalse OpportunisticOnionEditable = false
)

func (OpportunisticOnionEditable) IsKnown 

func (r OpportunisticOnionEditable) IsKnown() bool

type OpportunisticOnionID 

type OpportunisticOnionID string

ID of the zone setting. 

const (
	OpportunisticOnionIDOpportunisticOnion OpportunisticOnionID = "opportunistic_onion"
)

func (OpportunisticOnionID) IsKnown 

func (r OpportunisticOnionID) IsKnown() bool

type OpportunisticOnionValue 

type OpportunisticOnionValue string

Current value of the zone setting. 

const (
	OpportunisticOnionValueOn  OpportunisticOnionValue = "on"
	OpportunisticOnionValueOff OpportunisticOnionValue = "off"
)

func (OpportunisticOnionValue) IsKnown 

func (r OpportunisticOnionValue) IsKnown() bool

type OrangeToOrange 

type OrangeToOrange struct {
	// ID of the zone setting.
	ID OrangeToOrangeID `json:"id,required"`
	// Current value of the zone setting.
	Value OrangeToOrangeValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable OrangeToOrangeEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time          `json:"modified_on,nullable" format:"date-time"`
	JSON       orangeToOrangeJSON `json:"-"`
}

Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also on Cloudflare.

func (*OrangeToOrange) UnmarshalJSON 

func (r *OrangeToOrange) UnmarshalJSON(data []byte) (err error)

type OrangeToOrangeEditable 

type OrangeToOrangeEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	OrangeToOrangeEditableTrue  OrangeToOrangeEditable = true
	OrangeToOrangeEditableFalse OrangeToOrangeEditable = false
)

func (OrangeToOrangeEditable) IsKnown 

func (r OrangeToOrangeEditable) IsKnown() bool

type OrangeToOrangeID 

type OrangeToOrangeID string

ID of the zone setting. 

const (
	OrangeToOrangeIDOrangeToOrange OrangeToOrangeID = "orange_to_orange"
)

func (OrangeToOrangeID) IsKnown 

func (r OrangeToOrangeID) IsKnown() bool

type OrangeToOrangeParam 

type OrangeToOrangeParam struct {
	// ID of the zone setting.
	ID param.Field[OrangeToOrangeID] `json:"id,required"`
	// Current value of the zone setting.
	Value param.Field[OrangeToOrangeValue] `json:"value,required"`
}

Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also on Cloudflare.

func (OrangeToOrangeParam) MarshalJSON 

func (r OrangeToOrangeParam) MarshalJSON() (data []byte, err error)

type OrangeToOrangeValue 

type OrangeToOrangeValue string

Current value of the zone setting. 

const (
	OrangeToOrangeValueOn  OrangeToOrangeValue = "on"
	OrangeToOrangeValueOff OrangeToOrangeValue = "off"
)

func (OrangeToOrangeValue) IsKnown 

func (r OrangeToOrangeValue) IsKnown() bool

type OriginErrorPagePassThru 

type OriginErrorPagePassThru struct {
	// ID of the zone setting.
	ID OriginErrorPagePassThruID `json:"id,required"`
	// Current value of the zone setting.
	Value OriginErrorPagePassThruValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable OriginErrorPagePassThruEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time                   `json:"modified_on,nullable" format:"date-time"`
	JSON       originErrorPagePassThruJSON `json:"-"`
}

Cloudflare will proxy customer error pages on any 502,504 errors on origin server instead of showing a default Cloudflare error page. This does not apply to 522 errors and is limited to Enterprise Zones.

func (*OriginErrorPagePassThru) UnmarshalJSON 

func (r *OriginErrorPagePassThru) UnmarshalJSON(data []byte) (err error)

type OriginErrorPagePassThruEditable 

type OriginErrorPagePassThruEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	OriginErrorPagePassThruEditableTrue  OriginErrorPagePassThruEditable = true
	OriginErrorPagePassThruEditableFalse OriginErrorPagePassThruEditable = false
)

func (OriginErrorPagePassThruEditable) IsKnown 

func (r OriginErrorPagePassThruEditable) IsKnown() bool

type OriginErrorPagePassThruID 

type OriginErrorPagePassThruID string

ID of the zone setting. 

const (
	OriginErrorPagePassThruIDOriginErrorPagePassThru OriginErrorPagePassThruID = "origin_error_page_pass_thru"
)

func (OriginErrorPagePassThruID) IsKnown 

func (r OriginErrorPagePassThruID) IsKnown() bool

type OriginErrorPagePassThruValue 

type OriginErrorPagePassThruValue string

Current value of the zone setting. 

const (
	OriginErrorPagePassThruValueOn  OriginErrorPagePassThruValue = "on"
	OriginErrorPagePassThruValueOff OriginErrorPagePassThruValue = "off"
)

func (OriginErrorPagePassThruValue) IsKnown 

func (r OriginErrorPagePassThruValue) IsKnown() bool

type OriginMaxHTTPVersion 

type OriginMaxHTTPVersion string

Value of the zone setting. 

const (
	OriginMaxHTTPVersionOriginMaxHTTPVersion OriginMaxHTTPVersion = "origin_max_http_version"
)

func (OriginMaxHTTPVersion) IsKnown 

func (r OriginMaxHTTPVersion) IsKnown() bool

type Permission 

type Permission = shared.Permission

This is an alias to an internal type.

type PermissionGrant 

type PermissionGrant = shared.PermissionGrant

This is an alias to an internal type.

type PermissionGrantParam 

type PermissionGrantParam = shared.PermissionGrantParam

This is an alias to an internal type.

type Polish 

type Polish struct {
	// ID of the zone setting.
	ID PolishID `json:"id,required"`
	// Current value of the zone setting.
	Value PolishValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable PolishEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time  `json:"modified_on,nullable" format:"date-time"`
	JSON       polishJSON `json:"-"`
}

Removes metadata and compresses your images for faster page load times. Basic (Lossless): Reduce the size of PNG, JPEG, and GIF files - no impact on visual quality. Basic + JPEG (Lossy): Further reduce the size of JPEG files for faster image loading. Larger JPEGs are converted to progressive images, loading a lower-resolution image first and ending in a higher-resolution version. Not recommended for hi-res photography sites.

func (*Polish) UnmarshalJSON 

func (r *Polish) UnmarshalJSON(data []byte) (err error)

type PolishEditable 

type PolishEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	PolishEditableTrue  PolishEditable = true
	PolishEditableFalse PolishEditable = false
)

func (PolishEditable) IsKnown 

func (r PolishEditable) IsKnown() bool

type PolishID 

type PolishID string

ID of the zone setting. 

const (
	PolishIDPolish PolishID = "polish"
)

func (PolishID) IsKnown 

func (r PolishID) IsKnown() bool

type PolishParam 

type PolishParam struct {
	// ID of the zone setting.
	ID param.Field[PolishID] `json:"id,required"`
	// Current value of the zone setting.
	Value param.Field[PolishValue] `json:"value,required"`
}

Removes metadata and compresses your images for faster page load times. Basic (Lossless): Reduce the size of PNG, JPEG, and GIF files - no impact on visual quality. Basic + JPEG (Lossy): Further reduce the size of JPEG files for faster image loading. Larger JPEGs are converted to progressive images, loading a lower-resolution image first and ending in a higher-resolution version. Not recommended for hi-res photography sites.

func (PolishParam) MarshalJSON 

func (r PolishParam) MarshalJSON() (data []byte, err error)

type PolishValue 

type PolishValue string

Current value of the zone setting. 

const (
	PolishValueOff      PolishValue = "off"
	PolishValueLossless PolishValue = "lossless"
	PolishValueLossy    PolishValue = "lossy"
)

func (PolishValue) IsKnown 

func (r PolishValue) IsKnown() bool

type PrefetchPreload 

type PrefetchPreload struct {
	// ID of the zone setting.
	ID PrefetchPreloadID `json:"id,required"`
	// Current value of the zone setting.
	Value PrefetchPreloadValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable PrefetchPreloadEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time           `json:"modified_on,nullable" format:"date-time"`
	JSON       prefetchPreloadJSON `json:"-"`
}

Cloudflare will prefetch any URLs that are included in the response headers. This is limited to Enterprise Zones.

func (*PrefetchPreload) UnmarshalJSON 

func (r *PrefetchPreload) UnmarshalJSON(data []byte) (err error)

type PrefetchPreloadEditable 

type PrefetchPreloadEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	PrefetchPreloadEditableTrue  PrefetchPreloadEditable = true
	PrefetchPreloadEditableFalse PrefetchPreloadEditable = false
)

func (PrefetchPreloadEditable) IsKnown 

func (r PrefetchPreloadEditable) IsKnown() bool

type PrefetchPreloadID 

type PrefetchPreloadID string

ID of the zone setting. 

const (
	PrefetchPreloadIDPrefetchPreload PrefetchPreloadID = "prefetch_preload"
)

func (PrefetchPreloadID) IsKnown 

func (r PrefetchPreloadID) IsKnown() bool

type PrefetchPreloadValue 

type PrefetchPreloadValue string

Current value of the zone setting. 

const (
	PrefetchPreloadValueOn  PrefetchPreloadValue = "on"
	PrefetchPreloadValueOff PrefetchPreloadValue = "off"
)

func (PrefetchPreloadValue) IsKnown 

func (r PrefetchPreloadValue) IsKnown() bool

type ProxyReadTimeout 

type ProxyReadTimeout struct {
	// ID of the zone setting.
	ID ProxyReadTimeoutID `json:"id,required"`
	// Current value of the zone setting.
	Value float64 `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable ProxyReadTimeoutEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time            `json:"modified_on,nullable" format:"date-time"`
	JSON       proxyReadTimeoutJSON `json:"-"`
}

Maximum time between two read operations from origin.

func (*ProxyReadTimeout) UnmarshalJSON 

func (r *ProxyReadTimeout) UnmarshalJSON(data []byte) (err error)

type ProxyReadTimeoutEditable 

type ProxyReadTimeoutEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	ProxyReadTimeoutEditableTrue  ProxyReadTimeoutEditable = true
	ProxyReadTimeoutEditableFalse ProxyReadTimeoutEditable = false
)

func (ProxyReadTimeoutEditable) IsKnown 

func (r ProxyReadTimeoutEditable) IsKnown() bool

type ProxyReadTimeoutID 

type ProxyReadTimeoutID string

ID of the zone setting. 

const (
	ProxyReadTimeoutIDProxyReadTimeout ProxyReadTimeoutID = "proxy_read_timeout"
)

func (ProxyReadTimeoutID) IsKnown 

func (r ProxyReadTimeoutID) IsKnown() bool

type ProxyReadTimeoutParam 

type ProxyReadTimeoutParam struct {
	// ID of the zone setting.
	ID param.Field[ProxyReadTimeoutID] `json:"id,required"`
	// Current value of the zone setting.
	Value param.Field[float64] `json:"value,required"`
}

Maximum time between two read operations from origin.

func (ProxyReadTimeoutParam) MarshalJSON 

func (r ProxyReadTimeoutParam) MarshalJSON() (data []byte, err error)

type PseudoIPV4 

type PseudoIPV4 struct {
	// Value of the Pseudo IPv4 setting.
	ID PseudoIPV4ID `json:"id,required"`
	// Current value of the zone setting.
	Value PseudoIPV4Value `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable PseudoIPV4Editable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time      `json:"modified_on,nullable" format:"date-time"`
	JSON       pseudoIPV4JSON `json:"-"`
}

The value set for the Pseudo IPv4 setting.

func (*PseudoIPV4) UnmarshalJSON 

func (r *PseudoIPV4) UnmarshalJSON(data []byte) (err error)

type PseudoIPV4Editable 

type PseudoIPV4Editable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	PseudoIPV4EditableTrue  PseudoIPV4Editable = true
	PseudoIPV4EditableFalse PseudoIPV4Editable = false
)

func (PseudoIPV4Editable) IsKnown 

func (r PseudoIPV4Editable) IsKnown() bool

type PseudoIPV4ID 

type PseudoIPV4ID string

Value of the Pseudo IPv4 setting. 

const (
	PseudoIPV4IDPseudoIPV4 PseudoIPV4ID = "pseudo_ipv4"
)

func (PseudoIPV4ID) IsKnown 

func (r PseudoIPV4ID) IsKnown() bool

type PseudoIPV4Value 

type PseudoIPV4Value string

Current value of the zone setting. 

const (
	PseudoIPV4ValueOff             PseudoIPV4Value = "off"
	PseudoIPV4ValueAddHeader       PseudoIPV4Value = "add_header"
	PseudoIPV4ValueOverwriteHeader PseudoIPV4Value = "overwrite_header"
)

func (PseudoIPV4Value) IsKnown 

func (r PseudoIPV4Value) IsKnown() bool

type ResponseBuffering 

type ResponseBuffering struct {
	// ID of the zone setting.
	ID ResponseBufferingID `json:"id,required"`
	// Current value of the zone setting.
	Value ResponseBufferingValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable ResponseBufferingEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time             `json:"modified_on,nullable" format:"date-time"`
	JSON       responseBufferingJSON `json:"-"`
}

Enables or disables buffering of responses from the proxied server. Cloudflare may buffer the whole payload to deliver it at once to the client versus allowing it to be delivered in chunks. By default, the proxied server streams directly and is not buffered by Cloudflare. This is limited to Enterprise Zones.

func (*ResponseBuffering) UnmarshalJSON 

func (r *ResponseBuffering) UnmarshalJSON(data []byte) (err error)

type ResponseBufferingEditable 

type ResponseBufferingEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	ResponseBufferingEditableTrue  ResponseBufferingEditable = true
	ResponseBufferingEditableFalse ResponseBufferingEditable = false
)

func (ResponseBufferingEditable) IsKnown 

func (r ResponseBufferingEditable) IsKnown() bool

type ResponseBufferingID 

type ResponseBufferingID string

ID of the zone setting. 

const (
	ResponseBufferingIDResponseBuffering ResponseBufferingID = "response_buffering"
)

func (ResponseBufferingID) IsKnown 

func (r ResponseBufferingID) IsKnown() bool

type ResponseBufferingValue 

type ResponseBufferingValue string

Current value of the zone setting. 

const (
	ResponseBufferingValueOn  ResponseBufferingValue = "on"
	ResponseBufferingValueOff ResponseBufferingValue = "off"
)

func (ResponseBufferingValue) IsKnown 

func (r ResponseBufferingValue) IsKnown() bool

type ResponseInfo 

type ResponseInfo = shared.ResponseInfo

This is an alias to an internal type.

type RocketLoader 

type RocketLoader struct {
	// ID of the zone setting.
	ID RocketLoaderID `json:"id,required"`
	// Current value of the zone setting.
	Value RocketLoaderValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable RocketLoaderEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time        `json:"modified_on,nullable" format:"date-time"`
	JSON       rocketLoaderJSON `json:"-"`
}

Rocket Loader is a general-purpose asynchronous JavaScript optimisation that prioritises rendering your content while loading your site's Javascript asynchronously. Turning on Rocket Loader will immediately improve a web page's rendering time sometimes measured as Time to First Paint (TTFP), and also the `window.onload` time (assuming there is JavaScript on the page). This can have a positive impact on your Google search ranking. When turned on, Rocket Loader will automatically defer the loading of all Javascript referenced in your HTML, with no configuration required. Refer to [Understanding Rocket Loader](https://support.cloudflare.com/hc/articles/200168056) for more information.

func (*RocketLoader) UnmarshalJSON 

func (r *RocketLoader) UnmarshalJSON(data []byte) (err error)

type RocketLoaderEditable 

type RocketLoaderEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	RocketLoaderEditableTrue  RocketLoaderEditable = true
	RocketLoaderEditableFalse RocketLoaderEditable = false
)

func (RocketLoaderEditable) IsKnown 

func (r RocketLoaderEditable) IsKnown() bool

type RocketLoaderID 

type RocketLoaderID string

ID of the zone setting. 

const (
	RocketLoaderIDRocketLoader RocketLoaderID = "rocket_loader"
)

func (RocketLoaderID) IsKnown 

func (r RocketLoaderID) IsKnown() bool

type RocketLoaderParam 

type RocketLoaderParam struct {
	// ID of the zone setting.
	ID param.Field[RocketLoaderID] `json:"id,required"`
	// Current value of the zone setting.
	Value param.Field[RocketLoaderValue] `json:"value,required"`
}

Rocket Loader is a general-purpose asynchronous JavaScript optimisation that prioritises rendering your content while loading your site's Javascript asynchronously. Turning on Rocket Loader will immediately improve a web page's rendering time sometimes measured as Time to First Paint (TTFP), and also the `window.onload` time (assuming there is JavaScript on the page). This can have a positive impact on your Google search ranking. When turned on, Rocket Loader will automatically defer the loading of all Javascript referenced in your HTML, with no configuration required. Refer to [Understanding Rocket Loader](https://support.cloudflare.com/hc/articles/200168056) for more information.

func (RocketLoaderParam) MarshalJSON 

func (r RocketLoaderParam) MarshalJSON() (data []byte, err error)

type RocketLoaderValue 

type RocketLoaderValue string

Current value of the zone setting. 

const (
	RocketLoaderValueOn  RocketLoaderValue = "on"
	RocketLoaderValueOff RocketLoaderValue = "off"
)

func (RocketLoaderValue) IsKnown 

func (r RocketLoaderValue) IsKnown() bool

type Role 

type Role = shared.Role

This is an alias to an internal type.

type SSL 

type SSL struct {
	// ID of the zone setting.
	ID SSLID `json:"id,required"`
	// Current value of the zone setting.
	Value SSLValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable SSLEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,nullable" format:"date-time"`
	JSON       sslJSON   `json:"-"`
}

SSL encrypts your visitor's connection and safeguards credit card numbers and other personal data to and from your website. SSL can take up to 5 minutes to fully activate. Requires Cloudflare active on your root domain or www domain. Off: no SSL between the visitor and Cloudflare, and no SSL between Cloudflare and your web server (all HTTP traffic). Flexible: SSL between the visitor and Cloudflare -- visitor sees HTTPS on your site, but no SSL between Cloudflare and your web server. You don't need to have an SSL cert on your web server, but your vistors will still see the site as being HTTPS enabled. Full: SSL between the visitor and Cloudflare -- visitor sees HTTPS on your site, and SSL between Cloudflare and your web server. You'll need to have your own SSL cert or self-signed cert at the very least. Full (Strict): SSL between the visitor and Cloudflare -- visitor sees HTTPS on your site, and SSL between Cloudflare and your web server. You'll need to have a valid SSL certificate installed on your web server. This certificate must be signed by a certificate authority, have an expiration date in the future, and respond for the request domain name (hostname). (https://support.cloudflare.com/hc/en-us/articles/200170416).

func (*SSL) UnmarshalJSON 

func (r *SSL) UnmarshalJSON(data []byte) (err error)

type SSLEditable 

type SSLEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	SSLEditableTrue  SSLEditable = true
	SSLEditableFalse SSLEditable = false
)

func (SSLEditable) IsKnown 

func (r SSLEditable) IsKnown() bool

type SSLID 

type SSLID string

ID of the zone setting. 

const (
	SSLIDSSL SSLID = "ssl"
)

func (SSLID) IsKnown 

func (r SSLID) IsKnown() bool

type SSLRecommender 

type SSLRecommender struct {
	// Enrollment value for SSL/TLS Recommender.
	ID SSLRecommenderID `json:"id"`
	// ssl-recommender enrollment setting.
	Enabled bool               `json:"enabled"`
	JSON    sslRecommenderJSON `json:"-"`
}

Enrollment in the SSL/TLS Recommender service which tries to detect and recommend (by sending periodic emails) the most secure SSL/TLS setting your origin servers support.

func (*SSLRecommender) UnmarshalJSON 

func (r *SSLRecommender) UnmarshalJSON(data []byte) (err error)

type SSLRecommenderID 

type SSLRecommenderID string

Enrollment value for SSL/TLS Recommender. 

const (
	SSLRecommenderIDSSLRecommender SSLRecommenderID = "ssl_recommender"
)

func (SSLRecommenderID) IsKnown 

func (r SSLRecommenderID) IsKnown() bool

type SSLRecommenderParam 

type SSLRecommenderParam struct {
	// Enrollment value for SSL/TLS Recommender.
	ID param.Field[SSLRecommenderID] `json:"id"`
	// ssl-recommender enrollment setting.
	Enabled param.Field[bool] `json:"enabled"`
}

Enrollment in the SSL/TLS Recommender service which tries to detect and recommend (by sending periodic emails) the most secure SSL/TLS setting your origin servers support.

func (SSLRecommenderParam) MarshalJSON 

func (r SSLRecommenderParam) MarshalJSON() (data []byte, err error)

type SSLValue 

type SSLValue string

Current value of the zone setting. 

const (
	SSLValueOff      SSLValue = "off"
	SSLValueFlexible SSLValue = "flexible"
	SSLValueFull     SSLValue = "full"
	SSLValueStrict   SSLValue = "strict"
)

func (SSLValue) IsKnown 

func (r SSLValue) IsKnown() bool

type SecurityHeaders 

type SecurityHeaders struct {
	// ID of the zone's security header.
	ID SecurityHeadersID `json:"id,required"`
	// Current value of the zone setting.
	Value SecurityHeadersValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable SecurityHeadersEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time           `json:"modified_on,nullable" format:"date-time"`
	JSON       securityHeadersJSON `json:"-"`
}

Cloudflare security header for a zone.

func (*SecurityHeaders) UnmarshalJSON 

func (r *SecurityHeaders) UnmarshalJSON(data []byte) (err error)

type SecurityHeadersEditable 

type SecurityHeadersEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	SecurityHeadersEditableTrue  SecurityHeadersEditable = true
	SecurityHeadersEditableFalse SecurityHeadersEditable = false
)

func (SecurityHeadersEditable) IsKnown 

func (r SecurityHeadersEditable) IsKnown() bool

type SecurityHeadersID 

type SecurityHeadersID string

ID of the zone's security header. 

const (
	SecurityHeadersIDSecurityHeader SecurityHeadersID = "security_header"
)

func (SecurityHeadersID) IsKnown 

func (r SecurityHeadersID) IsKnown() bool

type SecurityHeadersValue 

type SecurityHeadersValue struct {
	// Strict Transport Security.
	StrictTransportSecurity SecurityHeadersValueStrictTransportSecurity `json:"strict_transport_security"`
	JSON                    securityHeadersValueJSON                    `json:"-"`
}

Current value of the zone setting.

func (*SecurityHeadersValue) UnmarshalJSON 

func (r *SecurityHeadersValue) UnmarshalJSON(data []byte) (err error)

type SecurityHeadersValueStrictTransportSecurity 

type SecurityHeadersValueStrictTransportSecurity struct {
	// Whether or not strict transport security is enabled.
	Enabled bool `json:"enabled"`
	// Include all subdomains for strict transport security.
	IncludeSubdomains bool `json:"include_subdomains"`
	// Max age in seconds of the strict transport security.
	MaxAge float64 `json:"max_age"`
	// Whether or not to include 'X-Content-Type-Options: nosniff' header.
	Nosniff bool                                            `json:"nosniff"`
	JSON    securityHeadersValueStrictTransportSecurityJSON `json:"-"`
}

Strict Transport Security.

func (*SecurityHeadersValueStrictTransportSecurity) UnmarshalJSON 

func (r *SecurityHeadersValueStrictTransportSecurity) UnmarshalJSON(data []byte) (err error)

type SecurityLevel 

type SecurityLevel struct {
	// ID of the zone setting.
	ID SecurityLevelID `json:"id,required"`
	// Current value of the zone setting.
	Value SecurityLevelValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable SecurityLevelEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time         `json:"modified_on,nullable" format:"date-time"`
	JSON       securityLevelJSON `json:"-"`
}

Choose the appropriate security profile for your website, which will automatically adjust each of the security settings. If you choose to customize an individual security setting, the profile will become Custom. (https://support.cloudflare.com/hc/en-us/articles/200170056).

func (*SecurityLevel) UnmarshalJSON 

func (r *SecurityLevel) UnmarshalJSON(data []byte) (err error)

type SecurityLevelEditable 

type SecurityLevelEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	SecurityLevelEditableTrue  SecurityLevelEditable = true
	SecurityLevelEditableFalse SecurityLevelEditable = false
)

func (SecurityLevelEditable) IsKnown 

func (r SecurityLevelEditable) IsKnown() bool

type SecurityLevelID 

type SecurityLevelID string

ID of the zone setting. 

const (
	SecurityLevelIDSecurityLevel SecurityLevelID = "security_level"
)

func (SecurityLevelID) IsKnown 

func (r SecurityLevelID) IsKnown() bool

type SecurityLevelValue 

type SecurityLevelValue string

Current value of the zone setting. 

const (
	SecurityLevelValueOff            SecurityLevelValue = "off"
	SecurityLevelValueEssentiallyOff SecurityLevelValue = "essentially_off"
	SecurityLevelValueLow            SecurityLevelValue = "low"
	SecurityLevelValueMedium         SecurityLevelValue = "medium"
	SecurityLevelValueHigh           SecurityLevelValue = "high"
	SecurityLevelValueUnderAttack    SecurityLevelValue = "under_attack"
)

func (SecurityLevelValue) IsKnown 

func (r SecurityLevelValue) IsKnown() bool

type ServerSideExcludes 

type ServerSideExcludes struct {
	// ID of the zone setting.
	ID ServerSideExcludesID `json:"id,required"`
	// Current value of the zone setting.
	Value ServerSideExcludesValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable ServerSideExcludesEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time              `json:"modified_on,nullable" format:"date-time"`
	JSON       serverSideExcludesJSON `json:"-"`
}

If there is sensitive content on your website that you want visible to real visitors, but that you want to hide from suspicious visitors, all you have to do is wrap the content with Cloudflare SSE tags. Wrap any content that you want to be excluded from suspicious visitors in the following SSE tags: <!--sse--><!--/sse-->. For example: <!--sse--> Bad visitors won't see my phone number, 555-555-5555 <!--/sse-->. Note: SSE only will work with HTML. If you have HTML minification enabled, you won't see the SSE tags in your HTML source when it's served through Cloudflare. SSE will still function in this case, as Cloudflare's HTML minification and SSE functionality occur on-the-fly as the resource moves through our network to the visitor's computer. (https://support.cloudflare.com/hc/en-us/articles/200170036).

func (*ServerSideExcludes) UnmarshalJSON 

func (r *ServerSideExcludes) UnmarshalJSON(data []byte) (err error)

type ServerSideExcludesEditable 

type ServerSideExcludesEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	ServerSideExcludesEditableTrue  ServerSideExcludesEditable = true
	ServerSideExcludesEditableFalse ServerSideExcludesEditable = false
)

func (ServerSideExcludesEditable) IsKnown 

func (r ServerSideExcludesEditable) IsKnown() bool

type ServerSideExcludesID 

type ServerSideExcludesID string

ID of the zone setting. 

const (
	ServerSideExcludesIDServerSideExclude ServerSideExcludesID = "server_side_exclude"
)

func (ServerSideExcludesID) IsKnown 

func (r ServerSideExcludesID) IsKnown() bool

type ServerSideExcludesValue 

type ServerSideExcludesValue string

Current value of the zone setting. 

const (
	ServerSideExcludesValueOn  ServerSideExcludesValue = "on"
	ServerSideExcludesValueOff ServerSideExcludesValue = "off"
)

func (ServerSideExcludesValue) IsKnown 

func (r ServerSideExcludesValue) IsKnown() bool

type SettingAdvancedDDoSGetParams 

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

type SettingAdvancedDDoSGetResponseEnvelope 

type SettingAdvancedDDoSGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Advanced protection from Distributed Denial of Service (DDoS) attacks on your
	// website. This is an uneditable value that is 'on' in the case of Business and
	// Enterprise zones.
	Result AdvancedDDoS                               `json:"result"`
	JSON   settingAdvancedDDoSGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingAdvancedDDoSGetResponseEnvelope) UnmarshalJSON 

func (r *SettingAdvancedDDoSGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingAdvancedDDoSService 

type SettingAdvancedDDoSService struct {
	Options []option.RequestOption
}

SettingAdvancedDDoSService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingAdvancedDDoSService method instead.

func NewSettingAdvancedDDoSService 

func NewSettingAdvancedDDoSService(opts ...option.RequestOption) (r *SettingAdvancedDDoSService)

NewSettingAdvancedDDoSService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingAdvancedDDoSService) Get 

func (r *SettingAdvancedDDoSService) Get(ctx context.Context, query SettingAdvancedDDoSGetParams, opts ...option.RequestOption) (res *AdvancedDDoS, err error)

Advanced protection from Distributed Denial of Service (DDoS) attacks on your website. This is an uneditable value that is 'on' in the case of Business and Enterprise zones.

type SettingAlwaysOnlineEditParams 

type SettingAlwaysOnlineEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingAlwaysOnlineEditParamsValue] `json:"value,required"`
}

func (SettingAlwaysOnlineEditParams) MarshalJSON 

func (r SettingAlwaysOnlineEditParams) MarshalJSON() (data []byte, err error)

type SettingAlwaysOnlineEditParamsValue 

type SettingAlwaysOnlineEditParamsValue string

Value of the zone setting. 

const (
	SettingAlwaysOnlineEditParamsValueOn  SettingAlwaysOnlineEditParamsValue = "on"
	SettingAlwaysOnlineEditParamsValueOff SettingAlwaysOnlineEditParamsValue = "off"
)

func (SettingAlwaysOnlineEditParamsValue) IsKnown 

func (r SettingAlwaysOnlineEditParamsValue) IsKnown() bool

type SettingAlwaysOnlineEditResponseEnvelope 

type SettingAlwaysOnlineEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When enabled, Cloudflare serves limited copies of web pages available from the
	// [Internet Archive's Wayback Machine](https://archive.org/web/) if your server is
	// offline. Refer to
	// [Always Online](https://developers.cloudflare.com/cache/about/always-online) for
	// more information.
	Result AlwaysOnline                                `json:"result"`
	JSON   settingAlwaysOnlineEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingAlwaysOnlineEditResponseEnvelope) UnmarshalJSON 

func (r *SettingAlwaysOnlineEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingAlwaysOnlineGetParams 

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

type SettingAlwaysOnlineGetResponseEnvelope 

type SettingAlwaysOnlineGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When enabled, Cloudflare serves limited copies of web pages available from the
	// [Internet Archive's Wayback Machine](https://archive.org/web/) if your server is
	// offline. Refer to
	// [Always Online](https://developers.cloudflare.com/cache/about/always-online) for
	// more information.
	Result AlwaysOnline                               `json:"result"`
	JSON   settingAlwaysOnlineGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingAlwaysOnlineGetResponseEnvelope) UnmarshalJSON 

func (r *SettingAlwaysOnlineGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingAlwaysOnlineService 

type SettingAlwaysOnlineService struct {
	Options []option.RequestOption
}

SettingAlwaysOnlineService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingAlwaysOnlineService method instead.

func NewSettingAlwaysOnlineService 

func NewSettingAlwaysOnlineService(opts ...option.RequestOption) (r *SettingAlwaysOnlineService)

NewSettingAlwaysOnlineService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingAlwaysOnlineService) Edit 

func (r *SettingAlwaysOnlineService) Edit(ctx context.Context, params SettingAlwaysOnlineEditParams, opts ...option.RequestOption) (res *AlwaysOnline, err error)

When enabled, Cloudflare serves limited copies of web pages available from the [Internet Archive's Wayback Machine](https://archive.org/web/) if your server is offline. Refer to [Always Online](https://developers.cloudflare.com/cache/about/always-online) for more information.

func (*SettingAlwaysOnlineService) Get 

func (r *SettingAlwaysOnlineService) Get(ctx context.Context, query SettingAlwaysOnlineGetParams, opts ...option.RequestOption) (res *AlwaysOnline, err error)

When enabled, Cloudflare serves limited copies of web pages available from the [Internet Archive's Wayback Machine](https://archive.org/web/) if your server is offline. Refer to [Always Online](https://developers.cloudflare.com/cache/about/always-online) for more information.

type SettingAlwaysUseHTTPSEditParams 

type SettingAlwaysUseHTTPSEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingAlwaysUseHTTPSEditParamsValue] `json:"value,required"`
}

func (SettingAlwaysUseHTTPSEditParams) MarshalJSON 

func (r SettingAlwaysUseHTTPSEditParams) MarshalJSON() (data []byte, err error)

type SettingAlwaysUseHTTPSEditParamsValue 

type SettingAlwaysUseHTTPSEditParamsValue string

Value of the zone setting. 

const (
	SettingAlwaysUseHTTPSEditParamsValueOn  SettingAlwaysUseHTTPSEditParamsValue = "on"
	SettingAlwaysUseHTTPSEditParamsValueOff SettingAlwaysUseHTTPSEditParamsValue = "off"
)

func (SettingAlwaysUseHTTPSEditParamsValue) IsKnown 

func (r SettingAlwaysUseHTTPSEditParamsValue) IsKnown() bool

type SettingAlwaysUseHTTPSEditResponseEnvelope 

type SettingAlwaysUseHTTPSEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Reply to all requests for URLs that use "http" with a 301 redirect to the
	// equivalent "https" URL. If you only want to redirect for a subset of requests,
	// consider creating an "Always use HTTPS" page rule.
	Result AlwaysUseHTTPS                                `json:"result"`
	JSON   settingAlwaysUseHTTPSEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingAlwaysUseHTTPSEditResponseEnvelope) UnmarshalJSON 

func (r *SettingAlwaysUseHTTPSEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingAlwaysUseHTTPSGetParams 

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

type SettingAlwaysUseHTTPSGetResponseEnvelope 

type SettingAlwaysUseHTTPSGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Reply to all requests for URLs that use "http" with a 301 redirect to the
	// equivalent "https" URL. If you only want to redirect for a subset of requests,
	// consider creating an "Always use HTTPS" page rule.
	Result AlwaysUseHTTPS                               `json:"result"`
	JSON   settingAlwaysUseHTTPSGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingAlwaysUseHTTPSGetResponseEnvelope) UnmarshalJSON 

func (r *SettingAlwaysUseHTTPSGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingAlwaysUseHTTPSService 

type SettingAlwaysUseHTTPSService struct {
	Options []option.RequestOption
}

SettingAlwaysUseHTTPSService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingAlwaysUseHTTPSService method instead.

func NewSettingAlwaysUseHTTPSService 

func NewSettingAlwaysUseHTTPSService(opts ...option.RequestOption) (r *SettingAlwaysUseHTTPSService)

NewSettingAlwaysUseHTTPSService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingAlwaysUseHTTPSService) Edit 

func (r *SettingAlwaysUseHTTPSService) Edit(ctx context.Context, params SettingAlwaysUseHTTPSEditParams, opts ...option.RequestOption) (res *AlwaysUseHTTPS, err error)

Reply to all requests for URLs that use "http" with a 301 redirect to the equivalent "https" URL. If you only want to redirect for a subset of requests, consider creating an "Always use HTTPS" page rule.

func (*SettingAlwaysUseHTTPSService) Get 

func (r *SettingAlwaysUseHTTPSService) Get(ctx context.Context, query SettingAlwaysUseHTTPSGetParams, opts ...option.RequestOption) (res *AlwaysUseHTTPS, err error)

Reply to all requests for URLs that use "http" with a 301 redirect to the equivalent "https" URL. If you only want to redirect for a subset of requests, consider creating an "Always use HTTPS" page rule.

type SettingAutomaticHTTPSRewriteEditParams 

type SettingAutomaticHTTPSRewriteEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting. Notes: Default value depends on the zone's plan
	// level.
	Value param.Field[SettingAutomaticHTTPSRewriteEditParamsValue] `json:"value,required"`
}

func (SettingAutomaticHTTPSRewriteEditParams) MarshalJSON 

func (r SettingAutomaticHTTPSRewriteEditParams) MarshalJSON() (data []byte, err error)

type SettingAutomaticHTTPSRewriteEditParamsValue 

type SettingAutomaticHTTPSRewriteEditParamsValue string

Value of the zone setting. Notes: Default value depends on the zone's plan level. 

const (
	SettingAutomaticHTTPSRewriteEditParamsValueOn  SettingAutomaticHTTPSRewriteEditParamsValue = "on"
	SettingAutomaticHTTPSRewriteEditParamsValueOff SettingAutomaticHTTPSRewriteEditParamsValue = "off"
)

func (SettingAutomaticHTTPSRewriteEditParamsValue) IsKnown 

func (r SettingAutomaticHTTPSRewriteEditParamsValue) IsKnown() bool

type SettingAutomaticHTTPSRewriteEditResponseEnvelope 

type SettingAutomaticHTTPSRewriteEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enable the Automatic HTTPS Rewrites feature for this zone.
	Result AutomaticHTTPSRewrites                               `json:"result"`
	JSON   settingAutomaticHTTPSRewriteEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingAutomaticHTTPSRewriteEditResponseEnvelope) UnmarshalJSON 

func (r *SettingAutomaticHTTPSRewriteEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingAutomaticHTTPSRewriteGetParams 

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

type SettingAutomaticHTTPSRewriteGetResponseEnvelope 

type SettingAutomaticHTTPSRewriteGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enable the Automatic HTTPS Rewrites feature for this zone.
	Result AutomaticHTTPSRewrites                              `json:"result"`
	JSON   settingAutomaticHTTPSRewriteGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingAutomaticHTTPSRewriteGetResponseEnvelope) UnmarshalJSON 

func (r *SettingAutomaticHTTPSRewriteGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingAutomaticHTTPSRewriteService 

type SettingAutomaticHTTPSRewriteService struct {
	Options []option.RequestOption
}

SettingAutomaticHTTPSRewriteService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingAutomaticHTTPSRewriteService method instead.

func NewSettingAutomaticHTTPSRewriteService 

func NewSettingAutomaticHTTPSRewriteService(opts ...option.RequestOption) (r *SettingAutomaticHTTPSRewriteService)

NewSettingAutomaticHTTPSRewriteService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingAutomaticHTTPSRewriteService) Edit 

func (r *SettingAutomaticHTTPSRewriteService) Edit(ctx context.Context, params SettingAutomaticHTTPSRewriteEditParams, opts ...option.RequestOption) (res *AutomaticHTTPSRewrites, err error)

Enable the Automatic HTTPS Rewrites feature for this zone.

func (*SettingAutomaticHTTPSRewriteService) Get 

func (r *SettingAutomaticHTTPSRewriteService) Get(ctx context.Context, query SettingAutomaticHTTPSRewriteGetParams, opts ...option.RequestOption) (res *AutomaticHTTPSRewrites, err error)

Enable the Automatic HTTPS Rewrites feature for this zone.

type SettingAutomaticPlatformOptimizationEditParams 

type SettingAutomaticPlatformOptimizationEditParams struct {
	// Identifier
	ZoneID param.Field[string]                             `path:"zone_id,required"`
	Value  param.Field[AutomaticPlatformOptimizationParam] `json:"value,required"`
}

func (SettingAutomaticPlatformOptimizationEditParams) MarshalJSON 

func (r SettingAutomaticPlatformOptimizationEditParams) MarshalJSON() (data []byte, err error)

type SettingAutomaticPlatformOptimizationEditResponseEnvelope 

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

func (*SettingAutomaticPlatformOptimizationEditResponseEnvelope) UnmarshalJSON 

func (r *SettingAutomaticPlatformOptimizationEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingAutomaticPlatformOptimizationGetParams 

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

type SettingAutomaticPlatformOptimizationGetResponseEnvelope 

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

func (*SettingAutomaticPlatformOptimizationGetResponseEnvelope) UnmarshalJSON 

func (r *SettingAutomaticPlatformOptimizationGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingAutomaticPlatformOptimizationService 

type SettingAutomaticPlatformOptimizationService struct {
	Options []option.RequestOption
}

SettingAutomaticPlatformOptimizationService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingAutomaticPlatformOptimizationService method instead.

func NewSettingAutomaticPlatformOptimizationService 

func NewSettingAutomaticPlatformOptimizationService(opts ...option.RequestOption) (r *SettingAutomaticPlatformOptimizationService)

NewSettingAutomaticPlatformOptimizationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingAutomaticPlatformOptimizationService) Edit 

func (r *SettingAutomaticPlatformOptimizationService) Edit(ctx context.Context, params SettingAutomaticPlatformOptimizationEditParams, opts ...option.RequestOption) (res *AutomaticPlatformOptimization, err error)

[Automatic Platform Optimization for WordPress](https://developers.cloudflare.com/automatic-platform-optimization/) serves your WordPress site from Cloudflare's edge network and caches third-party fonts.

func (*SettingAutomaticPlatformOptimizationService) Get 

func (r *SettingAutomaticPlatformOptimizationService) Get(ctx context.Context, query SettingAutomaticPlatformOptimizationGetParams, opts ...option.RequestOption) (res *AutomaticPlatformOptimization, err error)

[Automatic Platform Optimization for WordPress](https://developers.cloudflare.com/automatic-platform-optimization/) serves your WordPress site from Cloudflare's edge network and caches third-party fonts.

type SettingBrotliEditParams 

type SettingBrotliEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingBrotliEditParamsValue] `json:"value,required"`
}

func (SettingBrotliEditParams) MarshalJSON 

func (r SettingBrotliEditParams) MarshalJSON() (data []byte, err error)

type SettingBrotliEditParamsValue 

type SettingBrotliEditParamsValue string

Value of the zone setting. 

const (
	SettingBrotliEditParamsValueOff SettingBrotliEditParamsValue = "off"
	SettingBrotliEditParamsValueOn  SettingBrotliEditParamsValue = "on"
)

func (SettingBrotliEditParamsValue) IsKnown 

func (r SettingBrotliEditParamsValue) IsKnown() bool

type SettingBrotliEditResponseEnvelope 

type SettingBrotliEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When the client requesting an asset supports the Brotli compression algorithm,
	// Cloudflare will serve a Brotli compressed version of the asset.
	Result Brotli                                `json:"result"`
	JSON   settingBrotliEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingBrotliEditResponseEnvelope) UnmarshalJSON 

func (r *SettingBrotliEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingBrotliGetParams 

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

type SettingBrotliGetResponseEnvelope 

type SettingBrotliGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When the client requesting an asset supports the Brotli compression algorithm,
	// Cloudflare will serve a Brotli compressed version of the asset.
	Result Brotli                               `json:"result"`
	JSON   settingBrotliGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingBrotliGetResponseEnvelope) UnmarshalJSON 

func (r *SettingBrotliGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingBrotliService 

type SettingBrotliService struct {
	Options []option.RequestOption
}

SettingBrotliService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingBrotliService method instead.

func NewSettingBrotliService 

func NewSettingBrotliService(opts ...option.RequestOption) (r *SettingBrotliService)

NewSettingBrotliService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingBrotliService) Edit 

func (r *SettingBrotliService) Edit(ctx context.Context, params SettingBrotliEditParams, opts ...option.RequestOption) (res *Brotli, err error)

When the client requesting an asset supports the Brotli compression algorithm, Cloudflare will serve a Brotli compressed version of the asset.

func (*SettingBrotliService) Get 

func (r *SettingBrotliService) Get(ctx context.Context, query SettingBrotliGetParams, opts ...option.RequestOption) (res *Brotli, err error)

When the client requesting an asset supports the Brotli compression algorithm, Cloudflare will serve a Brotli compressed version of the asset.

type SettingBrowserCacheTTLEditParams 

type SettingBrowserCacheTTLEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting. Notes: Setting a TTL of 0 is equivalent to selecting
	// `Respect Existing Headers`
	Value param.Field[SettingBrowserCacheTTLEditParamsValue] `json:"value,required"`
}

func (SettingBrowserCacheTTLEditParams) MarshalJSON 

func (r SettingBrowserCacheTTLEditParams) MarshalJSON() (data []byte, err error)

type SettingBrowserCacheTTLEditParamsValue 

type SettingBrowserCacheTTLEditParamsValue float64

Value of the zone setting. Notes: Setting a TTL of 0 is equivalent to selecting `Respect Existing Headers` 

const (
	SettingBrowserCacheTTLEditParamsValue0        SettingBrowserCacheTTLEditParamsValue = 0
	SettingBrowserCacheTTLEditParamsValue30       SettingBrowserCacheTTLEditParamsValue = 30
	SettingBrowserCacheTTLEditParamsValue60       SettingBrowserCacheTTLEditParamsValue = 60
	SettingBrowserCacheTTLEditParamsValue120      SettingBrowserCacheTTLEditParamsValue = 120
	SettingBrowserCacheTTLEditParamsValue300      SettingBrowserCacheTTLEditParamsValue = 300
	SettingBrowserCacheTTLEditParamsValue1200     SettingBrowserCacheTTLEditParamsValue = 1200
	SettingBrowserCacheTTLEditParamsValue1800     SettingBrowserCacheTTLEditParamsValue = 1800
	SettingBrowserCacheTTLEditParamsValue3600     SettingBrowserCacheTTLEditParamsValue = 3600
	SettingBrowserCacheTTLEditParamsValue7200     SettingBrowserCacheTTLEditParamsValue = 7200
	SettingBrowserCacheTTLEditParamsValue10800    SettingBrowserCacheTTLEditParamsValue = 10800
	SettingBrowserCacheTTLEditParamsValue14400    SettingBrowserCacheTTLEditParamsValue = 14400
	SettingBrowserCacheTTLEditParamsValue18000    SettingBrowserCacheTTLEditParamsValue = 18000
	SettingBrowserCacheTTLEditParamsValue28800    SettingBrowserCacheTTLEditParamsValue = 28800
	SettingBrowserCacheTTLEditParamsValue43200    SettingBrowserCacheTTLEditParamsValue = 43200
	SettingBrowserCacheTTLEditParamsValue57600    SettingBrowserCacheTTLEditParamsValue = 57600
	SettingBrowserCacheTTLEditParamsValue72000    SettingBrowserCacheTTLEditParamsValue = 72000
	SettingBrowserCacheTTLEditParamsValue86400    SettingBrowserCacheTTLEditParamsValue = 86400
	SettingBrowserCacheTTLEditParamsValue172800   SettingBrowserCacheTTLEditParamsValue = 172800
	SettingBrowserCacheTTLEditParamsValue259200   SettingBrowserCacheTTLEditParamsValue = 259200
	SettingBrowserCacheTTLEditParamsValue345600   SettingBrowserCacheTTLEditParamsValue = 345600
	SettingBrowserCacheTTLEditParamsValue432000   SettingBrowserCacheTTLEditParamsValue = 432000
	SettingBrowserCacheTTLEditParamsValue691200   SettingBrowserCacheTTLEditParamsValue = 691200
	SettingBrowserCacheTTLEditParamsValue1382400  SettingBrowserCacheTTLEditParamsValue = 1382400
	SettingBrowserCacheTTLEditParamsValue2073600  SettingBrowserCacheTTLEditParamsValue = 2073600
	SettingBrowserCacheTTLEditParamsValue2678400  SettingBrowserCacheTTLEditParamsValue = 2678400
	SettingBrowserCacheTTLEditParamsValue5356800  SettingBrowserCacheTTLEditParamsValue = 5356800
	SettingBrowserCacheTTLEditParamsValue16070400 SettingBrowserCacheTTLEditParamsValue = 16070400
	SettingBrowserCacheTTLEditParamsValue31536000 SettingBrowserCacheTTLEditParamsValue = 31536000
)

func (SettingBrowserCacheTTLEditParamsValue) IsKnown 

func (r SettingBrowserCacheTTLEditParamsValue) IsKnown() bool

type SettingBrowserCacheTTLEditResponseEnvelope 

type SettingBrowserCacheTTLEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Browser Cache TTL (in seconds) specifies how long Cloudflare-cached resources
	// will remain on your visitors' computers. Cloudflare will honor any larger times
	// specified by your server.
	// (https://support.cloudflare.com/hc/en-us/articles/200168276).
	Result BrowserCacheTTL                                `json:"result"`
	JSON   settingBrowserCacheTTLEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingBrowserCacheTTLEditResponseEnvelope) UnmarshalJSON 

func (r *SettingBrowserCacheTTLEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingBrowserCacheTTLGetParams 

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

type SettingBrowserCacheTTLGetResponseEnvelope 

type SettingBrowserCacheTTLGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Browser Cache TTL (in seconds) specifies how long Cloudflare-cached resources
	// will remain on your visitors' computers. Cloudflare will honor any larger times
	// specified by your server.
	// (https://support.cloudflare.com/hc/en-us/articles/200168276).
	Result BrowserCacheTTL                               `json:"result"`
	JSON   settingBrowserCacheTTLGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingBrowserCacheTTLGetResponseEnvelope) UnmarshalJSON 

func (r *SettingBrowserCacheTTLGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingBrowserCacheTTLService 

type SettingBrowserCacheTTLService struct {
	Options []option.RequestOption
}

SettingBrowserCacheTTLService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingBrowserCacheTTLService method instead.

func NewSettingBrowserCacheTTLService 

func NewSettingBrowserCacheTTLService(opts ...option.RequestOption) (r *SettingBrowserCacheTTLService)

NewSettingBrowserCacheTTLService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingBrowserCacheTTLService) Edit 

func (r *SettingBrowserCacheTTLService) Edit(ctx context.Context, params SettingBrowserCacheTTLEditParams, opts ...option.RequestOption) (res *BrowserCacheTTL, err error)

Browser Cache TTL (in seconds) specifies how long Cloudflare-cached resources will remain on your visitors' computers. Cloudflare will honor any larger times specified by your server. (https://support.cloudflare.com/hc/en-us/articles/200168276).

func (*SettingBrowserCacheTTLService) Get 

func (r *SettingBrowserCacheTTLService) Get(ctx context.Context, query SettingBrowserCacheTTLGetParams, opts ...option.RequestOption) (res *BrowserCacheTTL, err error)

Browser Cache TTL (in seconds) specifies how long Cloudflare-cached resources will remain on your visitors' computers. Cloudflare will honor any larger times specified by your server. (https://support.cloudflare.com/hc/en-us/articles/200168276).

type SettingBrowserCheckEditParams 

type SettingBrowserCheckEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingBrowserCheckEditParamsValue] `json:"value,required"`
}

func (SettingBrowserCheckEditParams) MarshalJSON 

func (r SettingBrowserCheckEditParams) MarshalJSON() (data []byte, err error)

type SettingBrowserCheckEditParamsValue 

type SettingBrowserCheckEditParamsValue string

Value of the zone setting. 

const (
	SettingBrowserCheckEditParamsValueOn  SettingBrowserCheckEditParamsValue = "on"
	SettingBrowserCheckEditParamsValueOff SettingBrowserCheckEditParamsValue = "off"
)

func (SettingBrowserCheckEditParamsValue) IsKnown 

func (r SettingBrowserCheckEditParamsValue) IsKnown() bool

type SettingBrowserCheckEditResponseEnvelope 

type SettingBrowserCheckEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Browser Integrity Check is similar to Bad Behavior and looks for common HTTP
	// headers abused most commonly by spammers and denies access to your page. It will
	// also challenge visitors that do not have a user agent or a non standard user
	// agent (also commonly used by abuse bots, crawlers or visitors).
	// (https://support.cloudflare.com/hc/en-us/articles/200170086).
	Result BrowserCheck                                `json:"result"`
	JSON   settingBrowserCheckEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingBrowserCheckEditResponseEnvelope) UnmarshalJSON 

func (r *SettingBrowserCheckEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingBrowserCheckGetParams 

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

type SettingBrowserCheckGetResponseEnvelope 

type SettingBrowserCheckGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Browser Integrity Check is similar to Bad Behavior and looks for common HTTP
	// headers abused most commonly by spammers and denies access to your page. It will
	// also challenge visitors that do not have a user agent or a non standard user
	// agent (also commonly used by abuse bots, crawlers or visitors).
	// (https://support.cloudflare.com/hc/en-us/articles/200170086).
	Result BrowserCheck                               `json:"result"`
	JSON   settingBrowserCheckGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingBrowserCheckGetResponseEnvelope) UnmarshalJSON 

func (r *SettingBrowserCheckGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingBrowserCheckService 

type SettingBrowserCheckService struct {
	Options []option.RequestOption
}

SettingBrowserCheckService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingBrowserCheckService method instead.

func NewSettingBrowserCheckService 

func NewSettingBrowserCheckService(opts ...option.RequestOption) (r *SettingBrowserCheckService)

NewSettingBrowserCheckService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingBrowserCheckService) Edit 

func (r *SettingBrowserCheckService) Edit(ctx context.Context, params SettingBrowserCheckEditParams, opts ...option.RequestOption) (res *BrowserCheck, err error)

Browser Integrity Check is similar to Bad Behavior and looks for common HTTP headers abused most commonly by spammers and denies access to your page. It will also challenge visitors that do not have a user agent or a non standard user agent (also commonly used by abuse bots, crawlers or visitors). (https://support.cloudflare.com/hc/en-us/articles/200170086).

func (*SettingBrowserCheckService) Get 

func (r *SettingBrowserCheckService) Get(ctx context.Context, query SettingBrowserCheckGetParams, opts ...option.RequestOption) (res *BrowserCheck, err error)

Browser Integrity Check is similar to Bad Behavior and looks for common HTTP headers abused most commonly by spammers and denies access to your page. It will also challenge visitors that do not have a user agent or a non standard user agent (also commonly used by abuse bots, crawlers or visitors). (https://support.cloudflare.com/hc/en-us/articles/200170086).

type SettingCacheLevelEditParams 

type SettingCacheLevelEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingCacheLevelEditParamsValue] `json:"value,required"`
}

func (SettingCacheLevelEditParams) MarshalJSON 

func (r SettingCacheLevelEditParams) MarshalJSON() (data []byte, err error)

type SettingCacheLevelEditParamsValue 

type SettingCacheLevelEditParamsValue string

Value of the zone setting. 

const (
	SettingCacheLevelEditParamsValueAggressive SettingCacheLevelEditParamsValue = "aggressive"
	SettingCacheLevelEditParamsValueBasic      SettingCacheLevelEditParamsValue = "basic"
	SettingCacheLevelEditParamsValueSimplified SettingCacheLevelEditParamsValue = "simplified"
)

func (SettingCacheLevelEditParamsValue) IsKnown 

func (r SettingCacheLevelEditParamsValue) IsKnown() bool

type SettingCacheLevelEditResponseEnvelope 

type SettingCacheLevelEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cache Level functions based off the setting level. The basic setting will cache
	// most static resources (i.e., css, images, and JavaScript). The simplified
	// setting will ignore the query string when delivering a cached resource. The
	// aggressive setting will cache all static resources, including ones with a query
	// string. (https://support.cloudflare.com/hc/en-us/articles/200168256).
	Result CacheLevel                                `json:"result"`
	JSON   settingCacheLevelEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingCacheLevelEditResponseEnvelope) UnmarshalJSON 

func (r *SettingCacheLevelEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingCacheLevelGetParams 

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

type SettingCacheLevelGetResponseEnvelope 

type SettingCacheLevelGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cache Level functions based off the setting level. The basic setting will cache
	// most static resources (i.e., css, images, and JavaScript). The simplified
	// setting will ignore the query string when delivering a cached resource. The
	// aggressive setting will cache all static resources, including ones with a query
	// string. (https://support.cloudflare.com/hc/en-us/articles/200168256).
	Result CacheLevel                               `json:"result"`
	JSON   settingCacheLevelGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingCacheLevelGetResponseEnvelope) UnmarshalJSON 

func (r *SettingCacheLevelGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingCacheLevelService 

type SettingCacheLevelService struct {
	Options []option.RequestOption
}

SettingCacheLevelService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingCacheLevelService method instead.

func NewSettingCacheLevelService 

func NewSettingCacheLevelService(opts ...option.RequestOption) (r *SettingCacheLevelService)

NewSettingCacheLevelService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingCacheLevelService) Edit 

func (r *SettingCacheLevelService) Edit(ctx context.Context, params SettingCacheLevelEditParams, opts ...option.RequestOption) (res *CacheLevel, err error)

Cache Level functions based off the setting level. The basic setting will cache most static resources (i.e., css, images, and JavaScript). The simplified setting will ignore the query string when delivering a cached resource. The aggressive setting will cache all static resources, including ones with a query string. (https://support.cloudflare.com/hc/en-us/articles/200168256).

func (*SettingCacheLevelService) Get 

func (r *SettingCacheLevelService) Get(ctx context.Context, query SettingCacheLevelGetParams, opts ...option.RequestOption) (res *CacheLevel, err error)

Cache Level functions based off the setting level. The basic setting will cache most static resources (i.e., css, images, and JavaScript). The simplified setting will ignore the query string when delivering a cached resource. The aggressive setting will cache all static resources, including ones with a query string. (https://support.cloudflare.com/hc/en-us/articles/200168256).

type SettingChallengeTTLEditParams 

type SettingChallengeTTLEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingChallengeTTLEditParamsValue] `json:"value,required"`
}

func (SettingChallengeTTLEditParams) MarshalJSON 

func (r SettingChallengeTTLEditParams) MarshalJSON() (data []byte, err error)

type SettingChallengeTTLEditParamsValue 

type SettingChallengeTTLEditParamsValue float64

Value of the zone setting. 

const (
	SettingChallengeTTLEditParamsValue300      SettingChallengeTTLEditParamsValue = 300
	SettingChallengeTTLEditParamsValue900      SettingChallengeTTLEditParamsValue = 900
	SettingChallengeTTLEditParamsValue1800     SettingChallengeTTLEditParamsValue = 1800
	SettingChallengeTTLEditParamsValue2700     SettingChallengeTTLEditParamsValue = 2700
	SettingChallengeTTLEditParamsValue3600     SettingChallengeTTLEditParamsValue = 3600
	SettingChallengeTTLEditParamsValue7200     SettingChallengeTTLEditParamsValue = 7200
	SettingChallengeTTLEditParamsValue10800    SettingChallengeTTLEditParamsValue = 10800
	SettingChallengeTTLEditParamsValue14400    SettingChallengeTTLEditParamsValue = 14400
	SettingChallengeTTLEditParamsValue28800    SettingChallengeTTLEditParamsValue = 28800
	SettingChallengeTTLEditParamsValue57600    SettingChallengeTTLEditParamsValue = 57600
	SettingChallengeTTLEditParamsValue86400    SettingChallengeTTLEditParamsValue = 86400
	SettingChallengeTTLEditParamsValue604800   SettingChallengeTTLEditParamsValue = 604800
	SettingChallengeTTLEditParamsValue2592000  SettingChallengeTTLEditParamsValue = 2592000
	SettingChallengeTTLEditParamsValue31536000 SettingChallengeTTLEditParamsValue = 31536000
)

func (SettingChallengeTTLEditParamsValue) IsKnown 

func (r SettingChallengeTTLEditParamsValue) IsKnown() bool

type SettingChallengeTTLEditResponseEnvelope 

type SettingChallengeTTLEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Specify how long a visitor is allowed access to your site after successfully
	// completing a challenge (such as a CAPTCHA). After the TTL has expired the
	// visitor will have to complete a new challenge. We recommend a 15 - 45 minute
	// setting and will attempt to honor any setting above 45 minutes.
	// (https://support.cloudflare.com/hc/en-us/articles/200170136).
	Result ChallengeTTL                                `json:"result"`
	JSON   settingChallengeTTLEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingChallengeTTLEditResponseEnvelope) UnmarshalJSON 

func (r *SettingChallengeTTLEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingChallengeTTLGetParams 

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

type SettingChallengeTTLGetResponseEnvelope 

type SettingChallengeTTLGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Specify how long a visitor is allowed access to your site after successfully
	// completing a challenge (such as a CAPTCHA). After the TTL has expired the
	// visitor will have to complete a new challenge. We recommend a 15 - 45 minute
	// setting and will attempt to honor any setting above 45 minutes.
	// (https://support.cloudflare.com/hc/en-us/articles/200170136).
	Result ChallengeTTL                               `json:"result"`
	JSON   settingChallengeTTLGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingChallengeTTLGetResponseEnvelope) UnmarshalJSON 

func (r *SettingChallengeTTLGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingChallengeTTLService 

type SettingChallengeTTLService struct {
	Options []option.RequestOption
}

SettingChallengeTTLService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingChallengeTTLService method instead.

func NewSettingChallengeTTLService 

func NewSettingChallengeTTLService(opts ...option.RequestOption) (r *SettingChallengeTTLService)

NewSettingChallengeTTLService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingChallengeTTLService) Edit 

func (r *SettingChallengeTTLService) Edit(ctx context.Context, params SettingChallengeTTLEditParams, opts ...option.RequestOption) (res *ChallengeTTL, err error)

Specify how long a visitor is allowed access to your site after successfully completing a challenge (such as a CAPTCHA). After the TTL has expired the visitor will have to complete a new challenge. We recommend a 15 - 45 minute setting and will attempt to honor any setting above 45 minutes. (https://support.cloudflare.com/hc/en-us/articles/200170136).

func (*SettingChallengeTTLService) Get 

func (r *SettingChallengeTTLService) Get(ctx context.Context, query SettingChallengeTTLGetParams, opts ...option.RequestOption) (res *ChallengeTTL, err error)

Specify how long a visitor is allowed access to your site after successfully completing a challenge (such as a CAPTCHA). After the TTL has expired the visitor will have to complete a new challenge. We recommend a 15 - 45 minute setting and will attempt to honor any setting above 45 minutes. (https://support.cloudflare.com/hc/en-us/articles/200170136).

type SettingCipherEditParams 

type SettingCipherEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[[]string] `json:"value,required"`
}

func (SettingCipherEditParams) MarshalJSON 

func (r SettingCipherEditParams) MarshalJSON() (data []byte, err error)

type SettingCipherEditResponseEnvelope 

type SettingCipherEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// An allowlist of ciphers for TLS termination. These ciphers must be in the
	// BoringSSL format.
	Result Ciphers                               `json:"result"`
	JSON   settingCipherEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingCipherEditResponseEnvelope) UnmarshalJSON 

func (r *SettingCipherEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingCipherGetParams 

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

type SettingCipherGetResponseEnvelope 

type SettingCipherGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// An allowlist of ciphers for TLS termination. These ciphers must be in the
	// BoringSSL format.
	Result Ciphers                              `json:"result"`
	JSON   settingCipherGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingCipherGetResponseEnvelope) UnmarshalJSON 

func (r *SettingCipherGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingCipherService 

type SettingCipherService struct {
	Options []option.RequestOption
}

SettingCipherService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingCipherService method instead.

func NewSettingCipherService 

func NewSettingCipherService(opts ...option.RequestOption) (r *SettingCipherService)

NewSettingCipherService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingCipherService) Edit 

func (r *SettingCipherService) Edit(ctx context.Context, params SettingCipherEditParams, opts ...option.RequestOption) (res *Ciphers, err error)

Changes ciphers setting.

func (*SettingCipherService) Get 

func (r *SettingCipherService) Get(ctx context.Context, query SettingCipherGetParams, opts ...option.RequestOption) (res *Ciphers, err error)

Gets ciphers setting.

type SettingDevelopmentModeEditParams 

type SettingDevelopmentModeEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingDevelopmentModeEditParamsValue] `json:"value,required"`
}

func (SettingDevelopmentModeEditParams) MarshalJSON 

func (r SettingDevelopmentModeEditParams) MarshalJSON() (data []byte, err error)

type SettingDevelopmentModeEditParamsValue 

type SettingDevelopmentModeEditParamsValue string

Value of the zone setting. 

const (
	SettingDevelopmentModeEditParamsValueOn  SettingDevelopmentModeEditParamsValue = "on"
	SettingDevelopmentModeEditParamsValueOff SettingDevelopmentModeEditParamsValue = "off"
)

func (SettingDevelopmentModeEditParamsValue) IsKnown 

func (r SettingDevelopmentModeEditParamsValue) IsKnown() bool

type SettingDevelopmentModeEditResponseEnvelope 

type SettingDevelopmentModeEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Development Mode temporarily allows you to enter development mode for your
	// websites if you need to make changes to your site. This will bypass Cloudflare's
	// accelerated cache and slow down your site, but is useful if you are making
	// changes to cacheable content (like images, css, or JavaScript) and would like to
	// see those changes right away. Once entered, development mode will last for 3
	// hours and then automatically toggle off.
	Result DevelopmentMode                                `json:"result"`
	JSON   settingDevelopmentModeEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingDevelopmentModeEditResponseEnvelope) UnmarshalJSON 

func (r *SettingDevelopmentModeEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingDevelopmentModeGetParams 

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

type SettingDevelopmentModeGetResponseEnvelope 

type SettingDevelopmentModeGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Development Mode temporarily allows you to enter development mode for your
	// websites if you need to make changes to your site. This will bypass Cloudflare's
	// accelerated cache and slow down your site, but is useful if you are making
	// changes to cacheable content (like images, css, or JavaScript) and would like to
	// see those changes right away. Once entered, development mode will last for 3
	// hours and then automatically toggle off.
	Result DevelopmentMode                               `json:"result"`
	JSON   settingDevelopmentModeGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingDevelopmentModeGetResponseEnvelope) UnmarshalJSON 

func (r *SettingDevelopmentModeGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingDevelopmentModeService 

type SettingDevelopmentModeService struct {
	Options []option.RequestOption
}

SettingDevelopmentModeService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingDevelopmentModeService method instead.

func NewSettingDevelopmentModeService 

func NewSettingDevelopmentModeService(opts ...option.RequestOption) (r *SettingDevelopmentModeService)

NewSettingDevelopmentModeService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingDevelopmentModeService) Edit 

func (r *SettingDevelopmentModeService) Edit(ctx context.Context, params SettingDevelopmentModeEditParams, opts ...option.RequestOption) (res *DevelopmentMode, err error)

Development Mode temporarily allows you to enter development mode for your websites if you need to make changes to your site. This will bypass Cloudflare's accelerated cache and slow down your site, but is useful if you are making changes to cacheable content (like images, css, or JavaScript) and would like to see those changes right away. Once entered, development mode will last for 3 hours and then automatically toggle off.

func (*SettingDevelopmentModeService) Get 

func (r *SettingDevelopmentModeService) Get(ctx context.Context, query SettingDevelopmentModeGetParams, opts ...option.RequestOption) (res *DevelopmentMode, err error)

Development Mode temporarily allows you to enter development mode for your websites if you need to make changes to your site. This will bypass Cloudflare's accelerated cache and slow down your site, but is useful if you are making changes to cacheable content (like images, css, or JavaScript) and would like to see those changes right away. Once entered, development mode will last for 3 hours and then automatically toggle off.

type SettingEarlyHintEditParams 

type SettingEarlyHintEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingEarlyHintEditParamsValue] `json:"value,required"`
}

func (SettingEarlyHintEditParams) MarshalJSON 

func (r SettingEarlyHintEditParams) MarshalJSON() (data []byte, err error)

type SettingEarlyHintEditParamsValue 

type SettingEarlyHintEditParamsValue string

Value of the zone setting. 

const (
	SettingEarlyHintEditParamsValueOn  SettingEarlyHintEditParamsValue = "on"
	SettingEarlyHintEditParamsValueOff SettingEarlyHintEditParamsValue = "off"
)

func (SettingEarlyHintEditParamsValue) IsKnown 

func (r SettingEarlyHintEditParamsValue) IsKnown() bool

type SettingEarlyHintEditResponseEnvelope 

type SettingEarlyHintEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When enabled, Cloudflare will attempt to speed up overall page loads by serving
	// `103` responses with `Link` headers from the final response. Refer to
	// [Early Hints](https://developers.cloudflare.com/cache/about/early-hints) for
	// more information.
	Result EarlyHints                               `json:"result"`
	JSON   settingEarlyHintEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingEarlyHintEditResponseEnvelope) UnmarshalJSON 

func (r *SettingEarlyHintEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingEarlyHintGetParams 

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

type SettingEarlyHintGetResponseEnvelope 

type SettingEarlyHintGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When enabled, Cloudflare will attempt to speed up overall page loads by serving
	// `103` responses with `Link` headers from the final response. Refer to
	// [Early Hints](https://developers.cloudflare.com/cache/about/early-hints) for
	// more information.
	Result EarlyHints                              `json:"result"`
	JSON   settingEarlyHintGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingEarlyHintGetResponseEnvelope) UnmarshalJSON 

func (r *SettingEarlyHintGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingEarlyHintService 

type SettingEarlyHintService struct {
	Options []option.RequestOption
}

SettingEarlyHintService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingEarlyHintService method instead.

func NewSettingEarlyHintService 

func NewSettingEarlyHintService(opts ...option.RequestOption) (r *SettingEarlyHintService)

NewSettingEarlyHintService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingEarlyHintService) Edit 

func (r *SettingEarlyHintService) Edit(ctx context.Context, params SettingEarlyHintEditParams, opts ...option.RequestOption) (res *EarlyHints, err error)

When enabled, Cloudflare will attempt to speed up overall page loads by serving `103` responses with `Link` headers from the final response. Refer to [Early Hints](https://developers.cloudflare.com/cache/about/early-hints) for more information.

func (*SettingEarlyHintService) Get 

func (r *SettingEarlyHintService) Get(ctx context.Context, query SettingEarlyHintGetParams, opts ...option.RequestOption) (res *EarlyHints, err error)

When enabled, Cloudflare will attempt to speed up overall page loads by serving `103` responses with `Link` headers from the final response. Refer to [Early Hints](https://developers.cloudflare.com/cache/about/early-hints) for more information.

type SettingEmailObfuscationEditParams 

type SettingEmailObfuscationEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingEmailObfuscationEditParamsValue] `json:"value,required"`
}

func (SettingEmailObfuscationEditParams) MarshalJSON 

func (r SettingEmailObfuscationEditParams) MarshalJSON() (data []byte, err error)

type SettingEmailObfuscationEditParamsValue 

type SettingEmailObfuscationEditParamsValue string

Value of the zone setting. 

const (
	SettingEmailObfuscationEditParamsValueOn  SettingEmailObfuscationEditParamsValue = "on"
	SettingEmailObfuscationEditParamsValueOff SettingEmailObfuscationEditParamsValue = "off"
)

func (SettingEmailObfuscationEditParamsValue) IsKnown 

func (r SettingEmailObfuscationEditParamsValue) IsKnown() bool

type SettingEmailObfuscationEditResponseEnvelope 

type SettingEmailObfuscationEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Encrypt email adresses on your web page from bots, while keeping them visible to
	// humans. (https://support.cloudflare.com/hc/en-us/articles/200170016).
	Result EmailObfuscation                                `json:"result"`
	JSON   settingEmailObfuscationEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingEmailObfuscationEditResponseEnvelope) UnmarshalJSON 

func (r *SettingEmailObfuscationEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingEmailObfuscationGetParams 

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

type SettingEmailObfuscationGetResponseEnvelope 

type SettingEmailObfuscationGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Encrypt email adresses on your web page from bots, while keeping them visible to
	// humans. (https://support.cloudflare.com/hc/en-us/articles/200170016).
	Result EmailObfuscation                               `json:"result"`
	JSON   settingEmailObfuscationGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingEmailObfuscationGetResponseEnvelope) UnmarshalJSON 

func (r *SettingEmailObfuscationGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingEmailObfuscationService 

type SettingEmailObfuscationService struct {
	Options []option.RequestOption
}

SettingEmailObfuscationService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingEmailObfuscationService method instead.

func NewSettingEmailObfuscationService 

func NewSettingEmailObfuscationService(opts ...option.RequestOption) (r *SettingEmailObfuscationService)

NewSettingEmailObfuscationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingEmailObfuscationService) Edit 

func (r *SettingEmailObfuscationService) Edit(ctx context.Context, params SettingEmailObfuscationEditParams, opts ...option.RequestOption) (res *EmailObfuscation, err error)

Encrypt email adresses on your web page from bots, while keeping them visible to humans. (https://support.cloudflare.com/hc/en-us/articles/200170016).

func (*SettingEmailObfuscationService) Get 

func (r *SettingEmailObfuscationService) Get(ctx context.Context, query SettingEmailObfuscationGetParams, opts ...option.RequestOption) (res *EmailObfuscation, err error)

Encrypt email adresses on your web page from bots, while keeping them visible to humans. (https://support.cloudflare.com/hc/en-us/articles/200170016).

type SettingFontSettingEditParams 

type SettingFontSettingEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Whether the feature is enabled or disabled.
	Value param.Field[SettingFontSettingEditParamsValue] `json:"value,required"`
}

func (SettingFontSettingEditParams) MarshalJSON 

func (r SettingFontSettingEditParams) MarshalJSON() (data []byte, err error)

type SettingFontSettingEditParamsValue 

type SettingFontSettingEditParamsValue string

Whether the feature is enabled or disabled. 

const (
	SettingFontSettingEditParamsValueOn  SettingFontSettingEditParamsValue = "on"
	SettingFontSettingEditParamsValueOff SettingFontSettingEditParamsValue = "off"
)

func (SettingFontSettingEditParamsValue) IsKnown 

func (r SettingFontSettingEditParamsValue) IsKnown() bool

type SettingFontSettingEditResponseEnvelope 

type SettingFontSettingEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enhance your website's font delivery with Cloudflare Fonts. Deliver Google
	// Hosted fonts from your own domain, boost performance, and enhance user privacy.
	// Refer to the Cloudflare Fonts documentation for more information.
	Result FontSettings                               `json:"result"`
	JSON   settingFontSettingEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingFontSettingEditResponseEnvelope) UnmarshalJSON 

func (r *SettingFontSettingEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingFontSettingGetParams 

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

type SettingFontSettingGetResponseEnvelope 

type SettingFontSettingGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enhance your website's font delivery with Cloudflare Fonts. Deliver Google
	// Hosted fonts from your own domain, boost performance, and enhance user privacy.
	// Refer to the Cloudflare Fonts documentation for more information.
	Result FontSettings                              `json:"result"`
	JSON   settingFontSettingGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingFontSettingGetResponseEnvelope) UnmarshalJSON 

func (r *SettingFontSettingGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingFontSettingService 

type SettingFontSettingService struct {
	Options []option.RequestOption
}

SettingFontSettingService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingFontSettingService method instead.

func NewSettingFontSettingService 

func NewSettingFontSettingService(opts ...option.RequestOption) (r *SettingFontSettingService)

NewSettingFontSettingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingFontSettingService) Edit 

func (r *SettingFontSettingService) Edit(ctx context.Context, params SettingFontSettingEditParams, opts ...option.RequestOption) (res *FontSettings, err error)

Enhance your website's font delivery with Cloudflare Fonts. Deliver Google Hosted fonts from your own domain, boost performance, and enhance user privacy. Refer to the Cloudflare Fonts documentation for more information.

func (*SettingFontSettingService) Get 

func (r *SettingFontSettingService) Get(ctx context.Context, query SettingFontSettingGetParams, opts ...option.RequestOption) (res *FontSettings, err error)

Enhance your website's font delivery with Cloudflare Fonts. Deliver Google Hosted fonts from your own domain, boost performance, and enhance user privacy. Refer to the Cloudflare Fonts documentation for more information.

type SettingH2PrioritizationEditParams 

type SettingH2PrioritizationEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// HTTP/2 Edge Prioritization optimises the delivery of resources served through
	// HTTP/2 to improve page load performance. It also supports fine control of
	// content delivery when used in conjunction with Workers.
	Value param.Field[H2PrioritizationParam] `json:"value,required"`
}

func (SettingH2PrioritizationEditParams) MarshalJSON 

func (r SettingH2PrioritizationEditParams) MarshalJSON() (data []byte, err error)

type SettingH2PrioritizationEditResponseEnvelope 

type SettingH2PrioritizationEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// HTTP/2 Edge Prioritization optimises the delivery of resources served through
	// HTTP/2 to improve page load performance. It also supports fine control of
	// content delivery when used in conjunction with Workers.
	Result H2Prioritization                                `json:"result"`
	JSON   settingH2PrioritizationEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingH2PrioritizationEditResponseEnvelope) UnmarshalJSON 

func (r *SettingH2PrioritizationEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingH2PrioritizationGetParams 

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

type SettingH2PrioritizationGetResponseEnvelope 

type SettingH2PrioritizationGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// HTTP/2 Edge Prioritization optimises the delivery of resources served through
	// HTTP/2 to improve page load performance. It also supports fine control of
	// content delivery when used in conjunction with Workers.
	Result H2Prioritization                               `json:"result"`
	JSON   settingH2PrioritizationGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingH2PrioritizationGetResponseEnvelope) UnmarshalJSON 

func (r *SettingH2PrioritizationGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingH2PrioritizationService 

type SettingH2PrioritizationService struct {
	Options []option.RequestOption
}

SettingH2PrioritizationService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingH2PrioritizationService method instead.

func NewSettingH2PrioritizationService 

func NewSettingH2PrioritizationService(opts ...option.RequestOption) (r *SettingH2PrioritizationService)

NewSettingH2PrioritizationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingH2PrioritizationService) Edit 

func (r *SettingH2PrioritizationService) Edit(ctx context.Context, params SettingH2PrioritizationEditParams, opts ...option.RequestOption) (res *H2Prioritization, err error)

Gets HTTP/2 Edge Prioritization setting.

func (*SettingH2PrioritizationService) Get 

func (r *SettingH2PrioritizationService) Get(ctx context.Context, query SettingH2PrioritizationGetParams, opts ...option.RequestOption) (res *H2Prioritization, err error)

Gets HTTP/2 Edge Prioritization setting.

type SettingHTTP2EditParams 

type SettingHTTP2EditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the HTTP2 setting.
	Value param.Field[SettingHTTP2EditParamsValue] `json:"value,required"`
}

func (SettingHTTP2EditParams) MarshalJSON 

func (r SettingHTTP2EditParams) MarshalJSON() (data []byte, err error)

type SettingHTTP2EditParamsValue 

type SettingHTTP2EditParamsValue string

Value of the HTTP2 setting. 

const (
	SettingHTTP2EditParamsValueOn  SettingHTTP2EditParamsValue = "on"
	SettingHTTP2EditParamsValueOff SettingHTTP2EditParamsValue = "off"
)

func (SettingHTTP2EditParamsValue) IsKnown 

func (r SettingHTTP2EditParamsValue) IsKnown() bool

type SettingHTTP2EditResponseEnvelope 

type SettingHTTP2EditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// HTTP2 enabled for this zone.
	Result HTTP2                                `json:"result"`
	JSON   settingHTTP2EditResponseEnvelopeJSON `json:"-"`
}

func (*SettingHTTP2EditResponseEnvelope) UnmarshalJSON 

func (r *SettingHTTP2EditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingHTTP2GetParams 

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

type SettingHTTP2GetResponseEnvelope 

type SettingHTTP2GetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// HTTP2 enabled for this zone.
	Result HTTP2                               `json:"result"`
	JSON   settingHTTP2GetResponseEnvelopeJSON `json:"-"`
}

func (*SettingHTTP2GetResponseEnvelope) UnmarshalJSON 

func (r *SettingHTTP2GetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingHTTP2Service 

type SettingHTTP2Service struct {
	Options []option.RequestOption
}

SettingHTTP2Service contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingHTTP2Service method instead.

func NewSettingHTTP2Service 

func NewSettingHTTP2Service(opts ...option.RequestOption) (r *SettingHTTP2Service)

NewSettingHTTP2Service generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingHTTP2Service) Edit 

func (r *SettingHTTP2Service) Edit(ctx context.Context, params SettingHTTP2EditParams, opts ...option.RequestOption) (res *HTTP2, err error)

Value of the HTTP2 setting.

func (*SettingHTTP2Service) Get 

func (r *SettingHTTP2Service) Get(ctx context.Context, query SettingHTTP2GetParams, opts ...option.RequestOption) (res *HTTP2, err error)

Value of the HTTP2 setting.

type SettingHTTP3EditParams 

type SettingHTTP3EditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the HTTP3 setting.
	Value param.Field[SettingHTTP3EditParamsValue] `json:"value,required"`
}

func (SettingHTTP3EditParams) MarshalJSON 

func (r SettingHTTP3EditParams) MarshalJSON() (data []byte, err error)

type SettingHTTP3EditParamsValue 

type SettingHTTP3EditParamsValue string

Value of the HTTP3 setting. 

const (
	SettingHTTP3EditParamsValueOn  SettingHTTP3EditParamsValue = "on"
	SettingHTTP3EditParamsValueOff SettingHTTP3EditParamsValue = "off"
)

func (SettingHTTP3EditParamsValue) IsKnown 

func (r SettingHTTP3EditParamsValue) IsKnown() bool

type SettingHTTP3EditResponseEnvelope 

type SettingHTTP3EditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// HTTP3 enabled for this zone.
	Result HTTP3                                `json:"result"`
	JSON   settingHTTP3EditResponseEnvelopeJSON `json:"-"`
}

func (*SettingHTTP3EditResponseEnvelope) UnmarshalJSON 

func (r *SettingHTTP3EditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingHTTP3GetParams 

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

type SettingHTTP3GetResponseEnvelope 

type SettingHTTP3GetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// HTTP3 enabled for this zone.
	Result HTTP3                               `json:"result"`
	JSON   settingHTTP3GetResponseEnvelopeJSON `json:"-"`
}

func (*SettingHTTP3GetResponseEnvelope) UnmarshalJSON 

func (r *SettingHTTP3GetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingHTTP3Service 

type SettingHTTP3Service struct {
	Options []option.RequestOption
}

SettingHTTP3Service contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingHTTP3Service method instead.

func NewSettingHTTP3Service 

func NewSettingHTTP3Service(opts ...option.RequestOption) (r *SettingHTTP3Service)

NewSettingHTTP3Service generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingHTTP3Service) Edit 

func (r *SettingHTTP3Service) Edit(ctx context.Context, params SettingHTTP3EditParams, opts ...option.RequestOption) (res *HTTP3, err error)

Value of the HTTP3 setting.

func (*SettingHTTP3Service) Get 

func (r *SettingHTTP3Service) Get(ctx context.Context, query SettingHTTP3GetParams, opts ...option.RequestOption) (res *HTTP3, err error)

Value of the HTTP3 setting.

type SettingHotlinkProtectionEditParams 

type SettingHotlinkProtectionEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingHotlinkProtectionEditParamsValue] `json:"value,required"`
}

func (SettingHotlinkProtectionEditParams) MarshalJSON 

func (r SettingHotlinkProtectionEditParams) MarshalJSON() (data []byte, err error)

type SettingHotlinkProtectionEditParamsValue 

type SettingHotlinkProtectionEditParamsValue string

Value of the zone setting. 

const (
	SettingHotlinkProtectionEditParamsValueOn  SettingHotlinkProtectionEditParamsValue = "on"
	SettingHotlinkProtectionEditParamsValueOff SettingHotlinkProtectionEditParamsValue = "off"
)

func (SettingHotlinkProtectionEditParamsValue) IsKnown 

func (r SettingHotlinkProtectionEditParamsValue) IsKnown() bool

type SettingHotlinkProtectionEditResponseEnvelope 

type SettingHotlinkProtectionEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When enabled, the Hotlink Protection option ensures that other sites cannot suck
	// up your bandwidth by building pages that use images hosted on your site. Anytime
	// a request for an image on your site hits Cloudflare, we check to ensure that
	// it's not another site requesting them. People will still be able to download and
	// view images from your page, but other sites won't be able to steal them for use
	// on their own pages.
	// (https://support.cloudflare.com/hc/en-us/articles/200170026).
	Result HotlinkProtection                                `json:"result"`
	JSON   settingHotlinkProtectionEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingHotlinkProtectionEditResponseEnvelope) UnmarshalJSON 

func (r *SettingHotlinkProtectionEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingHotlinkProtectionGetParams 

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

type SettingHotlinkProtectionGetResponseEnvelope 

type SettingHotlinkProtectionGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When enabled, the Hotlink Protection option ensures that other sites cannot suck
	// up your bandwidth by building pages that use images hosted on your site. Anytime
	// a request for an image on your site hits Cloudflare, we check to ensure that
	// it's not another site requesting them. People will still be able to download and
	// view images from your page, but other sites won't be able to steal them for use
	// on their own pages.
	// (https://support.cloudflare.com/hc/en-us/articles/200170026).
	Result HotlinkProtection                               `json:"result"`
	JSON   settingHotlinkProtectionGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingHotlinkProtectionGetResponseEnvelope) UnmarshalJSON 

func (r *SettingHotlinkProtectionGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingHotlinkProtectionService 

type SettingHotlinkProtectionService struct {
	Options []option.RequestOption
}

SettingHotlinkProtectionService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingHotlinkProtectionService method instead.

func NewSettingHotlinkProtectionService 

func NewSettingHotlinkProtectionService(opts ...option.RequestOption) (r *SettingHotlinkProtectionService)

NewSettingHotlinkProtectionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingHotlinkProtectionService) Edit 

func (r *SettingHotlinkProtectionService) Edit(ctx context.Context, params SettingHotlinkProtectionEditParams, opts ...option.RequestOption) (res *HotlinkProtection, err error)

When enabled, the Hotlink Protection option ensures that other sites cannot suck up your bandwidth by building pages that use images hosted on your site. Anytime a request for an image on your site hits Cloudflare, we check to ensure that it's not another site requesting them. People will still be able to download and view images from your page, but other sites won't be able to steal them for use on their own pages. (https://support.cloudflare.com/hc/en-us/articles/200170026).

func (*SettingHotlinkProtectionService) Get 

func (r *SettingHotlinkProtectionService) Get(ctx context.Context, query SettingHotlinkProtectionGetParams, opts ...option.RequestOption) (res *HotlinkProtection, err error)

When enabled, the Hotlink Protection option ensures that other sites cannot suck up your bandwidth by building pages that use images hosted on your site. Anytime a request for an image on your site hits Cloudflare, we check to ensure that it's not another site requesting them. People will still be able to download and view images from your page, but other sites won't be able to steal them for use on their own pages. (https://support.cloudflare.com/hc/en-us/articles/200170026).

type SettingIPGeolocationEditParams 

type SettingIPGeolocationEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingIPGeolocationEditParamsValue] `json:"value,required"`
}

func (SettingIPGeolocationEditParams) MarshalJSON 

func (r SettingIPGeolocationEditParams) MarshalJSON() (data []byte, err error)

type SettingIPGeolocationEditParamsValue 

type SettingIPGeolocationEditParamsValue string

Value of the zone setting. 

const (
	SettingIPGeolocationEditParamsValueOn  SettingIPGeolocationEditParamsValue = "on"
	SettingIPGeolocationEditParamsValueOff SettingIPGeolocationEditParamsValue = "off"
)

func (SettingIPGeolocationEditParamsValue) IsKnown 

func (r SettingIPGeolocationEditParamsValue) IsKnown() bool

type SettingIPGeolocationEditResponseEnvelope 

type SettingIPGeolocationEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enable IP Geolocation to have Cloudflare geolocate visitors to your website and
	// pass the country code to you.
	// (https://support.cloudflare.com/hc/en-us/articles/200168236).
	Result IPGeolocation                                `json:"result"`
	JSON   settingIPGeolocationEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingIPGeolocationEditResponseEnvelope) UnmarshalJSON 

func (r *SettingIPGeolocationEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingIPGeolocationGetParams 

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

type SettingIPGeolocationGetResponseEnvelope 

type SettingIPGeolocationGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enable IP Geolocation to have Cloudflare geolocate visitors to your website and
	// pass the country code to you.
	// (https://support.cloudflare.com/hc/en-us/articles/200168236).
	Result IPGeolocation                               `json:"result"`
	JSON   settingIPGeolocationGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingIPGeolocationGetResponseEnvelope) UnmarshalJSON 

func (r *SettingIPGeolocationGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingIPGeolocationService 

type SettingIPGeolocationService struct {
	Options []option.RequestOption
}

SettingIPGeolocationService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingIPGeolocationService method instead.

func NewSettingIPGeolocationService 

func NewSettingIPGeolocationService(opts ...option.RequestOption) (r *SettingIPGeolocationService)

NewSettingIPGeolocationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingIPGeolocationService) Edit 

func (r *SettingIPGeolocationService) Edit(ctx context.Context, params SettingIPGeolocationEditParams, opts ...option.RequestOption) (res *IPGeolocation, err error)

Enable IP Geolocation to have Cloudflare geolocate visitors to your website and pass the country code to you. (https://support.cloudflare.com/hc/en-us/articles/200168236).

func (*SettingIPGeolocationService) Get 

func (r *SettingIPGeolocationService) Get(ctx context.Context, query SettingIPGeolocationGetParams, opts ...option.RequestOption) (res *IPGeolocation, err error)

Enable IP Geolocation to have Cloudflare geolocate visitors to your website and pass the country code to you. (https://support.cloudflare.com/hc/en-us/articles/200168236).

type SettingIPV6EditParams 

type SettingIPV6EditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingIPV6EditParamsValue] `json:"value,required"`
}

func (SettingIPV6EditParams) MarshalJSON 

func (r SettingIPV6EditParams) MarshalJSON() (data []byte, err error)

type SettingIPV6EditParamsValue 

type SettingIPV6EditParamsValue string

Value of the zone setting. 

const (
	SettingIPV6EditParamsValueOff SettingIPV6EditParamsValue = "off"
	SettingIPV6EditParamsValueOn  SettingIPV6EditParamsValue = "on"
)

func (SettingIPV6EditParamsValue) IsKnown 

func (r SettingIPV6EditParamsValue) IsKnown() bool

type SettingIPV6EditResponseEnvelope 

type SettingIPV6EditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enable IPv6 on all subdomains that are Cloudflare enabled.
	// (https://support.cloudflare.com/hc/en-us/articles/200168586).
	Result IPV6                                `json:"result"`
	JSON   settingIPV6EditResponseEnvelopeJSON `json:"-"`
}

func (*SettingIPV6EditResponseEnvelope) UnmarshalJSON 

func (r *SettingIPV6EditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingIPV6GetParams 

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

type SettingIPV6GetResponseEnvelope 

type SettingIPV6GetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enable IPv6 on all subdomains that are Cloudflare enabled.
	// (https://support.cloudflare.com/hc/en-us/articles/200168586).
	Result IPV6                               `json:"result"`
	JSON   settingIPV6GetResponseEnvelopeJSON `json:"-"`
}

func (*SettingIPV6GetResponseEnvelope) UnmarshalJSON 

func (r *SettingIPV6GetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingIPV6Service 

type SettingIPV6Service struct {
	Options []option.RequestOption
}

SettingIPV6Service contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingIPV6Service method instead.

func NewSettingIPV6Service 

func NewSettingIPV6Service(opts ...option.RequestOption) (r *SettingIPV6Service)

NewSettingIPV6Service generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingIPV6Service) Edit 

func (r *SettingIPV6Service) Edit(ctx context.Context, params SettingIPV6EditParams, opts ...option.RequestOption) (res *IPV6, err error)

Enable IPv6 on all subdomains that are Cloudflare enabled. (https://support.cloudflare.com/hc/en-us/articles/200168586).

func (*SettingIPV6Service) Get 

func (r *SettingIPV6Service) Get(ctx context.Context, query SettingIPV6GetParams, opts ...option.RequestOption) (res *IPV6, err error)

Enable IPv6 on all subdomains that are Cloudflare enabled. (https://support.cloudflare.com/hc/en-us/articles/200168586).

type SettingImageResizingEditParams 

type SettingImageResizingEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Image Resizing provides on-demand resizing, conversion and optimisation for
	// images served through Cloudflare's network. Refer to the
	// [Image Resizing documentation](https://developers.cloudflare.com/images/) for
	// more information.
	Value param.Field[ImageResizingParam] `json:"value,required"`
}

func (SettingImageResizingEditParams) MarshalJSON 

func (r SettingImageResizingEditParams) MarshalJSON() (data []byte, err error)

type SettingImageResizingEditResponseEnvelope 

type SettingImageResizingEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Image Resizing provides on-demand resizing, conversion and optimisation for
	// images served through Cloudflare's network. Refer to the
	// [Image Resizing documentation](https://developers.cloudflare.com/images/) for
	// more information.
	Result ImageResizing                                `json:"result"`
	JSON   settingImageResizingEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingImageResizingEditResponseEnvelope) UnmarshalJSON 

func (r *SettingImageResizingEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingImageResizingGetParams 

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

type SettingImageResizingGetResponseEnvelope 

type SettingImageResizingGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Image Resizing provides on-demand resizing, conversion and optimisation for
	// images served through Cloudflare's network. Refer to the
	// [Image Resizing documentation](https://developers.cloudflare.com/images/) for
	// more information.
	Result ImageResizing                               `json:"result"`
	JSON   settingImageResizingGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingImageResizingGetResponseEnvelope) UnmarshalJSON 

func (r *SettingImageResizingGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingImageResizingService 

type SettingImageResizingService struct {
	Options []option.RequestOption
}

SettingImageResizingService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingImageResizingService method instead.

func NewSettingImageResizingService 

func NewSettingImageResizingService(opts ...option.RequestOption) (r *SettingImageResizingService)

NewSettingImageResizingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingImageResizingService) Edit 

func (r *SettingImageResizingService) Edit(ctx context.Context, params SettingImageResizingEditParams, opts ...option.RequestOption) (res *ImageResizing, err error)

Image Resizing provides on-demand resizing, conversion and optimisation for images served through Cloudflare's network. Refer to the [Image Resizing documentation](https://developers.cloudflare.com/images/) for more information.

func (*SettingImageResizingService) Get 

func (r *SettingImageResizingService) Get(ctx context.Context, query SettingImageResizingGetParams, opts ...option.RequestOption) (res *ImageResizing, err error)

Image Resizing provides on-demand resizing, conversion and optimisation for images served through Cloudflare's network. Refer to the [Image Resizing documentation](https://developers.cloudflare.com/images/) for more information.

type SettingMinTLSVersionEditParams 

type SettingMinTLSVersionEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingMinTLSVersionEditParamsValue] `json:"value,required"`
}

func (SettingMinTLSVersionEditParams) MarshalJSON 

func (r SettingMinTLSVersionEditParams) MarshalJSON() (data []byte, err error)

type SettingMinTLSVersionEditParamsValue 

type SettingMinTLSVersionEditParamsValue string

Value of the zone setting. 

const (
	SettingMinTLSVersionEditParamsValue1_0 SettingMinTLSVersionEditParamsValue = "1.0"
	SettingMinTLSVersionEditParamsValue1_1 SettingMinTLSVersionEditParamsValue = "1.1"
	SettingMinTLSVersionEditParamsValue1_2 SettingMinTLSVersionEditParamsValue = "1.2"
	SettingMinTLSVersionEditParamsValue1_3 SettingMinTLSVersionEditParamsValue = "1.3"
)

func (SettingMinTLSVersionEditParamsValue) IsKnown 

func (r SettingMinTLSVersionEditParamsValue) IsKnown() bool

type SettingMinTLSVersionEditResponseEnvelope 

type SettingMinTLSVersionEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Only accepts HTTPS requests that use at least the TLS protocol version
	// specified. For example, if TLS 1.1 is selected, TLS 1.0 connections will be
	// rejected, while 1.1, 1.2, and 1.3 (if enabled) will be permitted.
	Result MinTLSVersion                                `json:"result"`
	JSON   settingMinTLSVersionEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingMinTLSVersionEditResponseEnvelope) UnmarshalJSON 

func (r *SettingMinTLSVersionEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingMinTLSVersionGetParams 

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

type SettingMinTLSVersionGetResponseEnvelope 

type SettingMinTLSVersionGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Only accepts HTTPS requests that use at least the TLS protocol version
	// specified. For example, if TLS 1.1 is selected, TLS 1.0 connections will be
	// rejected, while 1.1, 1.2, and 1.3 (if enabled) will be permitted.
	Result MinTLSVersion                               `json:"result"`
	JSON   settingMinTLSVersionGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingMinTLSVersionGetResponseEnvelope) UnmarshalJSON 

func (r *SettingMinTLSVersionGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingMinTLSVersionService 

type SettingMinTLSVersionService struct {
	Options []option.RequestOption
}

SettingMinTLSVersionService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingMinTLSVersionService method instead.

func NewSettingMinTLSVersionService 

func NewSettingMinTLSVersionService(opts ...option.RequestOption) (r *SettingMinTLSVersionService)

NewSettingMinTLSVersionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingMinTLSVersionService) Edit 

func (r *SettingMinTLSVersionService) Edit(ctx context.Context, params SettingMinTLSVersionEditParams, opts ...option.RequestOption) (res *MinTLSVersion, err error)

Changes Minimum TLS Version setting.

func (*SettingMinTLSVersionService) Get 

func (r *SettingMinTLSVersionService) Get(ctx context.Context, query SettingMinTLSVersionGetParams, opts ...option.RequestOption) (res *MinTLSVersion, err error)

Gets Minimum TLS Version setting.

type SettingMinifyEditParams 

type SettingMinifyEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingMinifyEditParamsValue] `json:"value,required"`
}

func (SettingMinifyEditParams) MarshalJSON 

func (r SettingMinifyEditParams) MarshalJSON() (data []byte, err error)

type SettingMinifyEditParamsValue 

type SettingMinifyEditParamsValue struct {
	// Automatically minify all CSS files for your website.
	Css param.Field[SettingMinifyEditParamsValueCss] `json:"css"`
	// Automatically minify all HTML files for your website.
	HTML param.Field[SettingMinifyEditParamsValueHTML] `json:"html"`
	// Automatically minify all JavaScript files for your website.
	JS param.Field[SettingMinifyEditParamsValueJS] `json:"js"`
}

Value of the zone setting.

func (SettingMinifyEditParamsValue) MarshalJSON 

func (r SettingMinifyEditParamsValue) MarshalJSON() (data []byte, err error)

type SettingMinifyEditParamsValueCss 

type SettingMinifyEditParamsValueCss string

Automatically minify all CSS files for your website. 

const (
	SettingMinifyEditParamsValueCssOn  SettingMinifyEditParamsValueCss = "on"
	SettingMinifyEditParamsValueCssOff SettingMinifyEditParamsValueCss = "off"
)

func (SettingMinifyEditParamsValueCss) IsKnown 

func (r SettingMinifyEditParamsValueCss) IsKnown() bool

type SettingMinifyEditParamsValueHTML 

type SettingMinifyEditParamsValueHTML string

Automatically minify all HTML files for your website. 

const (
	SettingMinifyEditParamsValueHTMLOn  SettingMinifyEditParamsValueHTML = "on"
	SettingMinifyEditParamsValueHTMLOff SettingMinifyEditParamsValueHTML = "off"
)

func (SettingMinifyEditParamsValueHTML) IsKnown 

func (r SettingMinifyEditParamsValueHTML) IsKnown() bool

type SettingMinifyEditParamsValueJS 

type SettingMinifyEditParamsValueJS string

Automatically minify all JavaScript files for your website. 

const (
	SettingMinifyEditParamsValueJSOn  SettingMinifyEditParamsValueJS = "on"
	SettingMinifyEditParamsValueJSOff SettingMinifyEditParamsValueJS = "off"
)

func (SettingMinifyEditParamsValueJS) IsKnown 

func (r SettingMinifyEditParamsValueJS) IsKnown() bool

type SettingMinifyEditResponseEnvelope 

type SettingMinifyEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Automatically minify certain assets for your website. Refer to
	// [Using Cloudflare Auto Minify](https://support.cloudflare.com/hc/en-us/articles/200168196)
	// for more information.
	Result Minify                                `json:"result"`
	JSON   settingMinifyEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingMinifyEditResponseEnvelope) UnmarshalJSON 

func (r *SettingMinifyEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingMinifyGetParams 

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

type SettingMinifyGetResponseEnvelope 

type SettingMinifyGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Automatically minify certain assets for your website. Refer to
	// [Using Cloudflare Auto Minify](https://support.cloudflare.com/hc/en-us/articles/200168196)
	// for more information.
	Result Minify                               `json:"result"`
	JSON   settingMinifyGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingMinifyGetResponseEnvelope) UnmarshalJSON 

func (r *SettingMinifyGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingMinifyService 

type SettingMinifyService struct {
	Options []option.RequestOption
}

SettingMinifyService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingMinifyService method instead.

func NewSettingMinifyService 

func NewSettingMinifyService(opts ...option.RequestOption) (r *SettingMinifyService)

NewSettingMinifyService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingMinifyService) Edit 

func (r *SettingMinifyService) Edit(ctx context.Context, params SettingMinifyEditParams, opts ...option.RequestOption) (res *Minify, err error)

Automatically minify certain assets for your website. Refer to [Using Cloudflare Auto Minify](https://support.cloudflare.com/hc/en-us/articles/200168196) for more information.

func (*SettingMinifyService) Get 

func (r *SettingMinifyService) Get(ctx context.Context, query SettingMinifyGetParams, opts ...option.RequestOption) (res *Minify, err error)

Automatically minify certain assets for your website. Refer to [Using Cloudflare Auto Minify](https://support.cloudflare.com/hc/en-us/articles/200168196) for more information.

type SettingMirageEditParams 

type SettingMirageEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingMirageEditParamsValue] `json:"value,required"`
}

func (SettingMirageEditParams) MarshalJSON 

func (r SettingMirageEditParams) MarshalJSON() (data []byte, err error)

type SettingMirageEditParamsValue 

type SettingMirageEditParamsValue string

Value of the zone setting. 

const (
	SettingMirageEditParamsValueOn  SettingMirageEditParamsValue = "on"
	SettingMirageEditParamsValueOff SettingMirageEditParamsValue = "off"
)

func (SettingMirageEditParamsValue) IsKnown 

func (r SettingMirageEditParamsValue) IsKnown() bool

type SettingMirageEditResponseEnvelope 

type SettingMirageEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Automatically optimize image loading for website visitors on mobile devices.
	// Refer to
	// [our blog post](http://blog.cloudflare.com/mirage2-solving-mobile-speed) for
	// more information.
	Result Mirage                                `json:"result"`
	JSON   settingMirageEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingMirageEditResponseEnvelope) UnmarshalJSON 

func (r *SettingMirageEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingMirageGetParams 

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

type SettingMirageGetResponseEnvelope 

type SettingMirageGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Automatically optimize image loading for website visitors on mobile devices.
	// Refer to
	// [our blog post](http://blog.cloudflare.com/mirage2-solving-mobile-speed) for
	// more information.
	Result Mirage                               `json:"result"`
	JSON   settingMirageGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingMirageGetResponseEnvelope) UnmarshalJSON 

func (r *SettingMirageGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingMirageService 

type SettingMirageService struct {
	Options []option.RequestOption
}

SettingMirageService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingMirageService method instead.

func NewSettingMirageService 

func NewSettingMirageService(opts ...option.RequestOption) (r *SettingMirageService)

NewSettingMirageService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingMirageService) Edit 

func (r *SettingMirageService) Edit(ctx context.Context, params SettingMirageEditParams, opts ...option.RequestOption) (res *Mirage, err error)

Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/mirage2-solving-mobile-speed) for more information.

func (*SettingMirageService) Get 

func (r *SettingMirageService) Get(ctx context.Context, query SettingMirageGetParams, opts ...option.RequestOption) (res *Mirage, err error)

Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/mirage2-solving-mobile-speed) for more information.

type SettingMobileRedirectEditParams 

type SettingMobileRedirectEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingMobileRedirectEditParamsValue] `json:"value,required"`
}

func (SettingMobileRedirectEditParams) MarshalJSON 

func (r SettingMobileRedirectEditParams) MarshalJSON() (data []byte, err error)

type SettingMobileRedirectEditParamsValue 

type SettingMobileRedirectEditParamsValue struct {
	// Which subdomain prefix you wish to redirect visitors on mobile devices to
	// (subdomain must already exist).
	MobileSubdomain param.Field[string] `json:"mobile_subdomain"`
	// Whether or not mobile redirect is enabled.
	Status param.Field[SettingMobileRedirectEditParamsValueStatus] `json:"status"`
	// Whether to drop the current page path and redirect to the mobile subdomain URL
	// root, or keep the path and redirect to the same page on the mobile subdomain.
	StripURI param.Field[bool] `json:"strip_uri"`
}

Value of the zone setting.

func (SettingMobileRedirectEditParamsValue) MarshalJSON 

func (r SettingMobileRedirectEditParamsValue) MarshalJSON() (data []byte, err error)

type SettingMobileRedirectEditParamsValueStatus 

type SettingMobileRedirectEditParamsValueStatus string

Whether or not mobile redirect is enabled. 

const (
	SettingMobileRedirectEditParamsValueStatusOn  SettingMobileRedirectEditParamsValueStatus = "on"
	SettingMobileRedirectEditParamsValueStatusOff SettingMobileRedirectEditParamsValueStatus = "off"
)

func (SettingMobileRedirectEditParamsValueStatus) IsKnown 

func (r SettingMobileRedirectEditParamsValueStatus) IsKnown() bool

type SettingMobileRedirectEditResponseEnvelope 

type SettingMobileRedirectEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Automatically redirect visitors on mobile devices to a mobile-optimized
	// subdomain. Refer to
	// [Understanding Cloudflare Mobile Redirect](https://support.cloudflare.com/hc/articles/200168336)
	// for more information.
	Result MobileRedirect                                `json:"result"`
	JSON   settingMobileRedirectEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingMobileRedirectEditResponseEnvelope) UnmarshalJSON 

func (r *SettingMobileRedirectEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingMobileRedirectGetParams 

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

type SettingMobileRedirectGetResponseEnvelope 

type SettingMobileRedirectGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Automatically redirect visitors on mobile devices to a mobile-optimized
	// subdomain. Refer to
	// [Understanding Cloudflare Mobile Redirect](https://support.cloudflare.com/hc/articles/200168336)
	// for more information.
	Result MobileRedirect                               `json:"result"`
	JSON   settingMobileRedirectGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingMobileRedirectGetResponseEnvelope) UnmarshalJSON 

func (r *SettingMobileRedirectGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingMobileRedirectService 

type SettingMobileRedirectService struct {
	Options []option.RequestOption
}

SettingMobileRedirectService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingMobileRedirectService method instead.

func NewSettingMobileRedirectService 

func NewSettingMobileRedirectService(opts ...option.RequestOption) (r *SettingMobileRedirectService)

NewSettingMobileRedirectService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingMobileRedirectService) Edit 

func (r *SettingMobileRedirectService) Edit(ctx context.Context, params SettingMobileRedirectEditParams, opts ...option.RequestOption) (res *MobileRedirect, err error)

Automatically redirect visitors on mobile devices to a mobile-optimized subdomain. Refer to [Understanding Cloudflare Mobile Redirect](https://support.cloudflare.com/hc/articles/200168336) for more information.

func (*SettingMobileRedirectService) Get 

func (r *SettingMobileRedirectService) Get(ctx context.Context, query SettingMobileRedirectGetParams, opts ...option.RequestOption) (res *MobileRedirect, err error)

Automatically redirect visitors on mobile devices to a mobile-optimized subdomain. Refer to [Understanding Cloudflare Mobile Redirect](https://support.cloudflare.com/hc/articles/200168336) for more information.

type SettingNELEditParams 

type SettingNELEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Enable Network Error Logging reporting on your zone. (Beta)
	Value param.Field[NELParam] `json:"value,required"`
}

func (SettingNELEditParams) MarshalJSON 

func (r SettingNELEditParams) MarshalJSON() (data []byte, err error)

type SettingNELEditResponseEnvelope 

type SettingNELEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enable Network Error Logging reporting on your zone. (Beta)
	Result NEL                                `json:"result"`
	JSON   settingNELEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingNELEditResponseEnvelope) UnmarshalJSON 

func (r *SettingNELEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingNELGetParams 

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

type SettingNELGetResponseEnvelope 

type SettingNELGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enable Network Error Logging reporting on your zone. (Beta)
	Result NEL                               `json:"result"`
	JSON   settingNELGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingNELGetResponseEnvelope) UnmarshalJSON 

func (r *SettingNELGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingNELService 

type SettingNELService struct {
	Options []option.RequestOption
}

SettingNELService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingNELService method instead.

func NewSettingNELService 

func NewSettingNELService(opts ...option.RequestOption) (r *SettingNELService)

NewSettingNELService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingNELService) Edit 

func (r *SettingNELService) Edit(ctx context.Context, params SettingNELEditParams, opts ...option.RequestOption) (res *NEL, err error)

Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/nel-solving-mobile-speed) for more information.

func (*SettingNELService) Get 

func (r *SettingNELService) Get(ctx context.Context, query SettingNELGetParams, opts ...option.RequestOption) (res *NEL, err error)

Enable Network Error Logging reporting on your zone. (Beta)

type SettingOpportunisticEncryptionEditParams 

type SettingOpportunisticEncryptionEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting. Notes: Default value depends on the zone's plan
	// level.
	Value param.Field[SettingOpportunisticEncryptionEditParamsValue] `json:"value,required"`
}

func (SettingOpportunisticEncryptionEditParams) MarshalJSON 

func (r SettingOpportunisticEncryptionEditParams) MarshalJSON() (data []byte, err error)

type SettingOpportunisticEncryptionEditParamsValue 

type SettingOpportunisticEncryptionEditParamsValue string

Value of the zone setting. Notes: Default value depends on the zone's plan level. 

const (
	SettingOpportunisticEncryptionEditParamsValueOn  SettingOpportunisticEncryptionEditParamsValue = "on"
	SettingOpportunisticEncryptionEditParamsValueOff SettingOpportunisticEncryptionEditParamsValue = "off"
)

func (SettingOpportunisticEncryptionEditParamsValue) IsKnown 

func (r SettingOpportunisticEncryptionEditParamsValue) IsKnown() bool

type SettingOpportunisticEncryptionEditResponseEnvelope 

type SettingOpportunisticEncryptionEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enables the Opportunistic Encryption feature for a zone.
	Result OpportunisticEncryption                                `json:"result"`
	JSON   settingOpportunisticEncryptionEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingOpportunisticEncryptionEditResponseEnvelope) UnmarshalJSON 

func (r *SettingOpportunisticEncryptionEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOpportunisticEncryptionGetParams 

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

type SettingOpportunisticEncryptionGetResponseEnvelope 

type SettingOpportunisticEncryptionGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enables the Opportunistic Encryption feature for a zone.
	Result OpportunisticEncryption                               `json:"result"`
	JSON   settingOpportunisticEncryptionGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingOpportunisticEncryptionGetResponseEnvelope) UnmarshalJSON 

func (r *SettingOpportunisticEncryptionGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOpportunisticEncryptionService 

type SettingOpportunisticEncryptionService struct {
	Options []option.RequestOption
}

SettingOpportunisticEncryptionService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingOpportunisticEncryptionService method instead.

func NewSettingOpportunisticEncryptionService 

func NewSettingOpportunisticEncryptionService(opts ...option.RequestOption) (r *SettingOpportunisticEncryptionService)

NewSettingOpportunisticEncryptionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingOpportunisticEncryptionService) Edit 

func (r *SettingOpportunisticEncryptionService) Edit(ctx context.Context, params SettingOpportunisticEncryptionEditParams, opts ...option.RequestOption) (res *OpportunisticEncryption, err error)

Changes Opportunistic Encryption setting.

func (*SettingOpportunisticEncryptionService) Get 

func (r *SettingOpportunisticEncryptionService) Get(ctx context.Context, query SettingOpportunisticEncryptionGetParams, opts ...option.RequestOption) (res *OpportunisticEncryption, err error)

Gets Opportunistic Encryption setting.

type SettingOpportunisticOnionEditParams 

type SettingOpportunisticOnionEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting. Notes: Default value depends on the zone's plan
	// level.
	Value param.Field[SettingOpportunisticOnionEditParamsValue] `json:"value,required"`
}

func (SettingOpportunisticOnionEditParams) MarshalJSON 

func (r SettingOpportunisticOnionEditParams) MarshalJSON() (data []byte, err error)

type SettingOpportunisticOnionEditParamsValue 

type SettingOpportunisticOnionEditParamsValue string

Value of the zone setting. Notes: Default value depends on the zone's plan level. 

const (
	SettingOpportunisticOnionEditParamsValueOn  SettingOpportunisticOnionEditParamsValue = "on"
	SettingOpportunisticOnionEditParamsValueOff SettingOpportunisticOnionEditParamsValue = "off"
)

func (SettingOpportunisticOnionEditParamsValue) IsKnown 

func (r SettingOpportunisticOnionEditParamsValue) IsKnown() bool

type SettingOpportunisticOnionEditResponseEnvelope 

type SettingOpportunisticOnionEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Add an Alt-Svc header to all legitimate requests from Tor, allowing the
	// connection to use our onion services instead of exit nodes.
	Result OpportunisticOnion                                `json:"result"`
	JSON   settingOpportunisticOnionEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingOpportunisticOnionEditResponseEnvelope) UnmarshalJSON 

func (r *SettingOpportunisticOnionEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOpportunisticOnionGetParams 

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

type SettingOpportunisticOnionGetResponseEnvelope 

type SettingOpportunisticOnionGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Add an Alt-Svc header to all legitimate requests from Tor, allowing the
	// connection to use our onion services instead of exit nodes.
	Result OpportunisticOnion                               `json:"result"`
	JSON   settingOpportunisticOnionGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingOpportunisticOnionGetResponseEnvelope) UnmarshalJSON 

func (r *SettingOpportunisticOnionGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOpportunisticOnionService 

type SettingOpportunisticOnionService struct {
	Options []option.RequestOption
}

SettingOpportunisticOnionService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingOpportunisticOnionService method instead.

func NewSettingOpportunisticOnionService 

func NewSettingOpportunisticOnionService(opts ...option.RequestOption) (r *SettingOpportunisticOnionService)

NewSettingOpportunisticOnionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingOpportunisticOnionService) Edit 

func (r *SettingOpportunisticOnionService) Edit(ctx context.Context, params SettingOpportunisticOnionEditParams, opts ...option.RequestOption) (res *OpportunisticOnion, err error)

Add an Alt-Svc header to all legitimate requests from Tor, allowing the connection to use our onion services instead of exit nodes.

func (*SettingOpportunisticOnionService) Get 

func (r *SettingOpportunisticOnionService) Get(ctx context.Context, query SettingOpportunisticOnionGetParams, opts ...option.RequestOption) (res *OpportunisticOnion, err error)

Add an Alt-Svc header to all legitimate requests from Tor, allowing the connection to use our onion services instead of exit nodes.

type SettingOrangeToOrangeEditParams 

type SettingOrangeToOrangeEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also
	// on Cloudflare.
	Value param.Field[OrangeToOrangeParam] `json:"value,required"`
}

func (SettingOrangeToOrangeEditParams) MarshalJSON 

func (r SettingOrangeToOrangeEditParams) MarshalJSON() (data []byte, err error)

type SettingOrangeToOrangeEditResponseEnvelope 

type SettingOrangeToOrangeEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also
	// on Cloudflare.
	Result OrangeToOrange                                `json:"result"`
	JSON   settingOrangeToOrangeEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingOrangeToOrangeEditResponseEnvelope) UnmarshalJSON 

func (r *SettingOrangeToOrangeEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOrangeToOrangeGetParams 

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

type SettingOrangeToOrangeGetResponseEnvelope 

type SettingOrangeToOrangeGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also
	// on Cloudflare.
	Result OrangeToOrange                               `json:"result"`
	JSON   settingOrangeToOrangeGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingOrangeToOrangeGetResponseEnvelope) UnmarshalJSON 

func (r *SettingOrangeToOrangeGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOrangeToOrangeService 

type SettingOrangeToOrangeService struct {
	Options []option.RequestOption
}

SettingOrangeToOrangeService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingOrangeToOrangeService method instead.

func NewSettingOrangeToOrangeService 

func NewSettingOrangeToOrangeService(opts ...option.RequestOption) (r *SettingOrangeToOrangeService)

NewSettingOrangeToOrangeService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingOrangeToOrangeService) Edit 

func (r *SettingOrangeToOrangeService) Edit(ctx context.Context, params SettingOrangeToOrangeEditParams, opts ...option.RequestOption) (res *OrangeToOrange, err error)

Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also on Cloudflare.

func (*SettingOrangeToOrangeService) Get 

func (r *SettingOrangeToOrangeService) Get(ctx context.Context, query SettingOrangeToOrangeGetParams, opts ...option.RequestOption) (res *OrangeToOrange, err error)

Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also on Cloudflare.

type SettingOriginErrorPagePassThruEditParams 

type SettingOriginErrorPagePassThruEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingOriginErrorPagePassThruEditParamsValue] `json:"value,required"`
}

func (SettingOriginErrorPagePassThruEditParams) MarshalJSON 

func (r SettingOriginErrorPagePassThruEditParams) MarshalJSON() (data []byte, err error)

type SettingOriginErrorPagePassThruEditParamsValue 

type SettingOriginErrorPagePassThruEditParamsValue string

Value of the zone setting. 

const (
	SettingOriginErrorPagePassThruEditParamsValueOn  SettingOriginErrorPagePassThruEditParamsValue = "on"
	SettingOriginErrorPagePassThruEditParamsValueOff SettingOriginErrorPagePassThruEditParamsValue = "off"
)

func (SettingOriginErrorPagePassThruEditParamsValue) IsKnown 

func (r SettingOriginErrorPagePassThruEditParamsValue) IsKnown() bool

type SettingOriginErrorPagePassThruEditResponseEnvelope 

type SettingOriginErrorPagePassThruEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cloudflare will proxy customer error pages on any 502,504 errors on origin
	// server instead of showing a default Cloudflare error page. This does not apply
	// to 522 errors and is limited to Enterprise Zones.
	Result OriginErrorPagePassThru                                `json:"result"`
	JSON   settingOriginErrorPagePassThruEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingOriginErrorPagePassThruEditResponseEnvelope) UnmarshalJSON 

func (r *SettingOriginErrorPagePassThruEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOriginErrorPagePassThruGetParams 

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

type SettingOriginErrorPagePassThruGetResponseEnvelope 

type SettingOriginErrorPagePassThruGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cloudflare will proxy customer error pages on any 502,504 errors on origin
	// server instead of showing a default Cloudflare error page. This does not apply
	// to 522 errors and is limited to Enterprise Zones.
	Result OriginErrorPagePassThru                               `json:"result"`
	JSON   settingOriginErrorPagePassThruGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingOriginErrorPagePassThruGetResponseEnvelope) UnmarshalJSON 

func (r *SettingOriginErrorPagePassThruGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOriginErrorPagePassThruService 

type SettingOriginErrorPagePassThruService struct {
	Options []option.RequestOption
}

SettingOriginErrorPagePassThruService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingOriginErrorPagePassThruService method instead.

func NewSettingOriginErrorPagePassThruService 

func NewSettingOriginErrorPagePassThruService(opts ...option.RequestOption) (r *SettingOriginErrorPagePassThruService)

NewSettingOriginErrorPagePassThruService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingOriginErrorPagePassThruService) Edit 

func (r *SettingOriginErrorPagePassThruService) Edit(ctx context.Context, params SettingOriginErrorPagePassThruEditParams, opts ...option.RequestOption) (res *OriginErrorPagePassThru, err error)

Cloudflare will proxy customer error pages on any 502,504 errors on origin server instead of showing a default Cloudflare error page. This does not apply to 522 errors and is limited to Enterprise Zones.

func (*SettingOriginErrorPagePassThruService) Get 

func (r *SettingOriginErrorPagePassThruService) Get(ctx context.Context, query SettingOriginErrorPagePassThruGetParams, opts ...option.RequestOption) (res *OriginErrorPagePassThru, err error)

Cloudflare will proxy customer error pages on any 502,504 errors on origin server instead of showing a default Cloudflare error page. This does not apply to 522 errors and is limited to Enterprise Zones.

type SettingOriginMaxHTTPVersionEditParams 

type SettingOriginMaxHTTPVersionEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the Origin Max HTTP Version Setting.
	Value param.Field[SettingOriginMaxHTTPVersionEditParamsValue] `json:"value,required"`
}

func (SettingOriginMaxHTTPVersionEditParams) MarshalJSON 

func (r SettingOriginMaxHTTPVersionEditParams) MarshalJSON() (data []byte, err error)

type SettingOriginMaxHTTPVersionEditParamsValue 

type SettingOriginMaxHTTPVersionEditParamsValue string

Value of the Origin Max HTTP Version Setting. 

const (
	SettingOriginMaxHTTPVersionEditParamsValue2 SettingOriginMaxHTTPVersionEditParamsValue = "2"
	SettingOriginMaxHTTPVersionEditParamsValue1 SettingOriginMaxHTTPVersionEditParamsValue = "1"
)

func (SettingOriginMaxHTTPVersionEditParamsValue) IsKnown 

func (r SettingOriginMaxHTTPVersionEditParamsValue) IsKnown() bool

type SettingOriginMaxHTTPVersionEditResponse 

type SettingOriginMaxHTTPVersionEditResponse struct {
	// Value of the zone setting.
	ID OriginMaxHTTPVersion `json:"id,required"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,required,nullable" format:"date-time"`
	// Value of the Origin Max HTTP Version Setting.
	Value SettingOriginMaxHTTPVersionEditResponseValue `json:"value,required"`
	JSON  settingOriginMaxHTTPVersionEditResponseJSON  `json:"-"`
}

Origin Max HTTP Setting Version sets the highest HTTP version Cloudflare will attempt to use with your origin. This setting allows Cloudflare to make HTTP/2 requests to your origin. (Refer to [Enable HTTP/2 to Origin](https://developers.cloudflare.com/cache/how-to/enable-http2-to-origin/), for more information.). The default value is "2" for all plan types except ENT where it is "1"

func (*SettingOriginMaxHTTPVersionEditResponse) UnmarshalJSON 

func (r *SettingOriginMaxHTTPVersionEditResponse) UnmarshalJSON(data []byte) (err error)

type SettingOriginMaxHTTPVersionEditResponseEnvelope 

type SettingOriginMaxHTTPVersionEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Origin Max HTTP Setting Version sets the highest HTTP version Cloudflare will
	// attempt to use with your origin. This setting allows Cloudflare to make HTTP/2
	// requests to your origin. (Refer to
	// [Enable HTTP/2 to Origin](https://developers.cloudflare.com/cache/how-to/enable-http2-to-origin/),
	// for more information.). The default value is "2" for all plan types except ENT
	// where it is "1"
	Result SettingOriginMaxHTTPVersionEditResponse `json:"result,required"`
	// Whether the API call was successful
	Success SettingOriginMaxHTTPVersionEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingOriginMaxHTTPVersionEditResponseEnvelopeJSON    `json:"-"`
}

func (*SettingOriginMaxHTTPVersionEditResponseEnvelope) UnmarshalJSON 

func (r *SettingOriginMaxHTTPVersionEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOriginMaxHTTPVersionEditResponseEnvelopeSuccess 

type SettingOriginMaxHTTPVersionEditResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	SettingOriginMaxHTTPVersionEditResponseEnvelopeSuccessTrue SettingOriginMaxHTTPVersionEditResponseEnvelopeSuccess = true
)

func (SettingOriginMaxHTTPVersionEditResponseEnvelopeSuccess) IsKnown 

func (r SettingOriginMaxHTTPVersionEditResponseEnvelopeSuccess) IsKnown() bool

type SettingOriginMaxHTTPVersionEditResponseValue 

type SettingOriginMaxHTTPVersionEditResponseValue string

Value of the Origin Max HTTP Version Setting. 

const (
	SettingOriginMaxHTTPVersionEditResponseValue2 SettingOriginMaxHTTPVersionEditResponseValue = "2"
	SettingOriginMaxHTTPVersionEditResponseValue1 SettingOriginMaxHTTPVersionEditResponseValue = "1"
)

func (SettingOriginMaxHTTPVersionEditResponseValue) IsKnown 

func (r SettingOriginMaxHTTPVersionEditResponseValue) IsKnown() bool

type SettingOriginMaxHTTPVersionGetParams 

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

type SettingOriginMaxHTTPVersionGetResponse 

type SettingOriginMaxHTTPVersionGetResponse struct {
	// Value of the zone setting.
	ID OriginMaxHTTPVersion `json:"id,required"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,required,nullable" format:"date-time"`
	// Value of the Origin Max HTTP Version Setting.
	Value SettingOriginMaxHTTPVersionGetResponseValue `json:"value,required"`
	JSON  settingOriginMaxHTTPVersionGetResponseJSON  `json:"-"`
}

Origin Max HTTP Setting Version sets the highest HTTP version Cloudflare will attempt to use with your origin. This setting allows Cloudflare to make HTTP/2 requests to your origin. (Refer to [Enable HTTP/2 to Origin](https://developers.cloudflare.com/cache/how-to/enable-http2-to-origin/), for more information.). The default value is "2" for all plan types except ENT where it is "1"

func (*SettingOriginMaxHTTPVersionGetResponse) UnmarshalJSON 

func (r *SettingOriginMaxHTTPVersionGetResponse) UnmarshalJSON(data []byte) (err error)

type SettingOriginMaxHTTPVersionGetResponseEnvelope 

type SettingOriginMaxHTTPVersionGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Origin Max HTTP Setting Version sets the highest HTTP version Cloudflare will
	// attempt to use with your origin. This setting allows Cloudflare to make HTTP/2
	// requests to your origin. (Refer to
	// [Enable HTTP/2 to Origin](https://developers.cloudflare.com/cache/how-to/enable-http2-to-origin/),
	// for more information.). The default value is "2" for all plan types except ENT
	// where it is "1"
	Result SettingOriginMaxHTTPVersionGetResponse `json:"result,required"`
	// Whether the API call was successful
	Success SettingOriginMaxHTTPVersionGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingOriginMaxHTTPVersionGetResponseEnvelopeJSON    `json:"-"`
}

func (*SettingOriginMaxHTTPVersionGetResponseEnvelope) UnmarshalJSON 

func (r *SettingOriginMaxHTTPVersionGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingOriginMaxHTTPVersionGetResponseEnvelopeSuccess 

type SettingOriginMaxHTTPVersionGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	SettingOriginMaxHTTPVersionGetResponseEnvelopeSuccessTrue SettingOriginMaxHTTPVersionGetResponseEnvelopeSuccess = true
)

func (SettingOriginMaxHTTPVersionGetResponseEnvelopeSuccess) IsKnown 

func (r SettingOriginMaxHTTPVersionGetResponseEnvelopeSuccess) IsKnown() bool

type SettingOriginMaxHTTPVersionGetResponseValue 

type SettingOriginMaxHTTPVersionGetResponseValue string

Value of the Origin Max HTTP Version Setting. 

const (
	SettingOriginMaxHTTPVersionGetResponseValue2 SettingOriginMaxHTTPVersionGetResponseValue = "2"
	SettingOriginMaxHTTPVersionGetResponseValue1 SettingOriginMaxHTTPVersionGetResponseValue = "1"
)

func (SettingOriginMaxHTTPVersionGetResponseValue) IsKnown 

func (r SettingOriginMaxHTTPVersionGetResponseValue) IsKnown() bool

type SettingOriginMaxHTTPVersionService 

type SettingOriginMaxHTTPVersionService struct {
	Options []option.RequestOption
}

SettingOriginMaxHTTPVersionService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingOriginMaxHTTPVersionService method instead.

func NewSettingOriginMaxHTTPVersionService 

func NewSettingOriginMaxHTTPVersionService(opts ...option.RequestOption) (r *SettingOriginMaxHTTPVersionService)

NewSettingOriginMaxHTTPVersionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingOriginMaxHTTPVersionService) Edit 

func (r *SettingOriginMaxHTTPVersionService) Edit(ctx context.Context, params SettingOriginMaxHTTPVersionEditParams, opts ...option.RequestOption) (res *SettingOriginMaxHTTPVersionEditResponse, err error)

Origin Max HTTP Setting Version sets the highest HTTP version Cloudflare will attempt to use with your origin. This setting allows Cloudflare to make HTTP/2 requests to your origin. (Refer to [Enable HTTP/2 to Origin](https://developers.cloudflare.com/cache/how-to/enable-http2-to-origin/), for more information.). The default value is "2" for all plan types except ENT where it is "1"

func (*SettingOriginMaxHTTPVersionService) Get 

func (r *SettingOriginMaxHTTPVersionService) Get(ctx context.Context, query SettingOriginMaxHTTPVersionGetParams, opts ...option.RequestOption) (res *SettingOriginMaxHTTPVersionGetResponse, err error)

Origin Max HTTP Setting Version sets the highest HTTP version Cloudflare will attempt to use with your origin. This setting allows Cloudflare to make HTTP/2 requests to your origin. (Refer to [Enable HTTP/2 to Origin](https://developers.cloudflare.com/cache/how-to/enable-http2-to-origin/), for more information.). The default value is "2" for all plan types except ENT where it is "1"

type SettingPolishEditParams 

type SettingPolishEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Removes metadata and compresses your images for faster page load times. Basic
	// (Lossless): Reduce the size of PNG, JPEG, and GIF files - no impact on visual
	// quality. Basic + JPEG (Lossy): Further reduce the size of JPEG files for faster
	// image loading. Larger JPEGs are converted to progressive images, loading a
	// lower-resolution image first and ending in a higher-resolution version. Not
	// recommended for hi-res photography sites.
	Value param.Field[PolishParam] `json:"value,required"`
}

func (SettingPolishEditParams) MarshalJSON 

func (r SettingPolishEditParams) MarshalJSON() (data []byte, err error)

type SettingPolishEditResponseEnvelope 

type SettingPolishEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Removes metadata and compresses your images for faster page load times. Basic
	// (Lossless): Reduce the size of PNG, JPEG, and GIF files - no impact on visual
	// quality. Basic + JPEG (Lossy): Further reduce the size of JPEG files for faster
	// image loading. Larger JPEGs are converted to progressive images, loading a
	// lower-resolution image first and ending in a higher-resolution version. Not
	// recommended for hi-res photography sites.
	Result Polish                                `json:"result"`
	JSON   settingPolishEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingPolishEditResponseEnvelope) UnmarshalJSON 

func (r *SettingPolishEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingPolishGetParams 

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

type SettingPolishGetResponseEnvelope 

type SettingPolishGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Removes metadata and compresses your images for faster page load times. Basic
	// (Lossless): Reduce the size of PNG, JPEG, and GIF files - no impact on visual
	// quality. Basic + JPEG (Lossy): Further reduce the size of JPEG files for faster
	// image loading. Larger JPEGs are converted to progressive images, loading a
	// lower-resolution image first and ending in a higher-resolution version. Not
	// recommended for hi-res photography sites.
	Result Polish                               `json:"result"`
	JSON   settingPolishGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingPolishGetResponseEnvelope) UnmarshalJSON 

func (r *SettingPolishGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingPolishService 

type SettingPolishService struct {
	Options []option.RequestOption
}

SettingPolishService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingPolishService method instead.

func NewSettingPolishService 

func NewSettingPolishService(opts ...option.RequestOption) (r *SettingPolishService)

NewSettingPolishService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingPolishService) Edit 

func (r *SettingPolishService) Edit(ctx context.Context, params SettingPolishEditParams, opts ...option.RequestOption) (res *Polish, err error)

Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/polish-solving-mobile-speed) for more information.

func (*SettingPolishService) Get 

func (r *SettingPolishService) Get(ctx context.Context, query SettingPolishGetParams, opts ...option.RequestOption) (res *Polish, err error)

Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/polish-solving-mobile-speed) for more information.

type SettingPrefetchPreloadEditParams 

type SettingPrefetchPreloadEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingPrefetchPreloadEditParamsValue] `json:"value,required"`
}

func (SettingPrefetchPreloadEditParams) MarshalJSON 

func (r SettingPrefetchPreloadEditParams) MarshalJSON() (data []byte, err error)

type SettingPrefetchPreloadEditParamsValue 

type SettingPrefetchPreloadEditParamsValue string

Value of the zone setting. 

const (
	SettingPrefetchPreloadEditParamsValueOn  SettingPrefetchPreloadEditParamsValue = "on"
	SettingPrefetchPreloadEditParamsValueOff SettingPrefetchPreloadEditParamsValue = "off"
)

func (SettingPrefetchPreloadEditParamsValue) IsKnown 

func (r SettingPrefetchPreloadEditParamsValue) IsKnown() bool

type SettingPrefetchPreloadEditResponseEnvelope 

type SettingPrefetchPreloadEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cloudflare will prefetch any URLs that are included in the response headers.
	// This is limited to Enterprise Zones.
	Result PrefetchPreload                                `json:"result"`
	JSON   settingPrefetchPreloadEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingPrefetchPreloadEditResponseEnvelope) UnmarshalJSON 

func (r *SettingPrefetchPreloadEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingPrefetchPreloadGetParams 

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

type SettingPrefetchPreloadGetResponseEnvelope 

type SettingPrefetchPreloadGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cloudflare will prefetch any URLs that are included in the response headers.
	// This is limited to Enterprise Zones.
	Result PrefetchPreload                               `json:"result"`
	JSON   settingPrefetchPreloadGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingPrefetchPreloadGetResponseEnvelope) UnmarshalJSON 

func (r *SettingPrefetchPreloadGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingPrefetchPreloadService 

type SettingPrefetchPreloadService struct {
	Options []option.RequestOption
}

SettingPrefetchPreloadService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingPrefetchPreloadService method instead.

func NewSettingPrefetchPreloadService 

func NewSettingPrefetchPreloadService(opts ...option.RequestOption) (r *SettingPrefetchPreloadService)

NewSettingPrefetchPreloadService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingPrefetchPreloadService) Edit 

func (r *SettingPrefetchPreloadService) Edit(ctx context.Context, params SettingPrefetchPreloadEditParams, opts ...option.RequestOption) (res *PrefetchPreload, err error)

Cloudflare will prefetch any URLs that are included in the response headers. This is limited to Enterprise Zones.

func (*SettingPrefetchPreloadService) Get 

func (r *SettingPrefetchPreloadService) Get(ctx context.Context, query SettingPrefetchPreloadGetParams, opts ...option.RequestOption) (res *PrefetchPreload, err error)

Cloudflare will prefetch any URLs that are included in the response headers. This is limited to Enterprise Zones.

type SettingProxyReadTimeoutEditParams 

type SettingProxyReadTimeoutEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Maximum time between two read operations from origin.
	Value param.Field[ProxyReadTimeoutParam] `json:"value,required"`
}

func (SettingProxyReadTimeoutEditParams) MarshalJSON 

func (r SettingProxyReadTimeoutEditParams) MarshalJSON() (data []byte, err error)

type SettingProxyReadTimeoutEditResponseEnvelope 

type SettingProxyReadTimeoutEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Maximum time between two read operations from origin.
	Result ProxyReadTimeout                                `json:"result"`
	JSON   settingProxyReadTimeoutEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingProxyReadTimeoutEditResponseEnvelope) UnmarshalJSON 

func (r *SettingProxyReadTimeoutEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingProxyReadTimeoutGetParams 

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

type SettingProxyReadTimeoutGetResponseEnvelope 

type SettingProxyReadTimeoutGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Maximum time between two read operations from origin.
	Result ProxyReadTimeout                               `json:"result"`
	JSON   settingProxyReadTimeoutGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingProxyReadTimeoutGetResponseEnvelope) UnmarshalJSON 

func (r *SettingProxyReadTimeoutGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingProxyReadTimeoutService 

type SettingProxyReadTimeoutService struct {
	Options []option.RequestOption
}

SettingProxyReadTimeoutService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingProxyReadTimeoutService method instead.

func NewSettingProxyReadTimeoutService 

func NewSettingProxyReadTimeoutService(opts ...option.RequestOption) (r *SettingProxyReadTimeoutService)

NewSettingProxyReadTimeoutService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingProxyReadTimeoutService) Edit 

func (r *SettingProxyReadTimeoutService) Edit(ctx context.Context, params SettingProxyReadTimeoutEditParams, opts ...option.RequestOption) (res *ProxyReadTimeout, err error)

Maximum time between two read operations from origin.

func (*SettingProxyReadTimeoutService) Get 

func (r *SettingProxyReadTimeoutService) Get(ctx context.Context, query SettingProxyReadTimeoutGetParams, opts ...option.RequestOption) (res *ProxyReadTimeout, err error)

Maximum time between two read operations from origin.

type SettingPseudoIPV4EditParams 

type SettingPseudoIPV4EditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the Pseudo IPv4 setting.
	Value param.Field[SettingPseudoIPV4EditParamsValue] `json:"value,required"`
}

func (SettingPseudoIPV4EditParams) MarshalJSON 

func (r SettingPseudoIPV4EditParams) MarshalJSON() (data []byte, err error)

type SettingPseudoIPV4EditParamsValue 

type SettingPseudoIPV4EditParamsValue string

Value of the Pseudo IPv4 setting. 

const (
	SettingPseudoIPV4EditParamsValueOff             SettingPseudoIPV4EditParamsValue = "off"
	SettingPseudoIPV4EditParamsValueAddHeader       SettingPseudoIPV4EditParamsValue = "add_header"
	SettingPseudoIPV4EditParamsValueOverwriteHeader SettingPseudoIPV4EditParamsValue = "overwrite_header"
)

func (SettingPseudoIPV4EditParamsValue) IsKnown 

func (r SettingPseudoIPV4EditParamsValue) IsKnown() bool

type SettingPseudoIPV4EditResponseEnvelope 

type SettingPseudoIPV4EditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// The value set for the Pseudo IPv4 setting.
	Result PseudoIPV4                                `json:"result"`
	JSON   settingPseudoIPV4EditResponseEnvelopeJSON `json:"-"`
}

func (*SettingPseudoIPV4EditResponseEnvelope) UnmarshalJSON 

func (r *SettingPseudoIPV4EditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingPseudoIPV4GetParams 

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

type SettingPseudoIPV4GetResponseEnvelope 

type SettingPseudoIPV4GetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// The value set for the Pseudo IPv4 setting.
	Result PseudoIPV4                               `json:"result"`
	JSON   settingPseudoIPV4GetResponseEnvelopeJSON `json:"-"`
}

func (*SettingPseudoIPV4GetResponseEnvelope) UnmarshalJSON 

func (r *SettingPseudoIPV4GetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingPseudoIPV4Service 

type SettingPseudoIPV4Service struct {
	Options []option.RequestOption
}

SettingPseudoIPV4Service contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingPseudoIPV4Service method instead.

func NewSettingPseudoIPV4Service 

func NewSettingPseudoIPV4Service(opts ...option.RequestOption) (r *SettingPseudoIPV4Service)

NewSettingPseudoIPV4Service generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingPseudoIPV4Service) Edit 

func (r *SettingPseudoIPV4Service) Edit(ctx context.Context, params SettingPseudoIPV4EditParams, opts ...option.RequestOption) (res *PseudoIPV4, err error)

Value of the Pseudo IPv4 setting.

func (*SettingPseudoIPV4Service) Get 

func (r *SettingPseudoIPV4Service) Get(ctx context.Context, query SettingPseudoIPV4GetParams, opts ...option.RequestOption) (res *PseudoIPV4, err error)

Value of the Pseudo IPv4 setting.

type SettingResponseBufferingEditParams 

type SettingResponseBufferingEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingResponseBufferingEditParamsValue] `json:"value,required"`
}

func (SettingResponseBufferingEditParams) MarshalJSON 

func (r SettingResponseBufferingEditParams) MarshalJSON() (data []byte, err error)

type SettingResponseBufferingEditParamsValue 

type SettingResponseBufferingEditParamsValue string

Value of the zone setting. 

const (
	SettingResponseBufferingEditParamsValueOn  SettingResponseBufferingEditParamsValue = "on"
	SettingResponseBufferingEditParamsValueOff SettingResponseBufferingEditParamsValue = "off"
)

func (SettingResponseBufferingEditParamsValue) IsKnown 

func (r SettingResponseBufferingEditParamsValue) IsKnown() bool

type SettingResponseBufferingEditResponseEnvelope 

type SettingResponseBufferingEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enables or disables buffering of responses from the proxied server. Cloudflare
	// may buffer the whole payload to deliver it at once to the client versus allowing
	// it to be delivered in chunks. By default, the proxied server streams directly
	// and is not buffered by Cloudflare. This is limited to Enterprise Zones.
	Result ResponseBuffering                                `json:"result"`
	JSON   settingResponseBufferingEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingResponseBufferingEditResponseEnvelope) UnmarshalJSON 

func (r *SettingResponseBufferingEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingResponseBufferingGetParams 

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

type SettingResponseBufferingGetResponseEnvelope 

type SettingResponseBufferingGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enables or disables buffering of responses from the proxied server. Cloudflare
	// may buffer the whole payload to deliver it at once to the client versus allowing
	// it to be delivered in chunks. By default, the proxied server streams directly
	// and is not buffered by Cloudflare. This is limited to Enterprise Zones.
	Result ResponseBuffering                               `json:"result"`
	JSON   settingResponseBufferingGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingResponseBufferingGetResponseEnvelope) UnmarshalJSON 

func (r *SettingResponseBufferingGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingResponseBufferingService 

type SettingResponseBufferingService struct {
	Options []option.RequestOption
}

SettingResponseBufferingService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingResponseBufferingService method instead.

func NewSettingResponseBufferingService 

func NewSettingResponseBufferingService(opts ...option.RequestOption) (r *SettingResponseBufferingService)

NewSettingResponseBufferingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingResponseBufferingService) Edit 

func (r *SettingResponseBufferingService) Edit(ctx context.Context, params SettingResponseBufferingEditParams, opts ...option.RequestOption) (res *ResponseBuffering, err error)

Enables or disables buffering of responses from the proxied server. Cloudflare may buffer the whole payload to deliver it at once to the client versus allowing it to be delivered in chunks. By default, the proxied server streams directly and is not buffered by Cloudflare. This is limited to Enterprise Zones.

func (*SettingResponseBufferingService) Get 

func (r *SettingResponseBufferingService) Get(ctx context.Context, query SettingResponseBufferingGetParams, opts ...option.RequestOption) (res *ResponseBuffering, err error)

Enables or disables buffering of responses from the proxied server. Cloudflare may buffer the whole payload to deliver it at once to the client versus allowing it to be delivered in chunks. By default, the proxied server streams directly and is not buffered by Cloudflare. This is limited to Enterprise Zones.

type SettingRocketLoaderEditParams 

type SettingRocketLoaderEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Rocket Loader is a general-purpose asynchronous JavaScript optimisation that
	// prioritises rendering your content while loading your site's Javascript
	// asynchronously. Turning on Rocket Loader will immediately improve a web page's
	// rendering time sometimes measured as Time to First Paint (TTFP), and also the
	// `window.onload` time (assuming there is JavaScript on the page). This can have a
	// positive impact on your Google search ranking. When turned on, Rocket Loader
	// will automatically defer the loading of all Javascript referenced in your HTML,
	// with no configuration required. Refer to
	// [Understanding Rocket Loader](https://support.cloudflare.com/hc/articles/200168056)
	// for more information.
	Value param.Field[RocketLoaderParam] `json:"value,required"`
}

func (SettingRocketLoaderEditParams) MarshalJSON 

func (r SettingRocketLoaderEditParams) MarshalJSON() (data []byte, err error)

type SettingRocketLoaderEditResponseEnvelope 

type SettingRocketLoaderEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Rocket Loader is a general-purpose asynchronous JavaScript optimisation that
	// prioritises rendering your content while loading your site's Javascript
	// asynchronously. Turning on Rocket Loader will immediately improve a web page's
	// rendering time sometimes measured as Time to First Paint (TTFP), and also the
	// `window.onload` time (assuming there is JavaScript on the page). This can have a
	// positive impact on your Google search ranking. When turned on, Rocket Loader
	// will automatically defer the loading of all Javascript referenced in your HTML,
	// with no configuration required. Refer to
	// [Understanding Rocket Loader](https://support.cloudflare.com/hc/articles/200168056)
	// for more information.
	Result RocketLoader                                `json:"result"`
	JSON   settingRocketLoaderEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingRocketLoaderEditResponseEnvelope) UnmarshalJSON 

func (r *SettingRocketLoaderEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingRocketLoaderGetParams 

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

type SettingRocketLoaderGetResponseEnvelope 

type SettingRocketLoaderGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Rocket Loader is a general-purpose asynchronous JavaScript optimisation that
	// prioritises rendering your content while loading your site's Javascript
	// asynchronously. Turning on Rocket Loader will immediately improve a web page's
	// rendering time sometimes measured as Time to First Paint (TTFP), and also the
	// `window.onload` time (assuming there is JavaScript on the page). This can have a
	// positive impact on your Google search ranking. When turned on, Rocket Loader
	// will automatically defer the loading of all Javascript referenced in your HTML,
	// with no configuration required. Refer to
	// [Understanding Rocket Loader](https://support.cloudflare.com/hc/articles/200168056)
	// for more information.
	Result RocketLoader                               `json:"result"`
	JSON   settingRocketLoaderGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingRocketLoaderGetResponseEnvelope) UnmarshalJSON 

func (r *SettingRocketLoaderGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingRocketLoaderService 

type SettingRocketLoaderService struct {
	Options []option.RequestOption
}

SettingRocketLoaderService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingRocketLoaderService method instead.

func NewSettingRocketLoaderService 

func NewSettingRocketLoaderService(opts ...option.RequestOption) (r *SettingRocketLoaderService)

NewSettingRocketLoaderService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingRocketLoaderService) Edit 

func (r *SettingRocketLoaderService) Edit(ctx context.Context, params SettingRocketLoaderEditParams, opts ...option.RequestOption) (res *RocketLoader, err error)

Rocket Loader is a general-purpose asynchronous JavaScript optimisation that prioritises rendering your content while loading your site's Javascript asynchronously. Turning on Rocket Loader will immediately improve a web page's rendering time sometimes measured as Time to First Paint (TTFP), and also the `window.onload` time (assuming there is JavaScript on the page). This can have a positive impact on your Google search ranking. When turned on, Rocket Loader will automatically defer the loading of all Javascript referenced in your HTML, with no configuration required. Refer to [Understanding Rocket Loader](https://support.cloudflare.com/hc/articles/200168056) for more information.

func (*SettingRocketLoaderService) Get 

func (r *SettingRocketLoaderService) Get(ctx context.Context, query SettingRocketLoaderGetParams, opts ...option.RequestOption) (res *RocketLoader, err error)

Rocket Loader is a general-purpose asynchronous JavaScript optimisation that prioritises rendering your content while loading your site's Javascript asynchronously. Turning on Rocket Loader will immediately improve a web page's rendering time sometimes measured as Time to First Paint (TTFP), and also the `window.onload` time (assuming there is JavaScript on the page). This can have a positive impact on your Google search ranking. When turned on, Rocket Loader will automatically defer the loading of all Javascript referenced in your HTML, with no configuration required. Refer to [Understanding Rocket Loader](https://support.cloudflare.com/hc/articles/200168056) for more information.

type SettingSSLEditParams 

type SettingSSLEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting. Notes: Depends on the zone's plan level
	Value param.Field[SettingSSLEditParamsValue] `json:"value,required"`
}

func (SettingSSLEditParams) MarshalJSON 

func (r SettingSSLEditParams) MarshalJSON() (data []byte, err error)

type SettingSSLEditParamsValue 

type SettingSSLEditParamsValue string

Value of the zone setting. Notes: Depends on the zone's plan level 

const (
	SettingSSLEditParamsValueOff      SettingSSLEditParamsValue = "off"
	SettingSSLEditParamsValueFlexible SettingSSLEditParamsValue = "flexible"
	SettingSSLEditParamsValueFull     SettingSSLEditParamsValue = "full"
	SettingSSLEditParamsValueStrict   SettingSSLEditParamsValue = "strict"
)

func (SettingSSLEditParamsValue) IsKnown 

func (r SettingSSLEditParamsValue) IsKnown() bool

type SettingSSLEditResponseEnvelope 

type SettingSSLEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// SSL encrypts your visitor's connection and safeguards credit card numbers and
	// other personal data to and from your website. SSL can take up to 5 minutes to
	// fully activate. Requires Cloudflare active on your root domain or www domain.
	// Off: no SSL between the visitor and Cloudflare, and no SSL between Cloudflare
	// and your web server (all HTTP traffic). Flexible: SSL between the visitor and
	// Cloudflare -- visitor sees HTTPS on your site, but no SSL between Cloudflare and
	// your web server. You don't need to have an SSL cert on your web server, but your
	// vistors will still see the site as being HTTPS enabled. Full: SSL between the
	// visitor and Cloudflare -- visitor sees HTTPS on your site, and SSL between
	// Cloudflare and your web server. You'll need to have your own SSL cert or
	// self-signed cert at the very least. Full (Strict): SSL between the visitor and
	// Cloudflare -- visitor sees HTTPS on your site, and SSL between Cloudflare and
	// your web server. You'll need to have a valid SSL certificate installed on your
	// web server. This certificate must be signed by a certificate authority, have an
	// expiration date in the future, and respond for the request domain name
	// (hostname). (https://support.cloudflare.com/hc/en-us/articles/200170416).
	Result SSL                                `json:"result"`
	JSON   settingSSLEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingSSLEditResponseEnvelope) UnmarshalJSON 

func (r *SettingSSLEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSSLGetParams 

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

type SettingSSLGetResponseEnvelope 

type SettingSSLGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// SSL encrypts your visitor's connection and safeguards credit card numbers and
	// other personal data to and from your website. SSL can take up to 5 minutes to
	// fully activate. Requires Cloudflare active on your root domain or www domain.
	// Off: no SSL between the visitor and Cloudflare, and no SSL between Cloudflare
	// and your web server (all HTTP traffic). Flexible: SSL between the visitor and
	// Cloudflare -- visitor sees HTTPS on your site, but no SSL between Cloudflare and
	// your web server. You don't need to have an SSL cert on your web server, but your
	// vistors will still see the site as being HTTPS enabled. Full: SSL between the
	// visitor and Cloudflare -- visitor sees HTTPS on your site, and SSL between
	// Cloudflare and your web server. You'll need to have your own SSL cert or
	// self-signed cert at the very least. Full (Strict): SSL between the visitor and
	// Cloudflare -- visitor sees HTTPS on your site, and SSL between Cloudflare and
	// your web server. You'll need to have a valid SSL certificate installed on your
	// web server. This certificate must be signed by a certificate authority, have an
	// expiration date in the future, and respond for the request domain name
	// (hostname). (https://support.cloudflare.com/hc/en-us/articles/200170416).
	Result SSL                               `json:"result"`
	JSON   settingSSLGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingSSLGetResponseEnvelope) UnmarshalJSON 

func (r *SettingSSLGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSSLRecommenderEditParams 

type SettingSSLRecommenderEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Enrollment in the SSL/TLS Recommender service which tries to detect and
	// recommend (by sending periodic emails) the most secure SSL/TLS setting your
	// origin servers support.
	Value param.Field[SSLRecommenderParam] `json:"value,required"`
}

func (SettingSSLRecommenderEditParams) MarshalJSON 

func (r SettingSSLRecommenderEditParams) MarshalJSON() (data []byte, err error)

type SettingSSLRecommenderEditResponseEnvelope 

type SettingSSLRecommenderEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enrollment in the SSL/TLS Recommender service which tries to detect and
	// recommend (by sending periodic emails) the most secure SSL/TLS setting your
	// origin servers support.
	Result SSLRecommender                                `json:"result"`
	JSON   settingSSLRecommenderEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingSSLRecommenderEditResponseEnvelope) UnmarshalJSON 

func (r *SettingSSLRecommenderEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSSLRecommenderGetParams 

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

type SettingSSLRecommenderGetResponseEnvelope 

type SettingSSLRecommenderGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enrollment in the SSL/TLS Recommender service which tries to detect and
	// recommend (by sending periodic emails) the most secure SSL/TLS setting your
	// origin servers support.
	Result SSLRecommender                               `json:"result"`
	JSON   settingSSLRecommenderGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingSSLRecommenderGetResponseEnvelope) UnmarshalJSON 

func (r *SettingSSLRecommenderGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSSLRecommenderService 

type SettingSSLRecommenderService struct {
	Options []option.RequestOption
}

SettingSSLRecommenderService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingSSLRecommenderService method instead.

func NewSettingSSLRecommenderService 

func NewSettingSSLRecommenderService(opts ...option.RequestOption) (r *SettingSSLRecommenderService)

NewSettingSSLRecommenderService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingSSLRecommenderService) Edit 

func (r *SettingSSLRecommenderService) Edit(ctx context.Context, params SettingSSLRecommenderEditParams, opts ...option.RequestOption) (res *SSLRecommender, err error)

Enrollment in the SSL/TLS Recommender service which tries to detect and recommend (by sending periodic emails) the most secure SSL/TLS setting your origin servers support.

func (*SettingSSLRecommenderService) Get 

func (r *SettingSSLRecommenderService) Get(ctx context.Context, query SettingSSLRecommenderGetParams, opts ...option.RequestOption) (res *SSLRecommender, err error)

Enrollment in the SSL/TLS Recommender service which tries to detect and recommend (by sending periodic emails) the most secure SSL/TLS setting your origin servers support.

type SettingSSLService 

type SettingSSLService struct {
	Options []option.RequestOption
}

SettingSSLService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingSSLService method instead.

func NewSettingSSLService 

func NewSettingSSLService(opts ...option.RequestOption) (r *SettingSSLService)

NewSettingSSLService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingSSLService) Edit 

func (r *SettingSSLService) Edit(ctx context.Context, params SettingSSLEditParams, opts ...option.RequestOption) (res *SSL, err error)

SSL encrypts your visitor's connection and safeguards credit card numbers and other personal data to and from your website. SSL can take up to 5 minutes to fully activate. Requires Cloudflare active on your root domain or www domain. Off: no SSL between the visitor and Cloudflare, and no SSL between Cloudflare and your web server (all HTTP traffic). Flexible: SSL between the visitor and Cloudflare -- visitor sees HTTPS on your site, but no SSL between Cloudflare and your web server. You don't need to have an SSL cert on your web server, but your vistors will still see the site as being HTTPS enabled. Full: SSL between the visitor and Cloudflare -- visitor sees HTTPS on your site, and SSL between Cloudflare and your web server. You'll need to have your own SSL cert or self-signed cert at the very least. Full (Strict): SSL between the visitor and Cloudflare -- visitor sees HTTPS on your site, and SSL between Cloudflare and your web server. You'll need to have a valid SSL certificate installed on your web server. This certificate must be signed by a certificate authority, have an expiration date in the future, and respond for the request domain name (hostname). (https://support.cloudflare.com/hc/en-us/articles/200170416).

func (*SettingSSLService) Get 

func (r *SettingSSLService) Get(ctx context.Context, query SettingSSLGetParams, opts ...option.RequestOption) (res *SSL, err error)

SSL encrypts your visitor's connection and safeguards credit card numbers and other personal data to and from your website. SSL can take up to 5 minutes to fully activate. Requires Cloudflare active on your root domain or www domain. Off: no SSL between the visitor and Cloudflare, and no SSL between Cloudflare and your web server (all HTTP traffic). Flexible: SSL between the visitor and Cloudflare -- visitor sees HTTPS on your site, but no SSL between Cloudflare and your web server. You don't need to have an SSL cert on your web server, but your vistors will still see the site as being HTTPS enabled. Full: SSL between the visitor and Cloudflare -- visitor sees HTTPS on your site, and SSL between Cloudflare and your web server. You'll need to have your own SSL cert or self-signed cert at the very least. Full (Strict): SSL between the visitor and Cloudflare -- visitor sees HTTPS on your site, and SSL between Cloudflare and your web server. You'll need to have a valid SSL certificate installed on your web server. This certificate must be signed by a certificate authority, have an expiration date in the future, and respond for the request domain name (hostname). (https://support.cloudflare.com/hc/en-us/articles/200170416).

type SettingSecurityHeaderEditParams 

type SettingSecurityHeaderEditParams struct {
	// Identifier
	ZoneID param.Field[string]                               `path:"zone_id,required"`
	Value  param.Field[SettingSecurityHeaderEditParamsValue] `json:"value,required"`
}

func (SettingSecurityHeaderEditParams) MarshalJSON 

func (r SettingSecurityHeaderEditParams) MarshalJSON() (data []byte, err error)

type SettingSecurityHeaderEditParamsValue 

type SettingSecurityHeaderEditParamsValue struct {
	// Strict Transport Security.
	StrictTransportSecurity param.Field[SettingSecurityHeaderEditParamsValueStrictTransportSecurity] `json:"strict_transport_security"`
}

func (SettingSecurityHeaderEditParamsValue) MarshalJSON 

func (r SettingSecurityHeaderEditParamsValue) MarshalJSON() (data []byte, err error)

type SettingSecurityHeaderEditParamsValueStrictTransportSecurity 

type SettingSecurityHeaderEditParamsValueStrictTransportSecurity struct {
	// Whether or not strict transport security is enabled.
	Enabled param.Field[bool] `json:"enabled"`
	// Include all subdomains for strict transport security.
	IncludeSubdomains param.Field[bool] `json:"include_subdomains"`
	// Max age in seconds of the strict transport security.
	MaxAge param.Field[float64] `json:"max_age"`
	// Whether or not to include 'X-Content-Type-Options: nosniff' header.
	Nosniff param.Field[bool] `json:"nosniff"`
}

Strict Transport Security.

func (SettingSecurityHeaderEditParamsValueStrictTransportSecurity) MarshalJSON 

func (r SettingSecurityHeaderEditParamsValueStrictTransportSecurity) MarshalJSON() (data []byte, err error)

type SettingSecurityHeaderEditResponseEnvelope 

type SettingSecurityHeaderEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cloudflare security header for a zone.
	Result SecurityHeaders                               `json:"result"`
	JSON   settingSecurityHeaderEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingSecurityHeaderEditResponseEnvelope) UnmarshalJSON 

func (r *SettingSecurityHeaderEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSecurityHeaderGetParams 

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

type SettingSecurityHeaderGetResponseEnvelope 

type SettingSecurityHeaderGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cloudflare security header for a zone.
	Result SecurityHeaders                              `json:"result"`
	JSON   settingSecurityHeaderGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingSecurityHeaderGetResponseEnvelope) UnmarshalJSON 

func (r *SettingSecurityHeaderGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSecurityHeaderService 

type SettingSecurityHeaderService struct {
	Options []option.RequestOption
}

SettingSecurityHeaderService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingSecurityHeaderService method instead.

func NewSettingSecurityHeaderService 

func NewSettingSecurityHeaderService(opts ...option.RequestOption) (r *SettingSecurityHeaderService)

NewSettingSecurityHeaderService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingSecurityHeaderService) Edit 

func (r *SettingSecurityHeaderService) Edit(ctx context.Context, params SettingSecurityHeaderEditParams, opts ...option.RequestOption) (res *SecurityHeaders, err error)

Cloudflare security header for a zone.

func (*SettingSecurityHeaderService) Get 

func (r *SettingSecurityHeaderService) Get(ctx context.Context, query SettingSecurityHeaderGetParams, opts ...option.RequestOption) (res *SecurityHeaders, err error)

Cloudflare security header for a zone.

type SettingSecurityLevelEditParams 

type SettingSecurityLevelEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingSecurityLevelEditParamsValue] `json:"value,required"`
}

func (SettingSecurityLevelEditParams) MarshalJSON 

func (r SettingSecurityLevelEditParams) MarshalJSON() (data []byte, err error)

type SettingSecurityLevelEditParamsValue 

type SettingSecurityLevelEditParamsValue string

Value of the zone setting. 

const (
	SettingSecurityLevelEditParamsValueOff            SettingSecurityLevelEditParamsValue = "off"
	SettingSecurityLevelEditParamsValueEssentiallyOff SettingSecurityLevelEditParamsValue = "essentially_off"
	SettingSecurityLevelEditParamsValueLow            SettingSecurityLevelEditParamsValue = "low"
	SettingSecurityLevelEditParamsValueMedium         SettingSecurityLevelEditParamsValue = "medium"
	SettingSecurityLevelEditParamsValueHigh           SettingSecurityLevelEditParamsValue = "high"
	SettingSecurityLevelEditParamsValueUnderAttack    SettingSecurityLevelEditParamsValue = "under_attack"
)

func (SettingSecurityLevelEditParamsValue) IsKnown 

func (r SettingSecurityLevelEditParamsValue) IsKnown() bool

type SettingSecurityLevelEditResponseEnvelope 

type SettingSecurityLevelEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Choose the appropriate security profile for your website, which will
	// automatically adjust each of the security settings. If you choose to customize
	// an individual security setting, the profile will become Custom.
	// (https://support.cloudflare.com/hc/en-us/articles/200170056).
	Result SecurityLevel                                `json:"result"`
	JSON   settingSecurityLevelEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingSecurityLevelEditResponseEnvelope) UnmarshalJSON 

func (r *SettingSecurityLevelEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSecurityLevelGetParams 

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

type SettingSecurityLevelGetResponseEnvelope 

type SettingSecurityLevelGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Choose the appropriate security profile for your website, which will
	// automatically adjust each of the security settings. If you choose to customize
	// an individual security setting, the profile will become Custom.
	// (https://support.cloudflare.com/hc/en-us/articles/200170056).
	Result SecurityLevel                               `json:"result"`
	JSON   settingSecurityLevelGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingSecurityLevelGetResponseEnvelope) UnmarshalJSON 

func (r *SettingSecurityLevelGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSecurityLevelService 

type SettingSecurityLevelService struct {
	Options []option.RequestOption
}

SettingSecurityLevelService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingSecurityLevelService method instead.

func NewSettingSecurityLevelService 

func NewSettingSecurityLevelService(opts ...option.RequestOption) (r *SettingSecurityLevelService)

NewSettingSecurityLevelService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingSecurityLevelService) Edit 

func (r *SettingSecurityLevelService) Edit(ctx context.Context, params SettingSecurityLevelEditParams, opts ...option.RequestOption) (res *SecurityLevel, err error)

Choose the appropriate security profile for your website, which will automatically adjust each of the security settings. If you choose to customize an individual security setting, the profile will become Custom. (https://support.cloudflare.com/hc/en-us/articles/200170056).

func (*SettingSecurityLevelService) Get 

func (r *SettingSecurityLevelService) Get(ctx context.Context, query SettingSecurityLevelGetParams, opts ...option.RequestOption) (res *SecurityLevel, err error)

Choose the appropriate security profile for your website, which will automatically adjust each of the security settings. If you choose to customize an individual security setting, the profile will become Custom. (https://support.cloudflare.com/hc/en-us/articles/200170056).

type SettingServerSideExcludeEditParams 

type SettingServerSideExcludeEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingServerSideExcludeEditParamsValue] `json:"value,required"`
}

func (SettingServerSideExcludeEditParams) MarshalJSON 

func (r SettingServerSideExcludeEditParams) MarshalJSON() (data []byte, err error)

type SettingServerSideExcludeEditParamsValue 

type SettingServerSideExcludeEditParamsValue string

Value of the zone setting. 

const (
	SettingServerSideExcludeEditParamsValueOn  SettingServerSideExcludeEditParamsValue = "on"
	SettingServerSideExcludeEditParamsValueOff SettingServerSideExcludeEditParamsValue = "off"
)

func (SettingServerSideExcludeEditParamsValue) IsKnown 

func (r SettingServerSideExcludeEditParamsValue) IsKnown() bool

type SettingServerSideExcludeEditResponseEnvelope 

type SettingServerSideExcludeEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// If there is sensitive content on your website that you want visible to real
	// visitors, but that you want to hide from suspicious visitors, all you have to do
	// is wrap the content with Cloudflare SSE tags. Wrap any content that you want to
	// be excluded from suspicious visitors in the following SSE tags:
	// <!--sse--><!--/sse-->. For example: <!--sse--> Bad visitors won't see my phone
	// number, 555-555-5555 <!--/sse-->. Note: SSE only will work with HTML. If you
	// have HTML minification enabled, you won't see the SSE tags in your HTML source
	// when it's served through Cloudflare. SSE will still function in this case, as
	// Cloudflare's HTML minification and SSE functionality occur on-the-fly as the
	// resource moves through our network to the visitor's computer.
	// (https://support.cloudflare.com/hc/en-us/articles/200170036).
	Result ServerSideExcludes                               `json:"result"`
	JSON   settingServerSideExcludeEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingServerSideExcludeEditResponseEnvelope) UnmarshalJSON 

func (r *SettingServerSideExcludeEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingServerSideExcludeGetParams 

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

type SettingServerSideExcludeGetResponseEnvelope 

type SettingServerSideExcludeGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// If there is sensitive content on your website that you want visible to real
	// visitors, but that you want to hide from suspicious visitors, all you have to do
	// is wrap the content with Cloudflare SSE tags. Wrap any content that you want to
	// be excluded from suspicious visitors in the following SSE tags:
	// <!--sse--><!--/sse-->. For example: <!--sse--> Bad visitors won't see my phone
	// number, 555-555-5555 <!--/sse-->. Note: SSE only will work with HTML. If you
	// have HTML minification enabled, you won't see the SSE tags in your HTML source
	// when it's served through Cloudflare. SSE will still function in this case, as
	// Cloudflare's HTML minification and SSE functionality occur on-the-fly as the
	// resource moves through our network to the visitor's computer.
	// (https://support.cloudflare.com/hc/en-us/articles/200170036).
	Result ServerSideExcludes                              `json:"result"`
	JSON   settingServerSideExcludeGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingServerSideExcludeGetResponseEnvelope) UnmarshalJSON 

func (r *SettingServerSideExcludeGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingServerSideExcludeService 

type SettingServerSideExcludeService struct {
	Options []option.RequestOption
}

SettingServerSideExcludeService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingServerSideExcludeService method instead.

func NewSettingServerSideExcludeService 

func NewSettingServerSideExcludeService(opts ...option.RequestOption) (r *SettingServerSideExcludeService)

NewSettingServerSideExcludeService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingServerSideExcludeService) Edit 

func (r *SettingServerSideExcludeService) Edit(ctx context.Context, params SettingServerSideExcludeEditParams, opts ...option.RequestOption) (res *ServerSideExcludes, err error)

If there is sensitive content on your website that you want visible to real visitors, but that you want to hide from suspicious visitors, all you have to do is wrap the content with Cloudflare SSE tags. Wrap any content that you want to be excluded from suspicious visitors in the following SSE tags: <!--sse--><!--/sse-->. For example: <!--sse--> Bad visitors won't see my phone number, 555-555-5555 <!--/sse-->. Note: SSE only will work with HTML. If you have HTML minification enabled, you won't see the SSE tags in your HTML source when it's served through Cloudflare. SSE will still function in this case, as Cloudflare's HTML minification and SSE functionality occur on-the-fly as the resource moves through our network to the visitor's computer. (https://support.cloudflare.com/hc/en-us/articles/200170036).

func (*SettingServerSideExcludeService) Get 

func (r *SettingServerSideExcludeService) Get(ctx context.Context, query SettingServerSideExcludeGetParams, opts ...option.RequestOption) (res *ServerSideExcludes, err error)

If there is sensitive content on your website that you want visible to real visitors, but that you want to hide from suspicious visitors, all you have to do is wrap the content with Cloudflare SSE tags. Wrap any content that you want to be excluded from suspicious visitors in the following SSE tags: <!--sse--><!--/sse-->. For example: <!--sse--> Bad visitors won't see my phone number, 555-555-5555 <!--/sse-->. Note: SSE only will work with HTML. If you have HTML minification enabled, you won't see the SSE tags in your HTML source when it's served through Cloudflare. SSE will still function in this case, as Cloudflare's HTML minification and SSE functionality occur on-the-fly as the resource moves through our network to the visitor's computer. (https://support.cloudflare.com/hc/en-us/articles/200170036).

type SettingService 

type SettingService struct {
	Options                       []option.RequestOption
	ZeroRTT                       *SettingZeroRTTService
	AdvancedDDoS                  *SettingAdvancedDDoSService
	AlwaysOnline                  *SettingAlwaysOnlineService
	AlwaysUseHTTPS                *SettingAlwaysUseHTTPSService
	AutomaticHTTPSRewrites        *SettingAutomaticHTTPSRewriteService
	AutomaticPlatformOptimization *SettingAutomaticPlatformOptimizationService
	Brotli                        *SettingBrotliService
	BrowserCacheTTL               *SettingBrowserCacheTTLService
	BrowserCheck                  *SettingBrowserCheckService
	CacheLevel                    *SettingCacheLevelService
	ChallengeTTL                  *SettingChallengeTTLService
	Ciphers                       *SettingCipherService
	DevelopmentMode               *SettingDevelopmentModeService
	EarlyHints                    *SettingEarlyHintService
	EmailObfuscation              *SettingEmailObfuscationService
	H2Prioritization              *SettingH2PrioritizationService
	HotlinkProtection             *SettingHotlinkProtectionService
	HTTP2                         *SettingHTTP2Service
	HTTP3                         *SettingHTTP3Service
	ImageResizing                 *SettingImageResizingService
	IPGeolocation                 *SettingIPGeolocationService
	IPV6                          *SettingIPV6Service
	MinTLSVersion                 *SettingMinTLSVersionService
	Minify                        *SettingMinifyService
	Mirage                        *SettingMirageService
	MobileRedirect                *SettingMobileRedirectService
	NEL                           *SettingNELService
	OpportunisticEncryption       *SettingOpportunisticEncryptionService
	OpportunisticOnion            *SettingOpportunisticOnionService
	OrangeToOrange                *SettingOrangeToOrangeService
	OriginErrorPagePassThru       *SettingOriginErrorPagePassThruService
	OriginMaxHTTPVersion          *SettingOriginMaxHTTPVersionService
	Polish                        *SettingPolishService
	PrefetchPreload               *SettingPrefetchPreloadService
	ProxyReadTimeout              *SettingProxyReadTimeoutService
	PseudoIPV4                    *SettingPseudoIPV4Service
	ResponseBuffering             *SettingResponseBufferingService
	RocketLoader                  *SettingRocketLoaderService
	SecurityHeaders               *SettingSecurityHeaderService
	SecurityLevel                 *SettingSecurityLevelService
	ServerSideExcludes            *SettingServerSideExcludeService
	SortQueryStringForCache       *SettingSortQueryStringForCacheService
	SSL                           *SettingSSLService
	SSLRecommender                *SettingSSLRecommenderService
	TLS1_3                        *SettingTLS1_3Service
	TLSClientAuth                 *SettingTLSClientAuthService
	TrueClientIPHeader            *SettingTrueClientIPHeaderService
	WAF                           *SettingWAFService
	WebP                          *SettingWebPService
	Websocket                     *SettingWebsocketService
	FontSettings                  *SettingFontSettingService
}

SettingService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingService method instead.

func NewSettingService 

func NewSettingService(opts ...option.RequestOption) (r *SettingService)

NewSettingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type SettingSortQueryStringForCacheEditParams 

type SettingSortQueryStringForCacheEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingSortQueryStringForCacheEditParamsValue] `json:"value,required"`
}

func (SettingSortQueryStringForCacheEditParams) MarshalJSON 

func (r SettingSortQueryStringForCacheEditParams) MarshalJSON() (data []byte, err error)

type SettingSortQueryStringForCacheEditParamsValue 

type SettingSortQueryStringForCacheEditParamsValue string

Value of the zone setting. 

const (
	SettingSortQueryStringForCacheEditParamsValueOn  SettingSortQueryStringForCacheEditParamsValue = "on"
	SettingSortQueryStringForCacheEditParamsValueOff SettingSortQueryStringForCacheEditParamsValue = "off"
)

func (SettingSortQueryStringForCacheEditParamsValue) IsKnown 

func (r SettingSortQueryStringForCacheEditParamsValue) IsKnown() bool

type SettingSortQueryStringForCacheEditResponseEnvelope 

type SettingSortQueryStringForCacheEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cloudflare will treat files with the same query strings as the same file in
	// cache, regardless of the order of the query strings. This is limited to
	// Enterprise Zones.
	Result SortQueryStringForCache                                `json:"result"`
	JSON   settingSortQueryStringForCacheEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingSortQueryStringForCacheEditResponseEnvelope) UnmarshalJSON 

func (r *SettingSortQueryStringForCacheEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSortQueryStringForCacheGetParams 

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

type SettingSortQueryStringForCacheGetResponseEnvelope 

type SettingSortQueryStringForCacheGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Cloudflare will treat files with the same query strings as the same file in
	// cache, regardless of the order of the query strings. This is limited to
	// Enterprise Zones.
	Result SortQueryStringForCache                               `json:"result"`
	JSON   settingSortQueryStringForCacheGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingSortQueryStringForCacheGetResponseEnvelope) UnmarshalJSON 

func (r *SettingSortQueryStringForCacheGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingSortQueryStringForCacheService 

type SettingSortQueryStringForCacheService struct {
	Options []option.RequestOption
}

SettingSortQueryStringForCacheService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingSortQueryStringForCacheService method instead.

func NewSettingSortQueryStringForCacheService 

func NewSettingSortQueryStringForCacheService(opts ...option.RequestOption) (r *SettingSortQueryStringForCacheService)

NewSettingSortQueryStringForCacheService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingSortQueryStringForCacheService) Edit 

func (r *SettingSortQueryStringForCacheService) Edit(ctx context.Context, params SettingSortQueryStringForCacheEditParams, opts ...option.RequestOption) (res *SortQueryStringForCache, err error)

Cloudflare will treat files with the same query strings as the same file in cache, regardless of the order of the query strings. This is limited to Enterprise Zones.

func (*SettingSortQueryStringForCacheService) Get 

func (r *SettingSortQueryStringForCacheService) Get(ctx context.Context, query SettingSortQueryStringForCacheGetParams, opts ...option.RequestOption) (res *SortQueryStringForCache, err error)

Cloudflare will treat files with the same query strings as the same file in cache, regardless of the order of the query strings. This is limited to Enterprise Zones.

type SettingTLS1_3EditParams 

type SettingTLS1_3EditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting. Notes: Default value depends on the zone's plan
	// level.
	Value param.Field[SettingTls1_3EditParamsValue] `json:"value,required"`
}

func (SettingTLS1_3EditParams) MarshalJSON 

func (r SettingTLS1_3EditParams) MarshalJSON() (data []byte, err error)

type SettingTLS1_3GetParams 

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

type SettingTLS1_3Service 

type SettingTLS1_3Service struct {
	Options []option.RequestOption
}

SettingTLS1_3Service contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingTLS1_3Service method instead.

func NewSettingTLS1_3Service 

func NewSettingTLS1_3Service(opts ...option.RequestOption) (r *SettingTLS1_3Service)

NewSettingTLS1_3Service generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingTLS1_3Service) Edit 

func (r *SettingTLS1_3Service) Edit(ctx context.Context, params SettingTLS1_3EditParams, opts ...option.RequestOption) (res *TLS1_3, err error)

Changes TLS 1.3 setting.

func (*SettingTLS1_3Service) Get 

func (r *SettingTLS1_3Service) Get(ctx context.Context, query SettingTLS1_3GetParams, opts ...option.RequestOption) (res *TLS1_3, err error)

Gets TLS 1.3 setting enabled for a zone.

type SettingTLSClientAuthEditParams 

type SettingTLSClientAuthEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// value of the zone setting.
	Value param.Field[SettingTLSClientAuthEditParamsValue] `json:"value,required"`
}

func (SettingTLSClientAuthEditParams) MarshalJSON 

func (r SettingTLSClientAuthEditParams) MarshalJSON() (data []byte, err error)

type SettingTLSClientAuthEditParamsValue 

type SettingTLSClientAuthEditParamsValue string

value of the zone setting. 

const (
	SettingTLSClientAuthEditParamsValueOn  SettingTLSClientAuthEditParamsValue = "on"
	SettingTLSClientAuthEditParamsValueOff SettingTLSClientAuthEditParamsValue = "off"
)

func (SettingTLSClientAuthEditParamsValue) IsKnown 

func (r SettingTLSClientAuthEditParamsValue) IsKnown() bool

type SettingTLSClientAuthEditResponseEnvelope 

type SettingTLSClientAuthEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// TLS Client Auth requires Cloudflare to connect to your origin server using a
	// client certificate (Enterprise Only).
	Result TLSClientAuth                                `json:"result"`
	JSON   settingTLSClientAuthEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingTLSClientAuthEditResponseEnvelope) UnmarshalJSON 

func (r *SettingTLSClientAuthEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingTLSClientAuthGetParams 

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

type SettingTLSClientAuthGetResponseEnvelope 

type SettingTLSClientAuthGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// TLS Client Auth requires Cloudflare to connect to your origin server using a
	// client certificate (Enterprise Only).
	Result TLSClientAuth                               `json:"result"`
	JSON   settingTLSClientAuthGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingTLSClientAuthGetResponseEnvelope) UnmarshalJSON 

func (r *SettingTLSClientAuthGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingTLSClientAuthService 

type SettingTLSClientAuthService struct {
	Options []option.RequestOption
}

SettingTLSClientAuthService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingTLSClientAuthService method instead.

func NewSettingTLSClientAuthService 

func NewSettingTLSClientAuthService(opts ...option.RequestOption) (r *SettingTLSClientAuthService)

NewSettingTLSClientAuthService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingTLSClientAuthService) Edit 

func (r *SettingTLSClientAuthService) Edit(ctx context.Context, params SettingTLSClientAuthEditParams, opts ...option.RequestOption) (res *TLSClientAuth, err error)

TLS Client Auth requires Cloudflare to connect to your origin server using a client certificate (Enterprise Only).

func (*SettingTLSClientAuthService) Get 

func (r *SettingTLSClientAuthService) Get(ctx context.Context, query SettingTLSClientAuthGetParams, opts ...option.RequestOption) (res *TLSClientAuth, err error)

TLS Client Auth requires Cloudflare to connect to your origin server using a client certificate (Enterprise Only).

type SettingTls1_3EditParamsValue 

type SettingTls1_3EditParamsValue string

Value of the zone setting. Notes: Default value depends on the zone's plan level. 

const (
	SettingTls1_3EditParamsValueOn  SettingTls1_3EditParamsValue = "on"
	SettingTls1_3EditParamsValueOff SettingTls1_3EditParamsValue = "off"
	SettingTls1_3EditParamsValueZrt SettingTls1_3EditParamsValue = "zrt"
)

func (SettingTls1_3EditParamsValue) IsKnown 

func (r SettingTls1_3EditParamsValue) IsKnown() bool

type SettingTls1_3EditResponseEnvelope 

type SettingTls1_3EditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enables Crypto TLS 1.3 feature for a zone.
	Result TLS1_3                                `json:"result"`
	JSON   settingTls1_3EditResponseEnvelopeJSON `json:"-"`
}

func (*SettingTls1_3EditResponseEnvelope) UnmarshalJSON 

func (r *SettingTls1_3EditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingTls1_3GetResponseEnvelope 

type SettingTls1_3GetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Enables Crypto TLS 1.3 feature for a zone.
	Result TLS1_3                               `json:"result"`
	JSON   settingTls1_3GetResponseEnvelopeJSON `json:"-"`
}

func (*SettingTls1_3GetResponseEnvelope) UnmarshalJSON 

func (r *SettingTls1_3GetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingTrueClientIPHeaderEditParams 

type SettingTrueClientIPHeaderEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingTrueClientIPHeaderEditParamsValue] `json:"value,required"`
}

func (SettingTrueClientIPHeaderEditParams) MarshalJSON 

func (r SettingTrueClientIPHeaderEditParams) MarshalJSON() (data []byte, err error)

type SettingTrueClientIPHeaderEditParamsValue 

type SettingTrueClientIPHeaderEditParamsValue string

Value of the zone setting. 

const (
	SettingTrueClientIPHeaderEditParamsValueOn  SettingTrueClientIPHeaderEditParamsValue = "on"
	SettingTrueClientIPHeaderEditParamsValueOff SettingTrueClientIPHeaderEditParamsValue = "off"
)

func (SettingTrueClientIPHeaderEditParamsValue) IsKnown 

func (r SettingTrueClientIPHeaderEditParamsValue) IsKnown() bool

type SettingTrueClientIPHeaderEditResponseEnvelope 

type SettingTrueClientIPHeaderEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Allows customer to continue to use True Client IP (Akamai feature) in the
	// headers we send to the origin. This is limited to Enterprise Zones.
	Result TrueClientIPHeader                                `json:"result"`
	JSON   settingTrueClientIPHeaderEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingTrueClientIPHeaderEditResponseEnvelope) UnmarshalJSON 

func (r *SettingTrueClientIPHeaderEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingTrueClientIPHeaderGetParams 

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

type SettingTrueClientIPHeaderGetResponseEnvelope 

type SettingTrueClientIPHeaderGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// Allows customer to continue to use True Client IP (Akamai feature) in the
	// headers we send to the origin. This is limited to Enterprise Zones.
	Result TrueClientIPHeader                               `json:"result"`
	JSON   settingTrueClientIPHeaderGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingTrueClientIPHeaderGetResponseEnvelope) UnmarshalJSON 

func (r *SettingTrueClientIPHeaderGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingTrueClientIPHeaderService 

type SettingTrueClientIPHeaderService struct {
	Options []option.RequestOption
}

SettingTrueClientIPHeaderService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingTrueClientIPHeaderService method instead.

func NewSettingTrueClientIPHeaderService 

func NewSettingTrueClientIPHeaderService(opts ...option.RequestOption) (r *SettingTrueClientIPHeaderService)

NewSettingTrueClientIPHeaderService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingTrueClientIPHeaderService) Edit 

func (r *SettingTrueClientIPHeaderService) Edit(ctx context.Context, params SettingTrueClientIPHeaderEditParams, opts ...option.RequestOption) (res *TrueClientIPHeader, err error)

Allows customer to continue to use True Client IP (Akamai feature) in the headers we send to the origin. This is limited to Enterprise Zones.

func (*SettingTrueClientIPHeaderService) Get 

func (r *SettingTrueClientIPHeaderService) Get(ctx context.Context, query SettingTrueClientIPHeaderGetParams, opts ...option.RequestOption) (res *TrueClientIPHeader, err error)

Allows customer to continue to use True Client IP (Akamai feature) in the headers we send to the origin. This is limited to Enterprise Zones.

type SettingWAFEditParams 

type SettingWAFEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingWAFEditParamsValue] `json:"value,required"`
}

func (SettingWAFEditParams) MarshalJSON 

func (r SettingWAFEditParams) MarshalJSON() (data []byte, err error)

type SettingWAFEditParamsValue 

type SettingWAFEditParamsValue string

Value of the zone setting. 

const (
	SettingWAFEditParamsValueOn  SettingWAFEditParamsValue = "on"
	SettingWAFEditParamsValueOff SettingWAFEditParamsValue = "off"
)

func (SettingWAFEditParamsValue) IsKnown 

func (r SettingWAFEditParamsValue) IsKnown() bool

type SettingWAFEditResponseEnvelope 

type SettingWAFEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// The WAF examines HTTP requests to your website. It inspects both GET and POST
	// requests and applies rules to help filter out illegitimate traffic from
	// legitimate website visitors. The Cloudflare WAF inspects website addresses or
	// URLs to detect anything out of the ordinary. If the Cloudflare WAF determines
	// suspicious user behavior, then the WAF will 'challenge' the web visitor with a
	// page that asks them to submit a CAPTCHA successfully to continue their action.
	// If the challenge is failed, the action will be stopped. What this means is that
	// Cloudflare's WAF will block any traffic identified as illegitimate before it
	// reaches your origin web server.
	// (https://support.cloudflare.com/hc/en-us/articles/200172016).
	Result WAF                                `json:"result"`
	JSON   settingWAFEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingWAFEditResponseEnvelope) UnmarshalJSON 

func (r *SettingWAFEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingWAFGetParams 

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

type SettingWAFGetResponseEnvelope 

type SettingWAFGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// The WAF examines HTTP requests to your website. It inspects both GET and POST
	// requests and applies rules to help filter out illegitimate traffic from
	// legitimate website visitors. The Cloudflare WAF inspects website addresses or
	// URLs to detect anything out of the ordinary. If the Cloudflare WAF determines
	// suspicious user behavior, then the WAF will 'challenge' the web visitor with a
	// page that asks them to submit a CAPTCHA successfully to continue their action.
	// If the challenge is failed, the action will be stopped. What this means is that
	// Cloudflare's WAF will block any traffic identified as illegitimate before it
	// reaches your origin web server.
	// (https://support.cloudflare.com/hc/en-us/articles/200172016).
	Result WAF                               `json:"result"`
	JSON   settingWAFGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingWAFGetResponseEnvelope) UnmarshalJSON 

func (r *SettingWAFGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingWAFService 

type SettingWAFService struct {
	Options []option.RequestOption
}

SettingWAFService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingWAFService method instead.

func NewSettingWAFService 

func NewSettingWAFService(opts ...option.RequestOption) (r *SettingWAFService)

NewSettingWAFService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingWAFService) Edit 

func (r *SettingWAFService) Edit(ctx context.Context, params SettingWAFEditParams, opts ...option.RequestOption) (res *WAF, err error)

The WAF examines HTTP requests to your website. It inspects both GET and POST requests and applies rules to help filter out illegitimate traffic from legitimate website visitors. The Cloudflare WAF inspects website addresses or URLs to detect anything out of the ordinary. If the Cloudflare WAF determines suspicious user behavior, then the WAF will 'challenge' the web visitor with a page that asks them to submit a CAPTCHA successfully to continue their action. If the challenge is failed, the action will be stopped. What this means is that Cloudflare's WAF will block any traffic identified as illegitimate before it reaches your origin web server. (https://support.cloudflare.com/hc/en-us/articles/200172016).

func (*SettingWAFService) Get 

func (r *SettingWAFService) Get(ctx context.Context, query SettingWAFGetParams, opts ...option.RequestOption) (res *WAF, err error)

The WAF examines HTTP requests to your website. It inspects both GET and POST requests and applies rules to help filter out illegitimate traffic from legitimate website visitors. The Cloudflare WAF inspects website addresses or URLs to detect anything out of the ordinary. If the Cloudflare WAF determines suspicious user behavior, then the WAF will 'challenge' the web visitor with a page that asks them to submit a CAPTCHA successfully to continue their action. If the challenge is failed, the action will be stopped. What this means is that Cloudflare's WAF will block any traffic identified as illegitimate before it reaches your origin web server. (https://support.cloudflare.com/hc/en-us/articles/200172016).

type SettingWebPEditParams 

type SettingWebPEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingWebPEditParamsValue] `json:"value,required"`
}

func (SettingWebPEditParams) MarshalJSON 

func (r SettingWebPEditParams) MarshalJSON() (data []byte, err error)

type SettingWebPEditParamsValue 

type SettingWebPEditParamsValue string

Value of the zone setting. 

const (
	SettingWebPEditParamsValueOff SettingWebPEditParamsValue = "off"
	SettingWebPEditParamsValueOn  SettingWebPEditParamsValue = "on"
)

func (SettingWebPEditParamsValue) IsKnown 

func (r SettingWebPEditParamsValue) IsKnown() bool

type SettingWebPEditResponseEnvelope 

type SettingWebPEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When the client requesting the image supports the WebP image codec, and WebP
	// offers a performance advantage over the original image format, Cloudflare will
	// serve a WebP version of the original image.
	Result WebP                                `json:"result"`
	JSON   settingWebPEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingWebPEditResponseEnvelope) UnmarshalJSON 

func (r *SettingWebPEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingWebPGetParams 

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

type SettingWebPGetResponseEnvelope 

type SettingWebPGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// When the client requesting the image supports the WebP image codec, and WebP
	// offers a performance advantage over the original image format, Cloudflare will
	// serve a WebP version of the original image.
	Result WebP                               `json:"result"`
	JSON   settingWebPGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingWebPGetResponseEnvelope) UnmarshalJSON 

func (r *SettingWebPGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingWebPService 

type SettingWebPService struct {
	Options []option.RequestOption
}

SettingWebPService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingWebPService method instead.

func NewSettingWebPService 

func NewSettingWebPService(opts ...option.RequestOption) (r *SettingWebPService)

NewSettingWebPService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingWebPService) Edit 

func (r *SettingWebPService) Edit(ctx context.Context, params SettingWebPEditParams, opts ...option.RequestOption) (res *WebP, err error)

When the client requesting the image supports the WebP image codec, and WebP offers a performance advantage over the original image format, Cloudflare will serve a WebP version of the original image.

func (*SettingWebPService) Get 

func (r *SettingWebPService) Get(ctx context.Context, query SettingWebPGetParams, opts ...option.RequestOption) (res *WebP, err error)

When the client requesting the image supports the WebP image codec, and WebP offers a performance advantage over the original image format, Cloudflare will serve a WebP version of the original image.

type SettingWebsocketEditParams 

type SettingWebsocketEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the zone setting.
	Value param.Field[SettingWebsocketEditParamsValue] `json:"value,required"`
}

func (SettingWebsocketEditParams) MarshalJSON 

func (r SettingWebsocketEditParams) MarshalJSON() (data []byte, err error)

type SettingWebsocketEditParamsValue 

type SettingWebsocketEditParamsValue string

Value of the zone setting. 

const (
	SettingWebsocketEditParamsValueOff SettingWebsocketEditParamsValue = "off"
	SettingWebsocketEditParamsValueOn  SettingWebsocketEditParamsValue = "on"
)

func (SettingWebsocketEditParamsValue) IsKnown 

func (r SettingWebsocketEditParamsValue) IsKnown() bool

type SettingWebsocketEditResponseEnvelope 

type SettingWebsocketEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// WebSockets are open connections sustained between the client and the origin
	// server. Inside a WebSockets connection, the client and the origin can pass data
	// back and forth without having to reestablish sessions. This makes exchanging
	// data within a WebSockets connection fast. WebSockets are often used for
	// real-time applications such as live chat and gaming. For more information refer
	// to
	// [Can I use Cloudflare with Websockets](https://support.cloudflare.com/hc/en-us/articles/200169466-Can-I-use-Cloudflare-with-WebSockets-).
	Result Websocket                                `json:"result"`
	JSON   settingWebsocketEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingWebsocketEditResponseEnvelope) UnmarshalJSON 

func (r *SettingWebsocketEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingWebsocketGetParams 

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

type SettingWebsocketGetResponseEnvelope 

type SettingWebsocketGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// WebSockets are open connections sustained between the client and the origin
	// server. Inside a WebSockets connection, the client and the origin can pass data
	// back and forth without having to reestablish sessions. This makes exchanging
	// data within a WebSockets connection fast. WebSockets are often used for
	// real-time applications such as live chat and gaming. For more information refer
	// to
	// [Can I use Cloudflare with Websockets](https://support.cloudflare.com/hc/en-us/articles/200169466-Can-I-use-Cloudflare-with-WebSockets-).
	Result Websocket                               `json:"result"`
	JSON   settingWebsocketGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingWebsocketGetResponseEnvelope) UnmarshalJSON 

func (r *SettingWebsocketGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingWebsocketService 

type SettingWebsocketService struct {
	Options []option.RequestOption
}

SettingWebsocketService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingWebsocketService method instead.

func NewSettingWebsocketService 

func NewSettingWebsocketService(opts ...option.RequestOption) (r *SettingWebsocketService)

NewSettingWebsocketService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingWebsocketService) Edit 

func (r *SettingWebsocketService) Edit(ctx context.Context, params SettingWebsocketEditParams, opts ...option.RequestOption) (res *Websocket, err error)

Changes Websockets setting. For more information about Websockets, please refer to [Using Cloudflare with WebSockets](https://support.cloudflare.com/hc/en-us/articles/200169466-Using-Cloudflare-with-WebSockets).

func (*SettingWebsocketService) Get 

func (r *SettingWebsocketService) Get(ctx context.Context, query SettingWebsocketGetParams, opts ...option.RequestOption) (res *Websocket, err error)

Gets Websockets setting. For more information about Websockets, please refer to [Using Cloudflare with WebSockets](https://support.cloudflare.com/hc/en-us/articles/200169466-Using-Cloudflare-with-WebSockets).

type SettingZeroRTTEditParams 

type SettingZeroRTTEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Value of the 0-RTT setting.
	Value param.Field[SettingZeroRTTEditParamsValue] `json:"value,required"`
}

func (SettingZeroRTTEditParams) MarshalJSON 

func (r SettingZeroRTTEditParams) MarshalJSON() (data []byte, err error)

type SettingZeroRTTEditParamsValue 

type SettingZeroRTTEditParamsValue string

Value of the 0-RTT setting. 

const (
	SettingZeroRTTEditParamsValueOn  SettingZeroRTTEditParamsValue = "on"
	SettingZeroRTTEditParamsValueOff SettingZeroRTTEditParamsValue = "off"
)

func (SettingZeroRTTEditParamsValue) IsKnown 

func (r SettingZeroRTTEditParamsValue) IsKnown() bool

type SettingZeroRTTEditResponseEnvelope 

type SettingZeroRTTEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// 0-RTT session resumption enabled for this zone.
	Result ZeroRTT                                `json:"result"`
	JSON   settingZeroRTTEditResponseEnvelopeJSON `json:"-"`
}

func (*SettingZeroRTTEditResponseEnvelope) UnmarshalJSON 

func (r *SettingZeroRTTEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingZeroRTTGetParams 

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

type SettingZeroRTTGetResponseEnvelope 

type SettingZeroRTTGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool `json:"success,required"`
	// 0-RTT session resumption enabled for this zone.
	Result ZeroRTT                               `json:"result"`
	JSON   settingZeroRTTGetResponseEnvelopeJSON `json:"-"`
}

func (*SettingZeroRTTGetResponseEnvelope) UnmarshalJSON 

func (r *SettingZeroRTTGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SettingZeroRTTService 

type SettingZeroRTTService struct {
	Options []option.RequestOption
}

SettingZeroRTTService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSettingZeroRTTService method instead.

func NewSettingZeroRTTService 

func NewSettingZeroRTTService(opts ...option.RequestOption) (r *SettingZeroRTTService)

NewSettingZeroRTTService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SettingZeroRTTService) Edit 

func (r *SettingZeroRTTService) Edit(ctx context.Context, params SettingZeroRTTEditParams, opts ...option.RequestOption) (res *ZeroRTT, err error)

Changes the 0-RTT session resumption setting.

func (*SettingZeroRTTService) Get 

func (r *SettingZeroRTTService) Get(ctx context.Context, query SettingZeroRTTGetParams, opts ...option.RequestOption) (res *ZeroRTT, err error)

Gets 0-RTT session resumption setting.

type SortQueryStringForCache 

type SortQueryStringForCache struct {
	// ID of the zone setting.
	ID SortQueryStringForCacheID `json:"id,required"`
	// Current value of the zone setting.
	Value SortQueryStringForCacheValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable SortQueryStringForCacheEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time                   `json:"modified_on,nullable" format:"date-time"`
	JSON       sortQueryStringForCacheJSON `json:"-"`
}

Cloudflare will treat files with the same query strings as the same file in cache, regardless of the order of the query strings. This is limited to Enterprise Zones.

func (*SortQueryStringForCache) UnmarshalJSON 

func (r *SortQueryStringForCache) UnmarshalJSON(data []byte) (err error)

type SortQueryStringForCacheEditable 

type SortQueryStringForCacheEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	SortQueryStringForCacheEditableTrue  SortQueryStringForCacheEditable = true
	SortQueryStringForCacheEditableFalse SortQueryStringForCacheEditable = false
)

func (SortQueryStringForCacheEditable) IsKnown 

func (r SortQueryStringForCacheEditable) IsKnown() bool

type SortQueryStringForCacheID 

type SortQueryStringForCacheID string

ID of the zone setting. 

const (
	SortQueryStringForCacheIDSortQueryStringForCache SortQueryStringForCacheID = "sort_query_string_for_cache"
)

func (SortQueryStringForCacheID) IsKnown 

func (r SortQueryStringForCacheID) IsKnown() bool

type SortQueryStringForCacheValue 

type SortQueryStringForCacheValue string

Current value of the zone setting. 

const (
	SortQueryStringForCacheValueOn  SortQueryStringForCacheValue = "on"
	SortQueryStringForCacheValueOff SortQueryStringForCacheValue = "off"
)

func (SortQueryStringForCacheValue) IsKnown 

func (r SortQueryStringForCacheValue) IsKnown() bool

type SubscriptionGetResponseEnvelope 

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

func (*SubscriptionGetResponseEnvelope) UnmarshalJSON 

func (r *SubscriptionGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SubscriptionGetResponseEnvelopeSuccess 

type SubscriptionGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	SubscriptionGetResponseEnvelopeSuccessTrue SubscriptionGetResponseEnvelopeSuccess = true
)

func (SubscriptionGetResponseEnvelopeSuccess) IsKnown 

func (r SubscriptionGetResponseEnvelopeSuccess) IsKnown() bool

type SubscriptionGetResponseUnion 

type SubscriptionGetResponseUnion interface {
	ImplementsZonesSubscriptionGetResponseUnion()
}

Union satisfied by zones.SubscriptionGetResponseUnknown or shared.UnionString.

type SubscriptionNewParams 

type SubscriptionNewParams struct {
	Subscription user.SubscriptionParam `json:"subscription,required"`
}

func (SubscriptionNewParams) MarshalJSON 

func (r SubscriptionNewParams) MarshalJSON() (data []byte, err error)

type SubscriptionNewResponseEnvelope 

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

func (*SubscriptionNewResponseEnvelope) UnmarshalJSON 

func (r *SubscriptionNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type SubscriptionNewResponseEnvelopeSuccess 

type SubscriptionNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	SubscriptionNewResponseEnvelopeSuccessTrue SubscriptionNewResponseEnvelopeSuccess = true
)

func (SubscriptionNewResponseEnvelopeSuccess) IsKnown 

func (r SubscriptionNewResponseEnvelopeSuccess) IsKnown() bool

type SubscriptionNewResponseUnion 

type SubscriptionNewResponseUnion interface {
	ImplementsZonesSubscriptionNewResponseUnion()
}

Union satisfied by zones.SubscriptionNewResponseUnknown or shared.UnionString.

type SubscriptionService 

type SubscriptionService struct {
	Options []option.RequestOption
}

SubscriptionService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSubscriptionService method instead.

func NewSubscriptionService 

func NewSubscriptionService(opts ...option.RequestOption) (r *SubscriptionService)

NewSubscriptionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SubscriptionService) Get 

func (r *SubscriptionService) Get(ctx context.Context, identifier string, opts ...option.RequestOption) (res *SubscriptionGetResponseUnion, err error)

Lists zone subscription details.

func (*SubscriptionService) List 

func (r *SubscriptionService) List(ctx context.Context, accountIdentifier string, opts ...option.RequestOption) (res *pagination.SinglePage[user.Subscription], err error)

Lists all of an account's subscriptions.

func (*SubscriptionService) ListAutoPaging 

func (r *SubscriptionService) ListAutoPaging(ctx context.Context, accountIdentifier string, opts ...option.RequestOption) *pagination.SinglePageAutoPager[user.Subscription]

Lists all of an account's subscriptions.

func (*SubscriptionService) New 

func (r *SubscriptionService) New(ctx context.Context, identifier string, body SubscriptionNewParams, opts ...option.RequestOption) (res *SubscriptionNewResponseUnion, err error)

Create a zone subscription, either plan or add-ons.

type TLS1_3 

type TLS1_3 struct {
	// ID of the zone setting.
	ID TLS1_3ID `json:"id,required"`
	// Current value of the zone setting.
	Value TLS1_3Value `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable TLS1_3Editable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time  `json:"modified_on,nullable" format:"date-time"`
	JSON       tls1_3JSON `json:"-"`
}

Enables Crypto TLS 1.3 feature for a zone.

func (*TLS1_3) UnmarshalJSON 

func (r *TLS1_3) UnmarshalJSON(data []byte) (err error)

type TLS1_3Editable 

type TLS1_3Editable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	TLS1_3EditableTrue  TLS1_3Editable = true
	TLS1_3EditableFalse TLS1_3Editable = false
)

func (TLS1_3Editable) IsKnown 

func (r TLS1_3Editable) IsKnown() bool

type TLS1_3ID 

type TLS1_3ID string

ID of the zone setting. 

const (
	TLS1_3IDTLS1_3 TLS1_3ID = "tls_1_3"
)

func (TLS1_3ID) IsKnown 

func (r TLS1_3ID) IsKnown() bool

type TLS1_3Value 

type TLS1_3Value string

Current value of the zone setting. 

const (
	TLS1_3ValueOn  TLS1_3Value = "on"
	TLS1_3ValueOff TLS1_3Value = "off"
	TLS1_3ValueZrt TLS1_3Value = "zrt"
)

func (TLS1_3Value) IsKnown 

func (r TLS1_3Value) IsKnown() bool

type TLSClientAuth 

type TLSClientAuth struct {
	// ID of the zone setting.
	ID TLSClientAuthID `json:"id,required"`
	// Current value of the zone setting.
	Value TLSClientAuthValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable TLSClientAuthEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time         `json:"modified_on,nullable" format:"date-time"`
	JSON       tlsClientAuthJSON `json:"-"`
}

TLS Client Auth requires Cloudflare to connect to your origin server using a client certificate (Enterprise Only).

func (*TLSClientAuth) UnmarshalJSON 

func (r *TLSClientAuth) UnmarshalJSON(data []byte) (err error)

type TLSClientAuthEditable 

type TLSClientAuthEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	TLSClientAuthEditableTrue  TLSClientAuthEditable = true
	TLSClientAuthEditableFalse TLSClientAuthEditable = false
)

func (TLSClientAuthEditable) IsKnown 

func (r TLSClientAuthEditable) IsKnown() bool

type TLSClientAuthID 

type TLSClientAuthID string

ID of the zone setting. 

const (
	TLSClientAuthIDTLSClientAuth TLSClientAuthID = "tls_client_auth"
)

func (TLSClientAuthID) IsKnown 

func (r TLSClientAuthID) IsKnown() bool

type TLSClientAuthValue 

type TLSClientAuthValue string

Current value of the zone setting. 

const (
	TLSClientAuthValueOn  TLSClientAuthValue = "on"
	TLSClientAuthValueOff TLSClientAuthValue = "off"
)

func (TLSClientAuthValue) IsKnown 

func (r TLSClientAuthValue) IsKnown() bool

type TrueClientIPHeader 

type TrueClientIPHeader struct {
	// ID of the zone setting.
	ID TrueClientIPHeaderID `json:"id,required"`
	// Current value of the zone setting.
	Value TrueClientIPHeaderValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable TrueClientIPHeaderEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time              `json:"modified_on,nullable" format:"date-time"`
	JSON       trueClientIPHeaderJSON `json:"-"`
}

Allows customer to continue to use True Client IP (Akamai feature) in the headers we send to the origin. This is limited to Enterprise Zones.

func (*TrueClientIPHeader) UnmarshalJSON 

func (r *TrueClientIPHeader) UnmarshalJSON(data []byte) (err error)

type TrueClientIPHeaderEditable 

type TrueClientIPHeaderEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	TrueClientIPHeaderEditableTrue  TrueClientIPHeaderEditable = true
	TrueClientIPHeaderEditableFalse TrueClientIPHeaderEditable = false
)

func (TrueClientIPHeaderEditable) IsKnown 

func (r TrueClientIPHeaderEditable) IsKnown() bool

type TrueClientIPHeaderID 

type TrueClientIPHeaderID string

ID of the zone setting. 

const (
	TrueClientIPHeaderIDTrueClientIPHeader TrueClientIPHeaderID = "true_client_ip_header"
)

func (TrueClientIPHeaderID) IsKnown 

func (r TrueClientIPHeaderID) IsKnown() bool

type TrueClientIPHeaderValue 

type TrueClientIPHeaderValue string

Current value of the zone setting. 

const (
	TrueClientIPHeaderValueOn  TrueClientIPHeaderValue = "on"
	TrueClientIPHeaderValueOff TrueClientIPHeaderValue = "off"
)

func (TrueClientIPHeaderValue) IsKnown 

func (r TrueClientIPHeaderValue) IsKnown() bool

type WAF 

type WAF struct {
	// ID of the zone setting.
	ID WAFID `json:"id,required"`
	// Current value of the zone setting.
	Value WAFValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable WAFEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,nullable" format:"date-time"`
	JSON       wafJSON   `json:"-"`
}

The WAF examines HTTP requests to your website. It inspects both GET and POST requests and applies rules to help filter out illegitimate traffic from legitimate website visitors. The Cloudflare WAF inspects website addresses or URLs to detect anything out of the ordinary. If the Cloudflare WAF determines suspicious user behavior, then the WAF will 'challenge' the web visitor with a page that asks them to submit a CAPTCHA successfully to continue their action. If the challenge is failed, the action will be stopped. What this means is that Cloudflare's WAF will block any traffic identified as illegitimate before it reaches your origin web server. (https://support.cloudflare.com/hc/en-us/articles/200172016).

func (*WAF) UnmarshalJSON 

func (r *WAF) UnmarshalJSON(data []byte) (err error)

type WAFEditable 

type WAFEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	WAFEditableTrue  WAFEditable = true
	WAFEditableFalse WAFEditable = false
)

func (WAFEditable) IsKnown 

func (r WAFEditable) IsKnown() bool

type WAFID 

type WAFID string

ID of the zone setting. 

const (
	WAFIDWAF WAFID = "waf"
)

func (WAFID) IsKnown 

func (r WAFID) IsKnown() bool

type WAFValue 

type WAFValue string

Current value of the zone setting. 

const (
	WAFValueOn  WAFValue = "on"
	WAFValueOff WAFValue = "off"
)

func (WAFValue) IsKnown 

func (r WAFValue) IsKnown() bool

type WebP 

type WebP struct {
	// ID of the zone setting.
	ID WebPID `json:"id,required"`
	// Current value of the zone setting.
	Value WebPValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable WebPEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time `json:"modified_on,nullable" format:"date-time"`
	JSON       WebPJSON  `json:"-"`
}

When the client requesting the image supports the WebP image codec, and WebP offers a performance advantage over the original image format, Cloudflare will serve a WebP version of the original image.

func (*WebP) UnmarshalJSON 

func (r *WebP) UnmarshalJSON(data []byte) (err error)

type WebPEditable 

type WebPEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	WebPEditableTrue  WebPEditable = true
	WebPEditableFalse WebPEditable = false
)

func (WebPEditable) IsKnown 

func (r WebPEditable) IsKnown() bool

type WebPID 

type WebPID string

ID of the zone setting. 

const (
	WebPIDWebP WebPID = "webp"
)

func (WebPID) IsKnown 

func (r WebPID) IsKnown() bool

type WebPJSON 

type WebPJSON struct {
	ID         apijson.Field
	Value      apijson.Field
	Editable   apijson.Field
	ModifiedOn apijson.Field

	ExtraFields map[string]apijson.Field
	// contains filtered or unexported fields
}

WebPJSON contains the JSON metadata for the struct WebP

func (WebPJSON) RawJSON 

func (r WebPJSON) RawJSON() string

type WebPValue 

type WebPValue string

Current value of the zone setting. 

const (
	WebPValueOff WebPValue = "off"
	WebPValueOn  WebPValue = "on"
)

func (WebPValue) IsKnown 

func (r WebPValue) IsKnown() bool

type Websocket 

type Websocket struct {
	// ID of the zone setting.
	ID WebsocketID `json:"id,required"`
	// Current value of the zone setting.
	Value WebsocketValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable WebsocketEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time     `json:"modified_on,nullable" format:"date-time"`
	JSON       websocketJSON `json:"-"`
}

WebSockets are open connections sustained between the client and the origin server. Inside a WebSockets connection, the client and the origin can pass data back and forth without having to reestablish sessions. This makes exchanging data within a WebSockets connection fast. WebSockets are often used for real-time applications such as live chat and gaming. For more information refer to [Can I use Cloudflare with Websockets](https://support.cloudflare.com/hc/en-us/articles/200169466-Can-I-use-Cloudflare-with-WebSockets-).

func (*Websocket) UnmarshalJSON 

func (r *Websocket) UnmarshalJSON(data []byte) (err error)

type WebsocketEditable 

type WebsocketEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	WebsocketEditableTrue  WebsocketEditable = true
	WebsocketEditableFalse WebsocketEditable = false
)

func (WebsocketEditable) IsKnown 

func (r WebsocketEditable) IsKnown() bool

type WebsocketID 

type WebsocketID string

ID of the zone setting. 

const (
	WebsocketIDWebsockets WebsocketID = "websockets"
)

func (WebsocketID) IsKnown 

func (r WebsocketID) IsKnown() bool

type WebsocketValue 

type WebsocketValue string

Current value of the zone setting. 

const (
	WebsocketValueOff WebsocketValue = "off"
	WebsocketValueOn  WebsocketValue = "on"
)

func (WebsocketValue) IsKnown 

func (r WebsocketValue) IsKnown() bool

type ZeroRTT 

type ZeroRTT struct {
	// ID of the zone setting.
	ID ZeroRTTID `json:"id,required"`
	// Current value of the zone setting.
	Value ZeroRTTValue `json:"value,required"`
	// Whether or not this setting can be modified for this zone (based on your
	// Cloudflare plan level).
	Editable ZeroRTTEditable `json:"editable"`
	// last time this setting was modified.
	ModifiedOn time.Time   `json:"modified_on,nullable" format:"date-time"`
	JSON       zeroRTTJSON `json:"-"`
}

0-RTT session resumption enabled for this zone.

func (*ZeroRTT) UnmarshalJSON 

func (r *ZeroRTT) UnmarshalJSON(data []byte) (err error)

type ZeroRTTEditable 

type ZeroRTTEditable bool

Whether or not this setting can be modified for this zone (based on your Cloudflare plan level). 

const (
	ZeroRTTEditableTrue  ZeroRTTEditable = true
	ZeroRTTEditableFalse ZeroRTTEditable = false
)

func (ZeroRTTEditable) IsKnown 

func (r ZeroRTTEditable) IsKnown() bool

type ZeroRTTID 

type ZeroRTTID string

ID of the zone setting. 

const (
	ZeroRTTID0rtt ZeroRTTID = "0rtt"
)

func (ZeroRTTID) IsKnown 

func (r ZeroRTTID) IsKnown() bool

type ZeroRTTValue 

type ZeroRTTValue string

Current value of the zone setting. 

const (
	ZeroRTTValueOn  ZeroRTTValue = "on"
	ZeroRTTValueOff ZeroRTTValue = "off"
)

func (ZeroRTTValue) IsKnown 

func (r ZeroRTTValue) IsKnown() bool

type Zone 

type Zone struct {
	// Identifier
	ID string `json:"id,required"`
	// The account the zone belongs to
	Account ZoneAccount `json:"account,required"`
	// The last time proof of ownership was detected and the zone was made active
	ActivatedOn time.Time `json:"activated_on,required,nullable" format:"date-time"`
	// When the zone was created
	CreatedOn time.Time `json:"created_on,required" format:"date-time"`
	// The interval (in seconds) from when development mode expires (positive integer)
	// or last expired (negative integer) for the domain. If development mode has never
	// been enabled, this value is 0.
	DevelopmentMode float64 `json:"development_mode,required"`
	// Metadata about the zone
	Meta ZoneMeta `json:"meta,required"`
	// When the zone was last modified
	ModifiedOn time.Time `json:"modified_on,required" format:"date-time"`
	// The domain name
	Name string `json:"name,required"`
	// DNS host at the time of switching to Cloudflare
	OriginalDnshost string `json:"original_dnshost,required,nullable"`
	// Original name servers before moving to Cloudflare Notes: Is this only available
	// for full zones?
	OriginalNameServers []string `json:"original_name_servers,required,nullable" format:"hostname"`
	// Registrar for the domain at the time of switching to Cloudflare
	OriginalRegistrar string `json:"original_registrar,required,nullable"`
	// The owner of the zone
	Owner ZoneOwner `json:"owner,required"`
	// An array of domains used for custom name servers. This is only available for
	// Business and Enterprise plans.
	VanityNameServers []string `json:"vanity_name_servers" format:"hostname"`
	JSON              zoneJSON `json:"-"`
}

func (*Zone) UnmarshalJSON 

func (r *Zone) UnmarshalJSON(data []byte) (err error)

type ZoneAccount 

type ZoneAccount struct {
	// Identifier
	ID string `json:"id"`
	// The name of the account
	Name string          `json:"name"`
	JSON zoneAccountJSON `json:"-"`
}

The account the zone belongs to

func (*ZoneAccount) UnmarshalJSON 

func (r *ZoneAccount) UnmarshalJSON(data []byte) (err error)

type ZoneDeleteParams 

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

type ZoneDeleteResponse 

type ZoneDeleteResponse struct {
	// Identifier
	ID   string                 `json:"id,required"`
	JSON zoneDeleteResponseJSON `json:"-"`
}

func (*ZoneDeleteResponse) UnmarshalJSON 

func (r *ZoneDeleteResponse) UnmarshalJSON(data []byte) (err error)

type ZoneDeleteResponseEnvelope 

type ZoneDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success bool                           `json:"success,required"`
	Result  ZoneDeleteResponse             `json:"result,nullable"`
	JSON    zoneDeleteResponseEnvelopeJSON `json:"-"`
}

func (*ZoneDeleteResponseEnvelope) UnmarshalJSON 

func (r *ZoneDeleteResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type ZoneEditParams 

type ZoneEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// (Deprecated) Please use the `/zones/{zone_id}/subscription` API to update a
	// zone's plan. Changing this value will create/cancel associated subscriptions. To
	// view available plans for this zone, see Zone Plans.
	Plan param.Field[ZoneEditParamsPlan] `json:"plan"`
	// A full zone implies that DNS is hosted with Cloudflare. A partial zone is
	// typically a partner-hosted zone or a CNAME setup. This parameter is only
	// available to Enterprise customers or if it has been explicitly enabled on a
	// zone.
	Type param.Field[ZoneEditParamsType] `json:"type"`
	// An array of domains used for custom name servers. This is only available for
	// Business and Enterprise plans.
	VanityNameServers param.Field[[]string] `json:"vanity_name_servers" format:"hostname"`
}

func (ZoneEditParams) MarshalJSON 

func (r ZoneEditParams) MarshalJSON() (data []byte, err error)

type ZoneEditParamsPlan 

type ZoneEditParamsPlan struct {
	// Identifier
	ID param.Field[string] `json:"id"`
}

(Deprecated) Please use the `/zones/{zone_id}/subscription` API to update a zone's plan. Changing this value will create/cancel associated subscriptions. To view available plans for this zone, see Zone Plans.

func (ZoneEditParamsPlan) MarshalJSON 

func (r ZoneEditParamsPlan) MarshalJSON() (data []byte, err error)

type ZoneEditParamsType 

type ZoneEditParamsType string

A full zone implies that DNS is hosted with Cloudflare. A partial zone is typically a partner-hosted zone or a CNAME setup. This parameter is only available to Enterprise customers or if it has been explicitly enabled on a zone. 

const (
	ZoneEditParamsTypeFull      ZoneEditParamsType = "full"
	ZoneEditParamsTypePartial   ZoneEditParamsType = "partial"
	ZoneEditParamsTypeSecondary ZoneEditParamsType = "secondary"
)

func (ZoneEditParamsType) IsKnown 

func (r ZoneEditParamsType) IsKnown() bool

type ZoneEditResponseEnvelope 

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

func (*ZoneEditResponseEnvelope) UnmarshalJSON 

func (r *ZoneEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type ZoneGetParams 

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

type ZoneGetResponseEnvelope 

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

func (*ZoneGetResponseEnvelope) UnmarshalJSON 

func (r *ZoneGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type ZoneHold 

type ZoneHold struct {
	Hold              bool         `json:"hold"`
	HoldAfter         string       `json:"hold_after"`
	IncludeSubdomains string       `json:"include_subdomains"`
	JSON              zoneHoldJSON `json:"-"`
}

func (*ZoneHold) UnmarshalJSON 

func (r *ZoneHold) UnmarshalJSON(data []byte) (err error)

type ZoneListParams 

type ZoneListParams struct {
	Account param.Field[ZoneListParamsAccount] `query:"account"`
	// Direction to order zones.
	Direction param.Field[ZoneListParamsDirection] `query:"direction"`
	// Whether to match all search requirements or at least one (any).
	Match param.Field[ZoneListParamsMatch] `query:"match"`
	// A domain name. Optional filter operators can be provided to extend refine the
	// search:
	//
	// - `equal` (default)
	// - `not_equal`
	// - `starts_with`
	// - `ends_with`
	// - `contains`
	// - `starts_with_case_sensitive`
	// - `ends_with_case_sensitive`
	// - `contains_case_sensitive`
	Name param.Field[string] `query:"name"`
	// Field to order zones by.
	Order param.Field[ZoneListParamsOrder] `query:"order"`
	// Page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// Number of zones per page.
	PerPage param.Field[float64] `query:"per_page"`
	// A zone status
	Status param.Field[ZoneListParamsStatus] `query:"status"`
}

func (ZoneListParams) URLQuery 

func (r ZoneListParams) URLQuery() (v url.Values)

URLQuery serializes ZoneListParams's query parameters as `url.Values`.

type ZoneListParamsAccount 

type ZoneListParamsAccount struct {
	// An account ID
	ID param.Field[string] `query:"id"`
	// An account Name. Optional filter operators can be provided to extend refine the
	// search:
	//
	// - `equal` (default)
	// - `not_equal`
	// - `starts_with`
	// - `ends_with`
	// - `contains`
	// - `starts_with_case_sensitive`
	// - `ends_with_case_sensitive`
	// - `contains_case_sensitive`
	Name param.Field[string] `query:"name"`
}

func (ZoneListParamsAccount) URLQuery 

func (r ZoneListParamsAccount) URLQuery() (v url.Values)

URLQuery serializes ZoneListParamsAccount's query parameters as `url.Values`.

type ZoneListParamsDirection 

type ZoneListParamsDirection string

Direction to order zones. 

const (
	ZoneListParamsDirectionAsc  ZoneListParamsDirection = "asc"
	ZoneListParamsDirectionDesc ZoneListParamsDirection = "desc"
)

func (ZoneListParamsDirection) IsKnown 

func (r ZoneListParamsDirection) IsKnown() bool

type ZoneListParamsMatch 

type ZoneListParamsMatch string

Whether to match all search requirements or at least one (any). 

const (
	ZoneListParamsMatchAny ZoneListParamsMatch = "any"
	ZoneListParamsMatchAll ZoneListParamsMatch = "all"
)

func (ZoneListParamsMatch) IsKnown 

func (r ZoneListParamsMatch) IsKnown() bool

type ZoneListParamsOrder 

type ZoneListParamsOrder string

Field to order zones by. 

const (
	ZoneListParamsOrderName        ZoneListParamsOrder = "name"
	ZoneListParamsOrderStatus      ZoneListParamsOrder = "status"
	ZoneListParamsOrderAccountID   ZoneListParamsOrder = "account.id"
	ZoneListParamsOrderAccountName ZoneListParamsOrder = "account.name"
)

func (ZoneListParamsOrder) IsKnown 

func (r ZoneListParamsOrder) IsKnown() bool

type ZoneListParamsStatus 

type ZoneListParamsStatus string

A zone status 

const (
	ZoneListParamsStatusInitializing ZoneListParamsStatus = "initializing"
	ZoneListParamsStatusPending      ZoneListParamsStatus = "pending"
	ZoneListParamsStatusActive       ZoneListParamsStatus = "active"
	ZoneListParamsStatusMoved        ZoneListParamsStatus = "moved"
)

func (ZoneListParamsStatus) IsKnown 

func (r ZoneListParamsStatus) IsKnown() bool

type ZoneMeta 

type ZoneMeta struct {
	// The zone is only configured for CDN
	CDNOnly bool `json:"cdn_only"`
	// Number of Custom Certificates the zone can have
	CustomCertificateQuota int64 `json:"custom_certificate_quota"`
	// The zone is only configured for DNS
	DNSOnly bool `json:"dns_only"`
	// The zone is setup with Foundation DNS
	FoundationDNS bool `json:"foundation_dns"`
	// Number of Page Rules a zone can have
	PageRuleQuota int64 `json:"page_rule_quota"`
	// The zone has been flagged for phishing
	PhishingDetected bool         `json:"phishing_detected"`
	Step             int64        `json:"step"`
	JSON             zoneMetaJSON `json:"-"`
}

Metadata about the zone

func (*ZoneMeta) UnmarshalJSON 

func (r *ZoneMeta) UnmarshalJSON(data []byte) (err error)

type ZoneNewParams 

type ZoneNewParams struct {
	Account param.Field[ZoneNewParamsAccount] `json:"account,required"`
	// The domain name
	Name param.Field[string] `json:"name,required"`
	// A full zone implies that DNS is hosted with Cloudflare. A partial zone is
	// typically a partner-hosted zone or a CNAME setup.
	Type param.Field[ZoneNewParamsType] `json:"type"`
}

func (ZoneNewParams) MarshalJSON 

func (r ZoneNewParams) MarshalJSON() (data []byte, err error)

type ZoneNewParamsAccount 

type ZoneNewParamsAccount struct {
	// Identifier
	ID param.Field[string] `json:"id"`
}

func (ZoneNewParamsAccount) MarshalJSON 

func (r ZoneNewParamsAccount) MarshalJSON() (data []byte, err error)

type ZoneNewParamsType 

type ZoneNewParamsType string

A full zone implies that DNS is hosted with Cloudflare. A partial zone is typically a partner-hosted zone or a CNAME setup. 

const (
	ZoneNewParamsTypeFull      ZoneNewParamsType = "full"
	ZoneNewParamsTypePartial   ZoneNewParamsType = "partial"
	ZoneNewParamsTypeSecondary ZoneNewParamsType = "secondary"
)

func (ZoneNewParamsType) IsKnown 

func (r ZoneNewParamsType) IsKnown() bool

type ZoneNewResponseEnvelope 

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

func (*ZoneNewResponseEnvelope) UnmarshalJSON 

func (r *ZoneNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type ZoneOwner 

type ZoneOwner struct {
	// Identifier
	ID string `json:"id"`
	// Name of the owner
	Name string `json:"name"`
	// The type of owner
	Type string        `json:"type"`
	JSON zoneOwnerJSON `json:"-"`
}

The owner of the zone

func (*ZoneOwner) UnmarshalJSON 

func (r *ZoneOwner) UnmarshalJSON(data []byte) (err error)

type ZoneService 

type ZoneService struct {
	Options           []option.RequestOption
	ActivationCheck   *ActivationCheckService
	DNSSettings       *DNSSettingService
	Settings          *SettingService
	CustomNameservers *CustomNameserverService
	Holds             *HoldService
	Subscriptions     *SubscriptionService
}

ZoneService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewZoneService method instead.

func NewZoneService 

func NewZoneService(opts ...option.RequestOption) (r *ZoneService)

NewZoneService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ZoneService) Delete 

func (r *ZoneService) Delete(ctx context.Context, body ZoneDeleteParams, opts ...option.RequestOption) (res *ZoneDeleteResponse, err error)

Deletes an existing zone.

func (*ZoneService) Edit 

func (r *ZoneService) Edit(ctx context.Context, params ZoneEditParams, opts ...option.RequestOption) (res *Zone, err error)

Edits a zone. Only one zone property can be changed at a time.

func (*ZoneService) Get 

func (r *ZoneService) Get(ctx context.Context, query ZoneGetParams, opts ...option.RequestOption) (res *Zone, err error)

Zone Details

func (*ZoneService) List 

func (r *ZoneService) List(ctx context.Context, query ZoneListParams, opts ...option.RequestOption) (res *pagination.V4PagePaginationArray[Zone], err error)

Lists, searches, sorts, and filters your zones.

func (*ZoneService) ListAutoPaging 

func (r *ZoneService) ListAutoPaging(ctx context.Context, query ZoneListParams, opts ...option.RequestOption) *pagination.V4PagePaginationArrayAutoPager[Zone]

Lists, searches, sorts, and filters your zones.

func (*ZoneService) New 

func (r *ZoneService) New(ctx context.Context, body ZoneNewParams, opts ...option.RequestOption) (res *Zone, err error)

Create Zone

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.