page_rules

type ASN = shared.ASN

type ASNParam = shared.ASNParam

type AuditLog = shared.AuditLog

type AuditLogAction = shared.AuditLogAction

type AuditLogActor = shared.AuditLogActor

type AuditLogActorType = shared.AuditLogActorType

type AuditLogOwner = shared.AuditLogOwner

type AuditLogResource = shared.AuditLogResource

type CertificateCA = shared.CertificateCA

type CertificateRequestType = shared.CertificateRequestType

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelStatus = shared.CloudflareTunnelStatus

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type Error = apierror.Error

type ErrorData = shared.ErrorData

type ErrorDataSource = shared.ErrorDataSource

type Member = shared.Member

type MemberPoliciesAccess = shared.MemberPoliciesAccess

type MemberPoliciesPermissionGroup = shared.MemberPoliciesPermissionGroup

type MemberPoliciesPermissionGroupsMeta = shared.MemberPoliciesPermissionGroupsMeta

type MemberPoliciesResourceGroup = shared.MemberPoliciesResourceGroup

type MemberPoliciesResourceGroupsMeta = shared.MemberPoliciesResourceGroupsMeta

type MemberPoliciesResourceGroupsScope = shared.MemberPoliciesResourceGroupsScope

type MemberPoliciesResourceGroupsScopeObject = shared.MemberPoliciesResourceGroupsScopeObject

type MemberPolicy = shared.MemberPolicy

type MemberStatus = shared.MemberStatus

type MemberUser = shared.MemberUser

type PageRule struct {
	// Identifier.
	ID string `json:"id,required"`
	// The set of actions to perform if the targets of this rule match the request.
	// Actions can redirect to another URL or override settings, but not both.
	Actions []PageRuleAction `json:"actions,required"`
	// The timestamp of when the Page Rule was created.
	CreatedOn time.Time `json:"created_on,required" format:"date-time"`
	// The timestamp of when the Page Rule was last modified.
	ModifiedOn time.Time `json:"modified_on,required" format:"date-time"`
	// The priority of the rule, used to define which Page Rule is processed over
	// another. A higher number indicates a higher priority. For example, if you have a
	// catch-all Page Rule (rule A: `/images/*`) but want a more specific Page Rule to
	// take precedence (rule B: `/images/special/*`), specify a higher priority for
	// rule B so it overrides rule A.
	Priority int64 `json:"priority,required"`
	// The status of the Page Rule.
	Status PageRuleStatus `json:"status,required"`
	// The rule targets to evaluate on each request.
	Targets []Target     `json:"targets,required"`
	JSON    pageRuleJSON `json:"-"`
}

type PageRuleAction struct {
	// If enabled, any ` http://“ URL is converted to  `https://` through a 301
	// redirect.
	ID PageRuleActionsID `json:"id"`
	// This field can have the runtime type of [zones.AutomaticHTTPSRewritesValue],
	// [int64], [zones.BrowserCheckValue], [string],
	// [PageRuleActionsCacheByDeviceTypeValue],
	// [PageRuleActionsCacheDeceptionArmorValue], [PageRuleActionsCacheKeyFieldsValue],
	// [zones.CacheLevelValue], [map[string]PageRuleActionsCacheTTLByStatusValueUnion],
	// [zones.EmailObfuscationValue], [PageRuleActionsExplicitCacheControlValue],
	// [PageRuleActionsForwardingURLValue], [zones.IPGeolocationValue],
	// [zones.MirageValue], [zones.OpportunisticEncryptionValue],
	// [zones.OriginErrorPagePassThruValue], [zones.PolishValue],
	// [PageRuleActionsRespectStrongEtagValue], [zones.ResponseBufferingValue],
	// [zones.RocketLoaderValue], [zones.SecurityLevelValue],
	// [zones.SortQueryStringForCacheValue], [zones.SSLValue],
	// [zones.TrueClientIPHeaderValue], [zones.WAFValue].
	Value interface{}        `json:"value"`
	JSON  pageRuleActionJSON `json:"-"`
	// contains filtered or unexported fields
}

type PageRuleActionsBypassCacheOnCookie struct {
	// Bypass cache and fetch resources from the origin server if a regular expression
	// matches against a cookie name present in the request.
	ID PageRuleActionsBypassCacheOnCookieID `json:"id"`
	// The regular expression to use for matching cookie names in the request. Refer to
	// [Bypass Cache on Cookie setting](https://developers.cloudflare.com/rules/page-rules/reference/additional-reference/#bypass-cache-on-cookie-setting)
	// to learn about limited regular expression support.
	Value string                                 `json:"value"`
	JSON  pageRuleActionsBypassCacheOnCookieJSON `json:"-"`
}

type PageRuleActionsBypassCacheOnCookieID string

type PageRuleActionsCacheByDeviceType struct {
	// Separate cached content based on the visitor's device type.
	ID PageRuleActionsCacheByDeviceTypeID `json:"id"`
	// The status of Cache By Device Type.
	Value PageRuleActionsCacheByDeviceTypeValue `json:"value"`
	JSON  pageRuleActionsCacheByDeviceTypeJSON  `json:"-"`
}

type PageRuleActionsCacheByDeviceTypeID string

type PageRuleActionsCacheByDeviceTypeValue string

type PageRuleActionsCacheDeceptionArmor struct {
	// Protect from web cache deception attacks while still allowing static assets to
	// be cached. This setting verifies that the URL's extension matches the returned
	// `Content-Type`.
	ID PageRuleActionsCacheDeceptionArmorID `json:"id"`
	// The status of Cache Deception Armor.
	Value PageRuleActionsCacheDeceptionArmorValue `json:"value"`
	JSON  pageRuleActionsCacheDeceptionArmorJSON  `json:"-"`
}

type PageRuleActionsCacheDeceptionArmorID string

type PageRuleActionsCacheDeceptionArmorValue string

type PageRuleActionsCacheKeyFields struct {
	// Control specifically what variables to include when deciding which resources to
	// cache. This allows customers to determine what to cache based on something other
	// than just the URL.
	ID    PageRuleActionsCacheKeyFieldsID    `json:"id"`
	Value PageRuleActionsCacheKeyFieldsValue `json:"value"`
	JSON  pageRuleActionsCacheKeyFieldsJSON  `json:"-"`
}

type PageRuleActionsCacheKeyFieldsID string

type PageRuleActionsCacheKeyFieldsValue struct {
	// Controls which cookies appear in the Cache Key.
	Cookie PageRuleActionsCacheKeyFieldsValueCookie `json:"cookie"`
	// Controls which headers go into the Cache Key. Exactly one of `include` or
	// `exclude` is expected.
	Header PageRuleActionsCacheKeyFieldsValueHeader `json:"header"`
	// Determines which host header to include in the Cache Key.
	Host PageRuleActionsCacheKeyFieldsValueHost `json:"host"`
	// Controls which URL query string parameters go into the Cache Key. Exactly one of
	// `include` or `exclude` is expected.
	QueryString PageRuleActionsCacheKeyFieldsValueQueryString `json:"query_string"`
	// Feature fields to add features about the end-user (client) into the Cache Key.
	User PageRuleActionsCacheKeyFieldsValueUser `json:"user"`
	JSON pageRuleActionsCacheKeyFieldsValueJSON `json:"-"`
}

type PageRuleActionsCacheKeyFieldsValueCookie struct {
	// A list of cookies to check for the presence of, without including their actual
	// values.
	CheckPresence []string `json:"check_presence"`
	// A list of cookies to include.
	Include []string                                     `json:"include"`
	JSON    pageRuleActionsCacheKeyFieldsValueCookieJSON `json:"-"`
}

type PageRuleActionsCacheKeyFieldsValueHeader struct {
	// A list of headers to check for the presence of, without including their actual
	// values.
	CheckPresence []string `json:"check_presence"`
	// A list of headers to ignore.
	Exclude []string `json:"exclude"`
	// A list of headers to include.
	Include []string                                     `json:"include"`
	JSON    pageRuleActionsCacheKeyFieldsValueHeaderJSON `json:"-"`
}

type PageRuleActionsCacheKeyFieldsValueHost struct {
	// Whether to include the Host header in the HTTP request sent to the origin.
	Resolved bool                                       `json:"resolved"`
	JSON     pageRuleActionsCacheKeyFieldsValueHostJSON `json:"-"`
}

type PageRuleActionsCacheKeyFieldsValueQueryString struct {
	// Ignore all query string parameters.
	Exclude PageRuleActionsCacheKeyFieldsValueQueryStringExcludeUnion `json:"exclude"`
	// Include all query string parameters.
	Include PageRuleActionsCacheKeyFieldsValueQueryStringIncludeUnion `json:"include"`
	JSON    pageRuleActionsCacheKeyFieldsValueQueryStringJSON         `json:"-"`
}

type PageRuleActionsCacheKeyFieldsValueQueryStringExcludeArray []string

type PageRuleActionsCacheKeyFieldsValueQueryStringExcludeString string

type PageRuleActionsCacheKeyFieldsValueQueryStringExcludeUnion interface {
	// contains filtered or unexported methods
}

type PageRuleActionsCacheKeyFieldsValueQueryStringIncludeArray []string

type PageRuleActionsCacheKeyFieldsValueQueryStringIncludeString string

type PageRuleActionsCacheKeyFieldsValueQueryStringIncludeUnion interface {
	// contains filtered or unexported methods
}

type PageRuleActionsCacheKeyFieldsValueUser struct {
	// Classifies a request as `mobile`, `desktop`, or `tablet` based on the User
	// Agent.
	DeviceType bool `json:"device_type"`
	// Includes the client's country, derived from the IP address.
	Geo bool `json:"geo"`
	// Includes the first language code contained in the `Accept-Language` header sent
	// by the client.
	Lang bool                                       `json:"lang"`
	JSON pageRuleActionsCacheKeyFieldsValueUserJSON `json:"-"`
}

type PageRuleActionsCacheOnCookie struct {
	// Apply the Cache Everything option (Cache Level setting) based on a regular
	// expression match against a cookie name.
	ID PageRuleActionsCacheOnCookieID `json:"id"`
	// The regular expression to use for matching cookie names in the request.
	Value string                           `json:"value"`
	JSON  pageRuleActionsCacheOnCookieJSON `json:"-"`
}

type PageRuleActionsCacheOnCookieID string

type PageRuleActionsCacheTTLByStatus struct {
	// Enterprise customers can set cache time-to-live (TTL) based on the response
	// status from the origin web server. Cache TTL refers to the duration of a
	// resource in the Cloudflare network before being marked as stale or discarded
	// from cache. Status codes are returned by a resource's origin. Setting cache TTL
	// based on response status overrides the default cache behavior (standard caching)
	// for static files and overrides cache instructions sent by the origin web server.
	// To cache non-static assets, set a Cache Level of Cache Everything using a Page
	// Rule. Setting no-store Cache-Control or a low TTL (using `max-age`/`s-maxage`)
	// increases requests to origin web servers and decreases performance.
	ID PageRuleActionsCacheTTLByStatusID `json:"id"`
	// A JSON object containing status codes and their corresponding TTLs. Each
	// key-value pair in the cache TTL by status cache rule has the following syntax
	//
	//   - `status_code`: An integer value such as 200 or 500. status_code matches the
	//     exact status code from the origin web server. Valid status codes are between
	//     100-999.
	//   - `status_code_range`: Integer values for from and to. status_code_range matches
	//     any status code from the origin web server within the specified range.
	//   - `value`: An integer value that defines the duration an asset is valid in
	//     seconds or one of the following strings: no-store (equivalent to -1), no-cache
	//     (equivalent to 0).
	Value map[string]PageRuleActionsCacheTTLByStatusValueUnion `json:"value"`
	JSON  pageRuleActionsCacheTTLByStatusJSON                  `json:"-"`
}

type PageRuleActionsCacheTTLByStatusID string

type PageRuleActionsCacheTTLByStatusValueString string

type PageRuleActionsCacheTTLByStatusValueUnion interface {
	ImplementsPageRuleActionsCacheTTLByStatusValueUnion()
}

type PageRuleActionsDisableApps struct {
	// Turn off all active
	// [Cloudflare Apps](https://developers.cloudflare.com/support/more-dashboard-apps/cloudflare-apps/)
	// (deprecated).
	ID   PageRuleActionsDisableAppsID   `json:"id"`
	JSON pageRuleActionsDisableAppsJSON `json:"-"`
}

type PageRuleActionsDisableAppsID string

type PageRuleActionsDisablePerformance struct {
	// Turn off
	// [Rocket Loader](https://developers.cloudflare.com/speed/optimization/content/rocket-loader/),
	// [Mirage](https://developers.cloudflare.com/speed/optimization/images/mirage/),
	// and [Polish](https://developers.cloudflare.com/images/polish/).
	ID   PageRuleActionsDisablePerformanceID   `json:"id"`
	JSON pageRuleActionsDisablePerformanceJSON `json:"-"`
}

type PageRuleActionsDisablePerformanceID string

type PageRuleActionsDisableSecurity struct {
	// Turn off
	// [Email Obfuscation](https://developers.cloudflare.com/waf/tools/scrape-shield/email-address-obfuscation/),
	// [Rate Limiting (previous version, deprecated)](https://developers.cloudflare.com/waf/reference/legacy/old-rate-limiting/),
	// [Scrape Shield](https://developers.cloudflare.com/waf/tools/scrape-shield/),
	// [URL (Zone) Lockdown](https://developers.cloudflare.com/waf/tools/zone-lockdown/),
	// and
	// [WAF managed rules (previous version, deprecated)](https://developers.cloudflare.com/waf/reference/legacy/old-waf-managed-rules/).
	ID   PageRuleActionsDisableSecurityID   `json:"id"`
	JSON pageRuleActionsDisableSecurityJSON `json:"-"`
}

type PageRuleActionsDisableSecurityID string

type PageRuleActionsDisableZaraz struct {
	// Turn off [Zaraz](https://developers.cloudflare.com/zaraz/).
	ID   PageRuleActionsDisableZarazID   `json:"id"`
	JSON pageRuleActionsDisableZarazJSON `json:"-"`
}

type PageRuleActionsDisableZarazID string

type PageRuleActionsEdgeCacheTTL struct {
	// Specify how long to cache a resource in the Cloudflare global network. _Edge
	// Cache TTL_ is not visible in response headers.
	ID    PageRuleActionsEdgeCacheTTLID   `json:"id"`
	Value int64                           `json:"value"`
	JSON  pageRuleActionsEdgeCacheTTLJSON `json:"-"`
}

type PageRuleActionsEdgeCacheTTLID string

type PageRuleActionsExplicitCacheControl struct {
	// Origin Cache Control is enabled by default for Free, Pro, and Business domains
	// and disabled by default for Enterprise domains.
	ID PageRuleActionsExplicitCacheControlID `json:"id"`
	// The status of Origin Cache Control.
	Value PageRuleActionsExplicitCacheControlValue `json:"value"`
	JSON  pageRuleActionsExplicitCacheControlJSON  `json:"-"`
}

type PageRuleActionsExplicitCacheControlID string

type PageRuleActionsExplicitCacheControlValue string

type PageRuleActionsForwardingURL struct {
	// Redirects one URL to another using an `HTTP 301/302` redirect. Refer to
	// [Wildcard matching and referencing](https://developers.cloudflare.com/rules/page-rules/reference/wildcard-matching/).
	ID    PageRuleActionsForwardingURLID    `json:"id"`
	Value PageRuleActionsForwardingURLValue `json:"value"`
	JSON  pageRuleActionsForwardingURLJSON  `json:"-"`
}

type PageRuleActionsForwardingURLID string

type PageRuleActionsForwardingURLValue struct {
	// The status code to use for the URL redirect. 301 is a permanent redirect. 302 is
	// a temporary redirect.
	StatusCode PageRuleActionsForwardingURLValueStatusCode `json:"status_code"`
	// The URL to redirect the request to. Notes: ${num} refers to the position of '\*'
	// in the constraint value.
	URL  string                                `json:"url"`
	JSON pageRuleActionsForwardingURLValueJSON `json:"-"`
}

type PageRuleActionsForwardingURLValueStatusCode int64

type PageRuleActionsHostHeaderOverride struct {
	// Apply a specific host header.
	ID PageRuleActionsHostHeaderOverrideID `json:"id"`
	// The hostname to use in the `Host` header
	Value string                                `json:"value"`
	JSON  pageRuleActionsHostHeaderOverrideJSON `json:"-"`
}

type PageRuleActionsHostHeaderOverrideID string

type PageRuleActionsID string

type PageRuleActionsResolveOverride struct {
	// Change the origin address to the value specified in this setting.
	ID PageRuleActionsResolveOverrideID `json:"id"`
	// The origin address you want to override with.
	Value string                             `json:"value"`
	JSON  pageRuleActionsResolveOverrideJSON `json:"-"`
}

type PageRuleActionsResolveOverrideID string

type PageRuleActionsRespectStrongEtag struct {
	// Turn on or off byte-for-byte equivalency checks between the Cloudflare cache and
	// the origin server.
	ID PageRuleActionsRespectStrongEtagID `json:"id"`
	// The status of Respect Strong ETags
	Value PageRuleActionsRespectStrongEtagValue `json:"value"`
	JSON  pageRuleActionsRespectStrongEtagJSON  `json:"-"`
}

type PageRuleActionsRespectStrongEtagID string

type PageRuleActionsRespectStrongEtagValue string

type PageRuleActionsUnion interface {
	ImplementsPageRuleAction()
}

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

type PageRuleDeleteResponse struct {
	// Identifier.
	ID   string                     `json:"id,required"`
	JSON pageRuleDeleteResponseJSON `json:"-"`
}

type PageRuleDeleteResponseEnvelope struct {
	Errors   []PageRuleDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PageRuleDeleteResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success PageRuleDeleteResponseEnvelopeSuccess `json:"success,required"`
	Result  PageRuleDeleteResponse                `json:"result,nullable"`
	JSON    pageRuleDeleteResponseEnvelopeJSON    `json:"-"`
}

type PageRuleDeleteResponseEnvelopeErrors struct {
	Code             int64                                      `json:"code,required"`
	Message          string                                     `json:"message,required"`
	DocumentationURL string                                     `json:"documentation_url"`
	Source           PageRuleDeleteResponseEnvelopeErrorsSource `json:"source"`
	JSON             pageRuleDeleteResponseEnvelopeErrorsJSON   `json:"-"`
}

type PageRuleDeleteResponseEnvelopeErrorsSource struct {
	Pointer string                                         `json:"pointer"`
	JSON    pageRuleDeleteResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type PageRuleDeleteResponseEnvelopeMessages struct {
	Code             int64                                        `json:"code,required"`
	Message          string                                       `json:"message,required"`
	DocumentationURL string                                       `json:"documentation_url"`
	Source           PageRuleDeleteResponseEnvelopeMessagesSource `json:"source"`
	JSON             pageRuleDeleteResponseEnvelopeMessagesJSON   `json:"-"`
}

type PageRuleDeleteResponseEnvelopeMessagesSource struct {
	Pointer string                                           `json:"pointer"`
	JSON    pageRuleDeleteResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type PageRuleDeleteResponseEnvelopeSuccess bool

type PageRuleEditParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The set of actions to perform if the targets of this rule match the request.
	// Actions can redirect to another URL or override settings, but not both.
	Actions param.Field[[]PageRuleEditParamsActionUnion] `json:"actions"`
	// The priority of the rule, used to define which Page Rule is processed over
	// another. A higher number indicates a higher priority. For example, if you have a
	// catch-all Page Rule (rule A: `/images/*`) but want a more specific Page Rule to
	// take precedence (rule B: `/images/special/*`), specify a higher priority for
	// rule B so it overrides rule A.
	Priority param.Field[int64] `json:"priority"`
	// The status of the Page Rule.
	Status param.Field[PageRuleEditParamsStatus] `json:"status"`
	// The rule targets to evaluate on each request.
	Targets param.Field[[]TargetParam] `json:"targets"`
}

type PageRuleEditParamsAction struct {
	// If enabled, any ` http://“ URL is converted to  `https://` through a 301
	// redirect.
	ID    param.Field[PageRuleEditParamsActionsID] `json:"id"`
	Value param.Field[interface{}]                 `json:"value"`
}

type PageRuleEditParamsActionUnion interface {
	ImplementsPageRuleEditParamsActionUnion()
}

type PageRuleEditParamsActionsBypassCacheOnCookie struct {
	// Bypass cache and fetch resources from the origin server if a regular expression
	// matches against a cookie name present in the request.
	ID param.Field[PageRuleEditParamsActionsBypassCacheOnCookieID] `json:"id"`
	// The regular expression to use for matching cookie names in the request. Refer to
	// [Bypass Cache on Cookie setting](https://developers.cloudflare.com/rules/page-rules/reference/additional-reference/#bypass-cache-on-cookie-setting)
	// to learn about limited regular expression support.
	Value param.Field[string] `json:"value"`
}

type PageRuleEditParamsActionsBypassCacheOnCookieID string

type PageRuleEditParamsActionsCacheByDeviceType struct {
	// Separate cached content based on the visitor's device type.
	ID param.Field[PageRuleEditParamsActionsCacheByDeviceTypeID] `json:"id"`
	// The status of Cache By Device Type.
	Value param.Field[PageRuleEditParamsActionsCacheByDeviceTypeValue] `json:"value"`
}

type PageRuleEditParamsActionsCacheByDeviceTypeID string

type PageRuleEditParamsActionsCacheByDeviceTypeValue string

type PageRuleEditParamsActionsCacheDeceptionArmor struct {
	// Protect from web cache deception attacks while still allowing static assets to
	// be cached. This setting verifies that the URL's extension matches the returned
	// `Content-Type`.
	ID param.Field[PageRuleEditParamsActionsCacheDeceptionArmorID] `json:"id"`
	// The status of Cache Deception Armor.
	Value param.Field[PageRuleEditParamsActionsCacheDeceptionArmorValue] `json:"value"`
}

type PageRuleEditParamsActionsCacheDeceptionArmorID string

type PageRuleEditParamsActionsCacheDeceptionArmorValue string

type PageRuleEditParamsActionsCacheKeyFields struct {
	// Control specifically what variables to include when deciding which resources to
	// cache. This allows customers to determine what to cache based on something other
	// than just the URL.
	ID    param.Field[PageRuleEditParamsActionsCacheKeyFieldsID]    `json:"id"`
	Value param.Field[PageRuleEditParamsActionsCacheKeyFieldsValue] `json:"value"`
}

type PageRuleEditParamsActionsCacheKeyFieldsID string

type PageRuleEditParamsActionsCacheKeyFieldsValue struct {
	// Controls which cookies appear in the Cache Key.
	Cookie param.Field[PageRuleEditParamsActionsCacheKeyFieldsValueCookie] `json:"cookie"`
	// Controls which headers go into the Cache Key. Exactly one of `include` or
	// `exclude` is expected.
	Header param.Field[PageRuleEditParamsActionsCacheKeyFieldsValueHeader] `json:"header"`
	// Determines which host header to include in the Cache Key.
	Host param.Field[PageRuleEditParamsActionsCacheKeyFieldsValueHost] `json:"host"`
	// Controls which URL query string parameters go into the Cache Key. Exactly one of
	// `include` or `exclude` is expected.
	QueryString param.Field[PageRuleEditParamsActionsCacheKeyFieldsValueQueryString] `json:"query_string"`
	// Feature fields to add features about the end-user (client) into the Cache Key.
	User param.Field[PageRuleEditParamsActionsCacheKeyFieldsValueUser] `json:"user"`
}

type PageRuleEditParamsActionsCacheKeyFieldsValueCookie struct {
	// A list of cookies to check for the presence of, without including their actual
	// values.
	CheckPresence param.Field[[]string] `json:"check_presence"`
	// A list of cookies to include.
	Include param.Field[[]string] `json:"include"`
}

type PageRuleEditParamsActionsCacheKeyFieldsValueHeader struct {
	// A list of headers to check for the presence of, without including their actual
	// values.
	CheckPresence param.Field[[]string] `json:"check_presence"`
	// A list of headers to ignore.
	Exclude param.Field[[]string] `json:"exclude"`
	// A list of headers to include.
	Include param.Field[[]string] `json:"include"`
}

type PageRuleEditParamsActionsCacheKeyFieldsValueHost struct {
	// Whether to include the Host header in the HTTP request sent to the origin.
	Resolved param.Field[bool] `json:"resolved"`
}

type PageRuleEditParamsActionsCacheKeyFieldsValueQueryString struct {
	// Ignore all query string parameters.
	Exclude param.Field[PageRuleEditParamsActionsCacheKeyFieldsValueQueryStringExcludeUnion] `json:"exclude"`
	// Include all query string parameters.
	Include param.Field[PageRuleEditParamsActionsCacheKeyFieldsValueQueryStringIncludeUnion] `json:"include"`
}

type PageRuleEditParamsActionsCacheKeyFieldsValueQueryStringExcludeArray []string

type PageRuleEditParamsActionsCacheKeyFieldsValueQueryStringExcludeString string

type PageRuleEditParamsActionsCacheKeyFieldsValueQueryStringExcludeUnion interface {
	// contains filtered or unexported methods
}

type PageRuleEditParamsActionsCacheKeyFieldsValueQueryStringIncludeArray []string

type PageRuleEditParamsActionsCacheKeyFieldsValueQueryStringIncludeString string

type PageRuleEditParamsActionsCacheKeyFieldsValueQueryStringIncludeUnion interface {
	// contains filtered or unexported methods
}

type PageRuleEditParamsActionsCacheKeyFieldsValueUser struct {
	// Classifies a request as `mobile`, `desktop`, or `tablet` based on the User
	// Agent.
	DeviceType param.Field[bool] `json:"device_type"`
	// Includes the client's country, derived from the IP address.
	Geo param.Field[bool] `json:"geo"`
	// Includes the first language code contained in the `Accept-Language` header sent
	// by the client.
	Lang param.Field[bool] `json:"lang"`
}

type PageRuleEditParamsActionsCacheOnCookie struct {
	// Apply the Cache Everything option (Cache Level setting) based on a regular
	// expression match against a cookie name.
	ID param.Field[PageRuleEditParamsActionsCacheOnCookieID] `json:"id"`
	// The regular expression to use for matching cookie names in the request.
	Value param.Field[string] `json:"value"`
}

type PageRuleEditParamsActionsCacheOnCookieID string

type PageRuleEditParamsActionsCacheTTLByStatus struct {
	// Enterprise customers can set cache time-to-live (TTL) based on the response
	// status from the origin web server. Cache TTL refers to the duration of a
	// resource in the Cloudflare network before being marked as stale or discarded
	// from cache. Status codes are returned by a resource's origin. Setting cache TTL
	// based on response status overrides the default cache behavior (standard caching)
	// for static files and overrides cache instructions sent by the origin web server.
	// To cache non-static assets, set a Cache Level of Cache Everything using a Page
	// Rule. Setting no-store Cache-Control or a low TTL (using `max-age`/`s-maxage`)
	// increases requests to origin web servers and decreases performance.
	ID param.Field[PageRuleEditParamsActionsCacheTTLByStatusID] `json:"id"`
	// A JSON object containing status codes and their corresponding TTLs. Each
	// key-value pair in the cache TTL by status cache rule has the following syntax
	//
	//   - `status_code`: An integer value such as 200 or 500. status_code matches the
	//     exact status code from the origin web server. Valid status codes are between
	//     100-999.
	//   - `status_code_range`: Integer values for from and to. status_code_range matches
	//     any status code from the origin web server within the specified range.
	//   - `value`: An integer value that defines the duration an asset is valid in
	//     seconds or one of the following strings: no-store (equivalent to -1), no-cache
	//     (equivalent to 0).
	Value param.Field[map[string]PageRuleEditParamsActionsCacheTTLByStatusValueUnion] `json:"value"`
}

type PageRuleEditParamsActionsCacheTTLByStatusID string

type PageRuleEditParamsActionsCacheTTLByStatusValueString string

type PageRuleEditParamsActionsCacheTTLByStatusValueUnion interface {
	ImplementsPageRuleEditParamsActionsCacheTTLByStatusValueUnion()
}

type PageRuleEditParamsActionsDisableApps struct {
	// Turn off all active
	// [Cloudflare Apps](https://developers.cloudflare.com/support/more-dashboard-apps/cloudflare-apps/)
	// (deprecated).
	ID param.Field[PageRuleEditParamsActionsDisableAppsID] `json:"id"`
}

type PageRuleEditParamsActionsDisableAppsID string

type PageRuleEditParamsActionsDisablePerformance struct {
	// Turn off
	// [Rocket Loader](https://developers.cloudflare.com/speed/optimization/content/rocket-loader/),
	// [Mirage](https://developers.cloudflare.com/speed/optimization/images/mirage/),
	// and [Polish](https://developers.cloudflare.com/images/polish/).
	ID param.Field[PageRuleEditParamsActionsDisablePerformanceID] `json:"id"`
}

type PageRuleEditParamsActionsDisablePerformanceID string

type PageRuleEditParamsActionsDisableSecurity struct {
	// Turn off
	// [Email Obfuscation](https://developers.cloudflare.com/waf/tools/scrape-shield/email-address-obfuscation/),
	// [Rate Limiting (previous version, deprecated)](https://developers.cloudflare.com/waf/reference/legacy/old-rate-limiting/),
	// [Scrape Shield](https://developers.cloudflare.com/waf/tools/scrape-shield/),
	// [URL (Zone) Lockdown](https://developers.cloudflare.com/waf/tools/zone-lockdown/),
	// and
	// [WAF managed rules (previous version, deprecated)](https://developers.cloudflare.com/waf/reference/legacy/old-waf-managed-rules/).
	ID param.Field[PageRuleEditParamsActionsDisableSecurityID] `json:"id"`
}

type PageRuleEditParamsActionsDisableSecurityID string

type PageRuleEditParamsActionsDisableZaraz struct {
	// Turn off [Zaraz](https://developers.cloudflare.com/zaraz/).
	ID param.Field[PageRuleEditParamsActionsDisableZarazID] `json:"id"`
}

type PageRuleEditParamsActionsDisableZarazID string

type PageRuleEditParamsActionsEdgeCacheTTL struct {
	// Specify how long to cache a resource in the Cloudflare global network. _Edge
	// Cache TTL_ is not visible in response headers.
	ID    param.Field[PageRuleEditParamsActionsEdgeCacheTTLID] `json:"id"`
	Value param.Field[int64]                                   `json:"value"`
}

type PageRuleEditParamsActionsEdgeCacheTTLID string

type PageRuleEditParamsActionsExplicitCacheControl struct {
	// Origin Cache Control is enabled by default for Free, Pro, and Business domains
	// and disabled by default for Enterprise domains.
	ID param.Field[PageRuleEditParamsActionsExplicitCacheControlID] `json:"id"`
	// The status of Origin Cache Control.
	Value param.Field[PageRuleEditParamsActionsExplicitCacheControlValue] `json:"value"`
}

type PageRuleEditParamsActionsExplicitCacheControlID string

type PageRuleEditParamsActionsExplicitCacheControlValue string

type PageRuleEditParamsActionsForwardingURL struct {
	// Redirects one URL to another using an `HTTP 301/302` redirect. Refer to
	// [Wildcard matching and referencing](https://developers.cloudflare.com/rules/page-rules/reference/wildcard-matching/).
	ID    param.Field[PageRuleEditParamsActionsForwardingURLID]    `json:"id"`
	Value param.Field[PageRuleEditParamsActionsForwardingURLValue] `json:"value"`
}

type PageRuleEditParamsActionsForwardingURLID string

type PageRuleEditParamsActionsForwardingURLValue struct {
	// The status code to use for the URL redirect. 301 is a permanent redirect. 302 is
	// a temporary redirect.
	StatusCode param.Field[PageRuleEditParamsActionsForwardingURLValueStatusCode] `json:"status_code"`
	// The URL to redirect the request to. Notes: ${num} refers to the position of '\*'
	// in the constraint value.
	URL param.Field[string] `json:"url"`
}

type PageRuleEditParamsActionsForwardingURLValueStatusCode int64

type PageRuleEditParamsActionsHostHeaderOverride struct {
	// Apply a specific host header.
	ID param.Field[PageRuleEditParamsActionsHostHeaderOverrideID] `json:"id"`
	// The hostname to use in the `Host` header
	Value param.Field[string] `json:"value"`
}

type PageRuleEditParamsActionsHostHeaderOverrideID string

type PageRuleEditParamsActionsID string

type PageRuleEditParamsActionsResolveOverride struct {
	// Change the origin address to the value specified in this setting.
	ID param.Field[PageRuleEditParamsActionsResolveOverrideID] `json:"id"`
	// The origin address you want to override with.
	Value param.Field[string] `json:"value"`
}

type PageRuleEditParamsActionsResolveOverrideID string

type PageRuleEditParamsActionsRespectStrongEtag struct {
	// Turn on or off byte-for-byte equivalency checks between the Cloudflare cache and
	// the origin server.
	ID param.Field[PageRuleEditParamsActionsRespectStrongEtagID] `json:"id"`
	// The status of Respect Strong ETags
	Value param.Field[PageRuleEditParamsActionsRespectStrongEtagValue] `json:"value"`
}

type PageRuleEditParamsActionsRespectStrongEtagID string

type PageRuleEditParamsActionsRespectStrongEtagValue string

type PageRuleEditParamsStatus string

type PageRuleEditResponseEnvelope struct {
	Errors   []PageRuleEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PageRuleEditResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success PageRuleEditResponseEnvelopeSuccess `json:"success,required"`
	Result  PageRule                            `json:"result"`
	JSON    pageRuleEditResponseEnvelopeJSON    `json:"-"`
}

type PageRuleEditResponseEnvelopeErrors struct {
	Code             int64                                    `json:"code,required"`
	Message          string                                   `json:"message,required"`
	DocumentationURL string                                   `json:"documentation_url"`
	Source           PageRuleEditResponseEnvelopeErrorsSource `json:"source"`
	JSON             pageRuleEditResponseEnvelopeErrorsJSON   `json:"-"`
}

type PageRuleEditResponseEnvelopeErrorsSource struct {
	Pointer string                                       `json:"pointer"`
	JSON    pageRuleEditResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type PageRuleEditResponseEnvelopeMessages struct {
	Code             int64                                      `json:"code,required"`
	Message          string                                     `json:"message,required"`
	DocumentationURL string                                     `json:"documentation_url"`
	Source           PageRuleEditResponseEnvelopeMessagesSource `json:"source"`
	JSON             pageRuleEditResponseEnvelopeMessagesJSON   `json:"-"`
}

type PageRuleEditResponseEnvelopeMessagesSource struct {
	Pointer string                                         `json:"pointer"`
	JSON    pageRuleEditResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type PageRuleEditResponseEnvelopeSuccess bool

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

type PageRuleGetResponseEnvelope struct {
	Errors   []PageRuleGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PageRuleGetResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success PageRuleGetResponseEnvelopeSuccess `json:"success,required"`
	Result  PageRule                           `json:"result"`
	JSON    pageRuleGetResponseEnvelopeJSON    `json:"-"`
}

type PageRuleGetResponseEnvelopeErrors struct {
	Code             int64                                   `json:"code,required"`
	Message          string                                  `json:"message,required"`
	DocumentationURL string                                  `json:"documentation_url"`
	Source           PageRuleGetResponseEnvelopeErrorsSource `json:"source"`
	JSON             pageRuleGetResponseEnvelopeErrorsJSON   `json:"-"`
}

type PageRuleGetResponseEnvelopeErrorsSource struct {
	Pointer string                                      `json:"pointer"`
	JSON    pageRuleGetResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type PageRuleGetResponseEnvelopeMessages struct {
	Code             int64                                     `json:"code,required"`
	Message          string                                    `json:"message,required"`
	DocumentationURL string                                    `json:"documentation_url"`
	Source           PageRuleGetResponseEnvelopeMessagesSource `json:"source"`
	JSON             pageRuleGetResponseEnvelopeMessagesJSON   `json:"-"`
}

type PageRuleGetResponseEnvelopeMessagesSource struct {
	Pointer string                                        `json:"pointer"`
	JSON    pageRuleGetResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type PageRuleGetResponseEnvelopeSuccess bool

type PageRuleListParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The direction used to sort returned Page Rules.
	Direction param.Field[PageRuleListParamsDirection] `query:"direction"`
	// When set to `all`, all the search requirements must match. When set to `any`,
	// only one of the search requirements has to match.
	Match param.Field[PageRuleListParamsMatch] `query:"match"`
	// The field used to sort returned Page Rules.
	Order param.Field[PageRuleListParamsOrder] `query:"order"`
	// The status of the Page Rule.
	Status param.Field[PageRuleListParamsStatus] `query:"status"`
}

type PageRuleListParamsDirection string

type PageRuleListParamsMatch string

type PageRuleListParamsOrder string

type PageRuleListParamsStatus string

type PageRuleListResponseEnvelope struct {
	Errors   []PageRuleListResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PageRuleListResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success PageRuleListResponseEnvelopeSuccess `json:"success,required"`
	Result  []PageRule                          `json:"result"`
	JSON    pageRuleListResponseEnvelopeJSON    `json:"-"`
}

type PageRuleListResponseEnvelopeErrors struct {
	Code             int64                                    `json:"code,required"`
	Message          string                                   `json:"message,required"`
	DocumentationURL string                                   `json:"documentation_url"`
	Source           PageRuleListResponseEnvelopeErrorsSource `json:"source"`
	JSON             pageRuleListResponseEnvelopeErrorsJSON   `json:"-"`
}

type PageRuleListResponseEnvelopeErrorsSource struct {
	Pointer string                                       `json:"pointer"`
	JSON    pageRuleListResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type PageRuleListResponseEnvelopeMessages struct {
	Code             int64                                      `json:"code,required"`
	Message          string                                     `json:"message,required"`
	DocumentationURL string                                     `json:"documentation_url"`
	Source           PageRuleListResponseEnvelopeMessagesSource `json:"source"`
	JSON             pageRuleListResponseEnvelopeMessagesJSON   `json:"-"`
}

type PageRuleListResponseEnvelopeMessagesSource struct {
	Pointer string                                         `json:"pointer"`
	JSON    pageRuleListResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type PageRuleListResponseEnvelopeSuccess bool

type PageRuleNewParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The set of actions to perform if the targets of this rule match the request.
	// Actions can redirect to another URL or override settings, but not both.
	Actions param.Field[[]PageRuleNewParamsActionUnion] `json:"actions,required"`
	// The rule targets to evaluate on each request.
	Targets param.Field[[]TargetParam] `json:"targets,required"`
	// The priority of the rule, used to define which Page Rule is processed over
	// another. A higher number indicates a higher priority. For example, if you have a
	// catch-all Page Rule (rule A: `/images/*`) but want a more specific Page Rule to
	// take precedence (rule B: `/images/special/*`), specify a higher priority for
	// rule B so it overrides rule A.
	Priority param.Field[int64] `json:"priority"`
	// The status of the Page Rule.
	Status param.Field[PageRuleNewParamsStatus] `json:"status"`
}

type PageRuleNewParamsAction struct {
	// If enabled, any ` http://“ URL is converted to  `https://` through a 301
	// redirect.
	ID    param.Field[PageRuleNewParamsActionsID] `json:"id"`
	Value param.Field[interface{}]                `json:"value"`
}

type PageRuleNewParamsActionUnion interface {
	ImplementsPageRuleNewParamsActionUnion()
}

type PageRuleNewParamsActionsBypassCacheOnCookie struct {
	// Bypass cache and fetch resources from the origin server if a regular expression
	// matches against a cookie name present in the request.
	ID param.Field[PageRuleNewParamsActionsBypassCacheOnCookieID] `json:"id"`
	// The regular expression to use for matching cookie names in the request. Refer to
	// [Bypass Cache on Cookie setting](https://developers.cloudflare.com/rules/page-rules/reference/additional-reference/#bypass-cache-on-cookie-setting)
	// to learn about limited regular expression support.
	Value param.Field[string] `json:"value"`
}

type PageRuleNewParamsActionsBypassCacheOnCookieID string

type PageRuleNewParamsActionsCacheByDeviceType struct {
	// Separate cached content based on the visitor's device type.
	ID param.Field[PageRuleNewParamsActionsCacheByDeviceTypeID] `json:"id"`
	// The status of Cache By Device Type.
	Value param.Field[PageRuleNewParamsActionsCacheByDeviceTypeValue] `json:"value"`
}

type PageRuleNewParamsActionsCacheByDeviceTypeID string

type PageRuleNewParamsActionsCacheByDeviceTypeValue string

type PageRuleNewParamsActionsCacheDeceptionArmor struct {
	// Protect from web cache deception attacks while still allowing static assets to
	// be cached. This setting verifies that the URL's extension matches the returned
	// `Content-Type`.
	ID param.Field[PageRuleNewParamsActionsCacheDeceptionArmorID] `json:"id"`
	// The status of Cache Deception Armor.
	Value param.Field[PageRuleNewParamsActionsCacheDeceptionArmorValue] `json:"value"`
}

type PageRuleNewParamsActionsCacheDeceptionArmorID string

type PageRuleNewParamsActionsCacheDeceptionArmorValue string

type PageRuleNewParamsActionsCacheKeyFields struct {
	// Control specifically what variables to include when deciding which resources to
	// cache. This allows customers to determine what to cache based on something other
	// than just the URL.
	ID    param.Field[PageRuleNewParamsActionsCacheKeyFieldsID]    `json:"id"`
	Value param.Field[PageRuleNewParamsActionsCacheKeyFieldsValue] `json:"value"`
}

type PageRuleNewParamsActionsCacheKeyFieldsID string

type PageRuleNewParamsActionsCacheKeyFieldsValue struct {
	// Controls which cookies appear in the Cache Key.
	Cookie param.Field[PageRuleNewParamsActionsCacheKeyFieldsValueCookie] `json:"cookie"`
	// Controls which headers go into the Cache Key. Exactly one of `include` or
	// `exclude` is expected.
	Header param.Field[PageRuleNewParamsActionsCacheKeyFieldsValueHeader] `json:"header"`
	// Determines which host header to include in the Cache Key.
	Host param.Field[PageRuleNewParamsActionsCacheKeyFieldsValueHost] `json:"host"`
	// Controls which URL query string parameters go into the Cache Key. Exactly one of
	// `include` or `exclude` is expected.
	QueryString param.Field[PageRuleNewParamsActionsCacheKeyFieldsValueQueryString] `json:"query_string"`
	// Feature fields to add features about the end-user (client) into the Cache Key.
	User param.Field[PageRuleNewParamsActionsCacheKeyFieldsValueUser] `json:"user"`
}

type PageRuleNewParamsActionsCacheKeyFieldsValueCookie struct {
	// A list of cookies to check for the presence of, without including their actual
	// values.
	CheckPresence param.Field[[]string] `json:"check_presence"`
	// A list of cookies to include.
	Include param.Field[[]string] `json:"include"`
}

type PageRuleNewParamsActionsCacheKeyFieldsValueHeader struct {
	// A list of headers to check for the presence of, without including their actual
	// values.
	CheckPresence param.Field[[]string] `json:"check_presence"`
	// A list of headers to ignore.
	Exclude param.Field[[]string] `json:"exclude"`
	// A list of headers to include.
	Include param.Field[[]string] `json:"include"`
}

type PageRuleNewParamsActionsCacheKeyFieldsValueHost struct {
	// Whether to include the Host header in the HTTP request sent to the origin.
	Resolved param.Field[bool] `json:"resolved"`
}

type PageRuleNewParamsActionsCacheKeyFieldsValueQueryString struct {
	// Ignore all query string parameters.
	Exclude param.Field[PageRuleNewParamsActionsCacheKeyFieldsValueQueryStringExcludeUnion] `json:"exclude"`
	// Include all query string parameters.
	Include param.Field[PageRuleNewParamsActionsCacheKeyFieldsValueQueryStringIncludeUnion] `json:"include"`
}

type PageRuleNewParamsActionsCacheKeyFieldsValueQueryStringExcludeArray []string

type PageRuleNewParamsActionsCacheKeyFieldsValueQueryStringExcludeString string

type PageRuleNewParamsActionsCacheKeyFieldsValueQueryStringExcludeUnion interface {
	// contains filtered or unexported methods
}

type PageRuleNewParamsActionsCacheKeyFieldsValueQueryStringIncludeArray []string

type PageRuleNewParamsActionsCacheKeyFieldsValueQueryStringIncludeString string

type PageRuleNewParamsActionsCacheKeyFieldsValueQueryStringIncludeUnion interface {
	// contains filtered or unexported methods
}

type PageRuleNewParamsActionsCacheKeyFieldsValueUser struct {
	// Classifies a request as `mobile`, `desktop`, or `tablet` based on the User
	// Agent.
	DeviceType param.Field[bool] `json:"device_type"`
	// Includes the client's country, derived from the IP address.
	Geo param.Field[bool] `json:"geo"`
	// Includes the first language code contained in the `Accept-Language` header sent
	// by the client.
	Lang param.Field[bool] `json:"lang"`
}

type PageRuleNewParamsActionsCacheOnCookie struct {
	// Apply the Cache Everything option (Cache Level setting) based on a regular
	// expression match against a cookie name.
	ID param.Field[PageRuleNewParamsActionsCacheOnCookieID] `json:"id"`
	// The regular expression to use for matching cookie names in the request.
	Value param.Field[string] `json:"value"`
}