firewall

type AccessRuleDeleteParams struct {
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
}

type AccessRuleDeleteResponse struct {
	// Identifier
	ID   string                       `json:"id,required"`
	JSON accessRuleDeleteResponseJSON `json:"-"`
}

type AccessRuleDeleteResponseEnvelope struct {
	Errors   []AccessRuleDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []AccessRuleDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   AccessRuleDeleteResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success AccessRuleDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    accessRuleDeleteResponseEnvelopeJSON    `json:"-"`
}

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

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

type AccessRuleDeleteResponseEnvelopeSuccess bool

type AccessRuleEditParams struct {
	// The rule configuration.
	Configuration param.Field[AccessRuleEditParamsConfiguration] `json:"configuration,required"`
	// The action to apply to a matched request.
	Mode param.Field[AccessRuleEditParamsMode] `json:"mode,required"`
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
	// An informative summary of the rule, typically used as a reminder or explanation.
	Notes param.Field[string] `json:"notes"`
}

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

type AccessRuleEditParamsConfigurationLegacyJhsASNConfiguration struct {
	// The configuration target. You must set the target to `asn` when specifying an
	// Autonomous System Number (ASN) in the rule.
	Target param.Field[AccessRuleEditParamsConfigurationLegacyJhsASNConfigurationTarget] `json:"target"`
	// The AS number to match.
	Value param.Field[string] `json:"value"`
}

type AccessRuleEditParamsConfigurationLegacyJhsASNConfigurationTarget string

type AccessRuleEditParamsConfigurationLegacyJhsCIDRConfiguration struct {
	// The configuration target. You must set the target to `ip_range` when specifying
	// an IP address range in the rule.
	Target param.Field[AccessRuleEditParamsConfigurationLegacyJhsCIDRConfigurationTarget] `json:"target"`
	// The IP address range to match. You can only use prefix lengths `/16` and `/24`
	// for IPv4 ranges, and prefix lengths `/32`, `/48`, and `/64` for IPv6 ranges.
	Value param.Field[string] `json:"value"`
}

type AccessRuleEditParamsConfigurationLegacyJhsCIDRConfigurationTarget string

type AccessRuleEditParamsConfigurationLegacyJhsCountryConfiguration struct {
	// The configuration target. You must set the target to `country` when specifying a
	// country code in the rule.
	Target param.Field[AccessRuleEditParamsConfigurationLegacyJhsCountryConfigurationTarget] `json:"target"`
	// The two-letter ISO-3166-1 alpha-2 code to match. For more information, refer to
	// [IP Access rules: Parameters](https://developers.cloudflare.com/waf/tools/ip-access-rules/parameters/#country).
	Value param.Field[string] `json:"value"`
}

type AccessRuleEditParamsConfigurationLegacyJhsCountryConfigurationTarget string

type AccessRuleEditParamsConfigurationLegacyJhsIPConfiguration struct {
	// The configuration target. You must set the target to `ip` when specifying an IP
	// address in the rule.
	Target param.Field[AccessRuleEditParamsConfigurationLegacyJhsIPConfigurationTarget] `json:"target"`
	// The IP address to match. This address will be compared to the IP address of
	// incoming requests.
	Value param.Field[string] `json:"value"`
}

type AccessRuleEditParamsConfigurationLegacyJhsIPConfigurationTarget string

type AccessRuleEditParamsConfigurationLegacyJhsIPV6Configuration struct {
	// The configuration target. You must set the target to `ip6` when specifying an
	// IPv6 address in the rule.
	Target param.Field[AccessRuleEditParamsConfigurationLegacyJhsIPV6ConfigurationTarget] `json:"target"`
	// The IPv6 address to match.
	Value param.Field[string] `json:"value"`
}

type AccessRuleEditParamsConfigurationLegacyJhsIPV6ConfigurationTarget string

type AccessRuleEditParamsMode string

type AccessRuleEditResponse interface {
	ImplementsFirewallAccessRuleEditResponse()
}

type AccessRuleEditResponseEnvelope struct {
	Errors   []AccessRuleEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []AccessRuleEditResponseEnvelopeMessages `json:"messages,required"`
	Result   AccessRuleEditResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success AccessRuleEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    accessRuleEditResponseEnvelopeJSON    `json:"-"`
}

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

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

type AccessRuleEditResponseEnvelopeSuccess bool

type AccessRuleGetParams struct {
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
}

type AccessRuleGetResponse interface {
	ImplementsFirewallAccessRuleGetResponse()
}

type AccessRuleGetResponseEnvelope struct {
	Errors   []AccessRuleGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []AccessRuleGetResponseEnvelopeMessages `json:"messages,required"`
	Result   AccessRuleGetResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success AccessRuleGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    accessRuleGetResponseEnvelopeJSON    `json:"-"`
}

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

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

type AccessRuleGetResponseEnvelopeSuccess bool

type AccessRuleListParams struct {
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
	// The direction used to sort returned rules.
	Direction     param.Field[AccessRuleListParamsDirection]     `query:"direction"`
	EgsPagination param.Field[AccessRuleListParamsEgsPagination] `query:"egs-pagination"`
	Filters       param.Field[AccessRuleListParamsFilters]       `query:"filters"`
	// The field used to sort returned rules.
	Order param.Field[AccessRuleListParamsOrder] `query:"order"`
	// Requested page within paginated list of results.
	Page param.Field[float64] `query:"page"`
	// Maximum number of results requested.
	PerPage param.Field[float64] `query:"per_page"`
}

type AccessRuleListParamsDirection string

type AccessRuleListParamsEgsPagination struct {
	Json param.Field[AccessRuleListParamsEgsPaginationJson] `query:"json"`
}

type AccessRuleListParamsEgsPaginationJson struct {
	// The page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// The maximum number of results per page. You can only set the value to `1` or to
	// a multiple of 5 such as `5`, `10`, `15`, or `20`.
	PerPage param.Field[float64] `query:"per_page"`
}

type AccessRuleListParamsFilters struct {
	// The target to search in existing rules.
	ConfigurationTarget param.Field[AccessRuleListParamsFiltersConfigurationTarget] `query:"configuration.target"`
	// The target value to search for in existing rules: an IP address, an IP address
	// range, or a country code, depending on the provided `configuration.target`.
	// Notes: You can search for a single IPv4 address, an IP address range with a
	// subnet of '/16' or '/24', or a two-letter ISO-3166-1 alpha-2 country code.
	ConfigurationValue param.Field[string] `query:"configuration.value"`
	// 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[AccessRuleListParamsFiltersMatch] `query:"match"`
	// The action to apply to a matched request.
	Mode param.Field[AccessRuleListParamsFiltersMode] `query:"mode"`
	// The string to search for in the notes of existing IP Access rules. Notes: For
	// example, the string 'attack' would match IP Access rules with notes 'Attack
	// 26/02' and 'Attack 27/02'. The search is case insensitive.
	Notes param.Field[string] `query:"notes"`
}

type AccessRuleListParamsFiltersConfigurationTarget string

type AccessRuleListParamsFiltersMatch string

type AccessRuleListParamsFiltersMode string

type AccessRuleListParamsOrder string

type AccessRuleListResponse = interface{}

type AccessRuleNewParams struct {
	// The rule configuration.
	Configuration param.Field[AccessRuleNewParamsConfiguration] `json:"configuration,required"`
	// The action to apply to a matched request.
	Mode param.Field[AccessRuleNewParamsMode] `json:"mode,required"`
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
	// An informative summary of the rule, typically used as a reminder or explanation.
	Notes param.Field[string] `json:"notes"`
}

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

type AccessRuleNewParamsConfigurationLegacyJhsASNConfiguration struct {
	// The configuration target. You must set the target to `asn` when specifying an
	// Autonomous System Number (ASN) in the rule.
	Target param.Field[AccessRuleNewParamsConfigurationLegacyJhsASNConfigurationTarget] `json:"target"`
	// The AS number to match.
	Value param.Field[string] `json:"value"`
}

type AccessRuleNewParamsConfigurationLegacyJhsASNConfigurationTarget string

type AccessRuleNewParamsConfigurationLegacyJhsCIDRConfiguration struct {
	// The configuration target. You must set the target to `ip_range` when specifying
	// an IP address range in the rule.
	Target param.Field[AccessRuleNewParamsConfigurationLegacyJhsCIDRConfigurationTarget] `json:"target"`
	// The IP address range to match. You can only use prefix lengths `/16` and `/24`
	// for IPv4 ranges, and prefix lengths `/32`, `/48`, and `/64` for IPv6 ranges.
	Value param.Field[string] `json:"value"`
}

type AccessRuleNewParamsConfigurationLegacyJhsCIDRConfigurationTarget string

type AccessRuleNewParamsConfigurationLegacyJhsCountryConfiguration struct {
	// The configuration target. You must set the target to `country` when specifying a
	// country code in the rule.
	Target param.Field[AccessRuleNewParamsConfigurationLegacyJhsCountryConfigurationTarget] `json:"target"`
	// The two-letter ISO-3166-1 alpha-2 code to match. For more information, refer to
	// [IP Access rules: Parameters](https://developers.cloudflare.com/waf/tools/ip-access-rules/parameters/#country).
	Value param.Field[string] `json:"value"`
}

type AccessRuleNewParamsConfigurationLegacyJhsCountryConfigurationTarget string

type AccessRuleNewParamsConfigurationLegacyJhsIPConfiguration struct {
	// The configuration target. You must set the target to `ip` when specifying an IP
	// address in the rule.
	Target param.Field[AccessRuleNewParamsConfigurationLegacyJhsIPConfigurationTarget] `json:"target"`
	// The IP address to match. This address will be compared to the IP address of
	// incoming requests.
	Value param.Field[string] `json:"value"`
}

type AccessRuleNewParamsConfigurationLegacyJhsIPConfigurationTarget string

type AccessRuleNewParamsConfigurationLegacyJhsIPV6Configuration struct {
	// The configuration target. You must set the target to `ip6` when specifying an
	// IPv6 address in the rule.
	Target param.Field[AccessRuleNewParamsConfigurationLegacyJhsIPV6ConfigurationTarget] `json:"target"`
	// The IPv6 address to match.
	Value param.Field[string] `json:"value"`
}

type AccessRuleNewParamsConfigurationLegacyJhsIPV6ConfigurationTarget string

type AccessRuleNewParamsMode string

type AccessRuleNewResponse interface {
	ImplementsFirewallAccessRuleNewResponse()
}

type AccessRuleNewResponseEnvelope struct {
	Errors   []AccessRuleNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []AccessRuleNewResponseEnvelopeMessages `json:"messages,required"`
	Result   AccessRuleNewResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success AccessRuleNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    accessRuleNewResponseEnvelopeJSON    `json:"-"`
}

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

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

type AccessRuleNewResponseEnvelopeSuccess bool

type AccessRuleService struct {
	Options []option.RequestOption
}

type Error = apierror.Error

type FirewallService struct {
	Options     []option.RequestOption
	Lockdowns   *LockdownService
	Rules       *RuleService
	AccessRules *AccessRuleService
	UARules     *UARuleService
	WAF         *WAFService
}

type LegacyJhsFilterRule struct {
	// The unique identifier of the firewall rule.
	ID string `json:"id"`
	// The action to apply to a matched request. The `log` action is only available on
	// an Enterprise plan.
	Action LegacyJhsFilterRuleAction `json:"action"`
	// An informative summary of the firewall rule.
	Description string                    `json:"description"`
	Filter      LegacyJhsFilterRuleFilter `json:"filter"`
	// When true, indicates that the firewall rule is currently paused.
	Paused bool `json:"paused"`
	// The priority of the rule. Optional value used to define the processing order. A
	// lower number indicates a higher priority. If not provided, rules with a defined
	// priority will be processed before rules without a priority.
	Priority float64                      `json:"priority"`
	Products []LegacyJhsFilterRuleProduct `json:"products"`
	// A short reference tag. Allows you to select related firewall rules.
	Ref  string                  `json:"ref"`
	JSON legacyJhsFilterRuleJSON `json:"-"`
}

type LegacyJhsFilterRuleAction string

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

type LegacyJhsFilterRuleFilterLegacyJhsDeletedFilter struct {
	// The unique identifier of the filter.
	ID string `json:"id,required"`
	// When true, indicates that the firewall rule was deleted.
	Deleted bool                                                `json:"deleted,required"`
	JSON    legacyJhsFilterRuleFilterLegacyJhsDeletedFilterJSON `json:"-"`
}

type LegacyJhsFilterRuleProduct string

type LegacyJhsOverride struct {
	// The unique identifier of the WAF override.
	ID string `json:"id"`
	// An informative summary of the current URI-based WAF override.
	Description string `json:"description,nullable"`
	// An object that allows you to enable or disable WAF rule groups for the current
	// WAF override. Each key of this object must be the ID of a WAF rule group, and
	// each value must be a valid WAF action (usually `default` or `disable`). When
	// creating a new URI-based WAF override, you must provide a `groups` object or a
	// `rules` object.
	Groups map[string]interface{} `json:"groups"`
	// When true, indicates that the WAF package is currently paused.
	Paused bool `json:"paused"`
	// The relative priority of the current URI-based WAF override when multiple
	// overrides match a single URL. A lower number indicates higher priority. Higher
	// priority overrides may overwrite values set by lower priority overrides.
	Priority float64 `json:"priority"`
	// Specifies that, when a WAF rule matches, its configured action will be replaced
	// by the action configured in this object.
	RewriteAction LegacyJhsOverrideRewriteAction `json:"rewrite_action"`
	// An object that allows you to override the action of specific WAF rules. Each key
	// of this object must be the ID of a WAF rule, and each value must be a valid WAF
	// action. Unless you are disabling a rule, ensure that you also enable the rule
	// group that this WAF rule belongs to. When creating a new URI-based WAF override,
	// you must provide a `groups` object or a `rules` object.
	Rules map[string]LegacyJhsOverrideRule `json:"rules"`
	// The URLs to include in the current WAF override. You can use wildcards. Each
	// entered URL will be escaped before use, which means you can only use simple
	// wildcard patterns.
	URLs []string              `json:"urls"`
	JSON legacyJhsOverrideJSON `json:"-"`
}

type LegacyJhsOverrideRewriteAction struct {
	// The WAF rule action to apply.
	Block     LegacyJhsOverrideRewriteActionBlock `json:"block"`
	Challenge interface{}                         `json:"challenge"`
	Default   interface{}                         `json:"default"`
	// The WAF rule action to apply.
	Disable  LegacyJhsOverrideRewriteActionDisable `json:"disable"`
	Simulate interface{}                           `json:"simulate"`
	JSON     legacyJhsOverrideRewriteActionJSON    `json:"-"`
}

type LegacyJhsOverrideRewriteActionBlock string

type LegacyJhsOverrideRewriteActionDisable string

type LegacyJhsOverrideRule string

type LegacyJhsZonelockdown struct {
	// The unique identifier of the Zone Lockdown rule.
	ID string `json:"id,required"`
	// A list of IP addresses or CIDR ranges that will be allowed to access the URLs
	// specified in the Zone Lockdown rule. You can include any number of `ip` or
	// `ip_range` configurations.
	Configurations LegacyJhsZonelockdownConfigurations `json:"configurations,required"`
	// The timestamp of when the rule was created.
	CreatedOn time.Time `json:"created_on,required" format:"date-time"`
	// An informative summary of the rule.
	Description string `json:"description,required"`
	// The timestamp of when the rule was last modified.
	ModifiedOn time.Time `json:"modified_on,required" format:"date-time"`
	// When true, indicates that the rule is currently paused.
	Paused bool `json:"paused,required"`
	// The URLs to include in the rule definition. You can use wildcards. Each entered
	// URL will be escaped before use, which means you can only use simple wildcard
	// patterns.
	URLs []string                  `json:"urls,required"`
	JSON legacyJhsZonelockdownJSON `json:"-"`
}

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

type LegacyJhsZonelockdownConfigurationsLegacyJhsSchemasCIDRConfiguration struct {
	// The configuration target. You must set the target to `ip_range` when specifying
	// an IP address range in the Zone Lockdown rule.
	Target LegacyJhsZonelockdownConfigurationsLegacyJhsSchemasCIDRConfigurationTarget `json:"target"`
	// The IP address range to match. You can only use prefix lengths `/16` and `/24`.
	Value string                                                                   `json:"value"`
	JSON  legacyJhsZonelockdownConfigurationsLegacyJhsSchemasCIDRConfigurationJSON `json:"-"`
}

type LegacyJhsZonelockdownConfigurationsLegacyJhsSchemasCIDRConfigurationTarget string

type LegacyJhsZonelockdownConfigurationsLegacyJhsSchemasIPConfiguration struct {
	// The configuration target. You must set the target to `ip` when specifying an IP
	// address in the Zone Lockdown rule.
	Target LegacyJhsZonelockdownConfigurationsLegacyJhsSchemasIPConfigurationTarget `json:"target"`
	// The IP address to match. This address will be compared to the IP address of
	// incoming requests.
	Value string                                                                 `json:"value"`
	JSON  legacyJhsZonelockdownConfigurationsLegacyJhsSchemasIPConfigurationJSON `json:"-"`
}

type LegacyJhsZonelockdownConfigurationsLegacyJhsSchemasIPConfigurationTarget string

type LockdownDeleteResponse struct {
	// The unique identifier of the Zone Lockdown rule.
	ID   string                     `json:"id"`
	JSON lockdownDeleteResponseJSON `json:"-"`
}

type LockdownDeleteResponseEnvelope struct {
	Result LockdownDeleteResponse             `json:"result"`
	JSON   lockdownDeleteResponseEnvelopeJSON `json:"-"`
}

type LockdownGetResponseEnvelope struct {
	Errors   []LockdownGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []LockdownGetResponseEnvelopeMessages `json:"messages,required"`
	Result   LegacyJhsZonelockdown                 `json:"result,required,nullable"`
	// Whether the API call was successful
	Success LockdownGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    lockdownGetResponseEnvelopeJSON    `json:"-"`
}

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

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

type LockdownGetResponseEnvelopeSuccess bool

type LockdownListParams struct {
	// A string to search for in the description of existing rules.
	Description param.Field[string] `query:"description"`
	// A string to search for in the description of existing rules.
	DescriptionSearch param.Field[string] `query:"description_search"`
	// A single IP address to search for in existing rules.
	IP param.Field[string] `query:"ip"`
	// A single IP address range to search for in existing rules.
	IPRangeSearch param.Field[string] `query:"ip_range_search"`
	// A single IP address to search for in existing rules.
	IPSearch param.Field[string] `query:"ip_search"`
	// Page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// The maximum number of results per page. You can only set the value to `1` or to
	// a multiple of 5 such as `5`, `10`, `15`, or `20`.
	PerPage param.Field[float64] `query:"per_page"`
	// The priority of the rule to control the processing order. A lower number
	// indicates higher priority. If not provided, any rules with a configured priority
	// will be processed before rules without a priority.
	Priority param.Field[float64] `query:"priority"`
	// A single URI to search for in the list of URLs of existing rules.
	URISearch param.Field[string] `query:"uri_search"`
}

type LockdownNewParams struct {
	Body param.Field[interface{}] `json:"body,required"`
}

type LockdownNewResponseEnvelope struct {
	Errors   []LockdownNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []LockdownNewResponseEnvelopeMessages `json:"messages,required"`
	Result   LegacyJhsZonelockdown                 `json:"result,required,nullable"`
	// Whether the API call was successful
	Success LockdownNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    lockdownNewResponseEnvelopeJSON    `json:"-"`
}

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

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

type LockdownNewResponseEnvelopeSuccess bool

type LockdownService struct {
	Options []option.RequestOption
}

type LockdownUpdateParams struct {
	Body param.Field[interface{}] `json:"body,required"`
}

type LockdownUpdateResponseEnvelope struct {
	Errors   []LockdownUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []LockdownUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   LegacyJhsZonelockdown                    `json:"result,required,nullable"`
	// Whether the API call was successful
	Success LockdownUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    lockdownUpdateResponseEnvelopeJSON    `json:"-"`
}

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

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

type LockdownUpdateResponseEnvelopeSuccess bool

type RuleDeleteParams struct {
	// When true, indicates that Cloudflare should also delete the associated filter if
	// there are no other firewall rules referencing the filter.
	DeleteFilterIfUnused param.Field[bool] `json:"delete_filter_if_unused"`
}

type RuleDeleteResponseEnvelope struct {
	Errors   []RuleDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   LegacyJhsFilterRule                  `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RuleDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    ruleDeleteResponseEnvelopeJSON    `json:"-"`
}

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

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

type RuleDeleteResponseEnvelopeSuccess bool

type RuleEditParams struct {
	Body param.Field[interface{}] `json:"body,required"`
}

type RuleEditResponseEnvelope struct {
	Errors   []RuleEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleEditResponseEnvelopeMessages `json:"messages,required"`
	Result   []LegacyJhsFilterRule              `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    RuleEditResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo RuleEditResponseEnvelopeResultInfo `json:"result_info"`
	JSON       ruleEditResponseEnvelopeJSON       `json:"-"`
}

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

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

type RuleEditResponseEnvelopeResultInfo 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       ruleEditResponseEnvelopeResultInfoJSON `json:"-"`
}

type RuleEditResponseEnvelopeSuccess bool

type RuleGetParams struct {
}

type RuleGetResponseEnvelope struct {
	Errors   []RuleGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleGetResponseEnvelopeMessages `json:"messages,required"`
	Result   LegacyJhsFilterRule               `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RuleGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    ruleGetResponseEnvelopeJSON    `json:"-"`
}

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

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

type RuleGetResponseEnvelopeSuccess bool

type RuleListParams struct {
	// The action to search for. Must be an exact match.
	Action param.Field[string] `query:"action"`
	// A case-insensitive string to find in the description.
	Description param.Field[string] `query:"description"`
	// Page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// When true, indicates that the firewall rule is currently paused.
	Paused param.Field[bool] `query:"paused"`
	// Number of firewall rules per page.
	PerPage param.Field[float64] `query:"per_page"`
}

type RuleNewParams struct {
	Body param.Field[interface{}] `json:"body,required"`
}

type RuleNewResponseEnvelope struct {
	Errors   []RuleNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleNewResponseEnvelopeMessages `json:"messages,required"`
	Result   []LegacyJhsFilterRule             `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    RuleNewResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo RuleNewResponseEnvelopeResultInfo `json:"result_info"`
	JSON       ruleNewResponseEnvelopeJSON       `json:"-"`
}

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

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

type RuleNewResponseEnvelopeResultInfo 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       ruleNewResponseEnvelopeResultInfoJSON `json:"-"`
}

type RuleNewResponseEnvelopeSuccess bool

type RuleService struct {
	Options []option.RequestOption
}

type RuleUpdateParams struct {
	Body param.Field[interface{}] `json:"body,required"`
}

type RuleUpdateResponseEnvelope struct {
	Errors   []RuleUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   LegacyJhsFilterRule                  `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RuleUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    ruleUpdateResponseEnvelopeJSON    `json:"-"`
}

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

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

type RuleUpdateResponseEnvelopeSuccess bool

type UARuleDeleteResponse struct {
	// The unique identifier of the User Agent Blocking rule.
	ID   string                   `json:"id"`
	JSON uaRuleDeleteResponseJSON `json:"-"`
}

type UARuleDeleteResponseEnvelope struct {
	Errors   []UARuleDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []UARuleDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   UARuleDeleteResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success UARuleDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    uaRuleDeleteResponseEnvelopeJSON    `json:"-"`
}

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

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

type UARuleDeleteResponseEnvelopeSuccess bool

type UARuleGetResponse interface {
	ImplementsFirewallUARuleGetResponse()
}

type UARuleGetResponseEnvelope struct {
	Errors   []UARuleGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []UARuleGetResponseEnvelopeMessages `json:"messages,required"`
	Result   UARuleGetResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success UARuleGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    uaRuleGetResponseEnvelopeJSON    `json:"-"`
}

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

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

type UARuleGetResponseEnvelopeSuccess bool

type UARuleListParams struct {
	// A string to search for in the description of existing rules.
	Description param.Field[string] `query:"description"`
	// A string to search for in the description of existing rules.
	DescriptionSearch param.Field[string] `query:"description_search"`
	// Page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// The maximum number of results per page. You can only set the value to `1` or to
	// a multiple of 5 such as `5`, `10`, `15`, or `20`.
	PerPage param.Field[float64] `query:"per_page"`
	// A string to search for in the user agent values of existing rules.
	UASearch param.Field[string] `query:"ua_search"`
}

type UARuleListResponse struct {
	// The unique identifier of the User Agent Blocking rule.
	ID string `json:"id"`
	// The configuration object for the current rule.
	Configuration UARuleListResponseConfiguration `json:"configuration"`
	// An informative summary of the rule.
	Description string `json:"description"`
	// The action to apply to a matched request.
	Mode UARuleListResponseMode `json:"mode"`
	// When true, indicates that the rule is currently paused.
	Paused bool                   `json:"paused"`
	JSON   uaRuleListResponseJSON `json:"-"`
}

type UARuleListResponseConfiguration struct {
	// The configuration target for this rule. You must set the target to `ua` for User
	// Agent Blocking rules.
	Target string `json:"target"`
	// The exact user agent string to match. This value will be compared to the
	// received `User-Agent` HTTP header value.
	Value string                              `json:"value"`
	JSON  uaRuleListResponseConfigurationJSON `json:"-"`
}

type UARuleListResponseMode string

type UARuleNewParams struct {
	Body param.Field[interface{}] `json:"body,required"`
}

type UARuleNewResponse interface {
	ImplementsFirewallUARuleNewResponse()
}

type UARuleNewResponseEnvelope struct {
	Errors   []UARuleNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []UARuleNewResponseEnvelopeMessages `json:"messages,required"`
	Result   UARuleNewResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success UARuleNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    uaRuleNewResponseEnvelopeJSON    `json:"-"`
}

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

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

type UARuleNewResponseEnvelopeSuccess bool

type UARuleService struct {
	Options []option.RequestOption
}

type UARuleUpdateParams struct {
	Body param.Field[interface{}] `json:"body,required"`
}

type UARuleUpdateResponse interface {
	ImplementsFirewallUARuleUpdateResponse()
}

type UARuleUpdateResponseEnvelope struct {
	Errors   []UARuleUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []UARuleUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   UARuleUpdateResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success UARuleUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    uaRuleUpdateResponseEnvelopeJSON    `json:"-"`
}

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

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

type UARuleUpdateResponseEnvelopeSuccess bool

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

type WAFManagedRulesRuleWAFManagedRulesAnomalyRule struct {
	// The unique identifier of the WAF rule.
	ID string `json:"id,required"`
	// Defines the available modes for the current WAF rule. Applies to anomaly
	// detection WAF rules.
	AllowedModes []WAFManagedRulesRuleWAFManagedRulesAnomalyRuleAllowedMode `json:"allowed_modes,required"`
	// The public description of the WAF rule.
	Description string `json:"description,required"`
	// The rule group to which the current WAF rule belongs.
	Group WAFManagedRulesRuleWAFManagedRulesAnomalyRuleGroup `json:"group,required"`
	// When set to `on`, the current WAF rule will be used when evaluating the request.
	// Applies to anomaly detection WAF rules.
	Mode WAFManagedRulesRuleWAFManagedRulesAnomalyRuleMode `json:"mode,required"`
	// The unique identifier of a WAF package.
	PackageID string `json:"package_id,required"`
	// The order in which the individual WAF rule is executed within its rule group.
	Priority string                                            `json:"priority,required"`
	JSON     wafManagedRulesRuleWAFManagedRulesAnomalyRuleJSON `json:"-"`
}

type WAFManagedRulesRuleWAFManagedRulesAnomalyRuleAllowedMode string

type WAFManagedRulesRuleWAFManagedRulesAnomalyRuleGroup struct {
	// The unique identifier of the rule group.
	ID string `json:"id"`
	// The name of the rule group.
	Name string                                                 `json:"name"`
	JSON wafManagedRulesRuleWAFManagedRulesAnomalyRuleGroupJSON `json:"-"`
}

type WAFManagedRulesRuleWAFManagedRulesAnomalyRuleMode string

type WAFManagedRulesRuleWAFManagedRulesTraditionalAllowRule struct {
	// The unique identifier of the WAF rule.
	ID string `json:"id,required"`
	// Defines the available modes for the current WAF rule.
	AllowedModes []WAFManagedRulesRuleWAFManagedRulesTraditionalAllowRuleAllowedMode `json:"allowed_modes,required"`
	// The public description of the WAF rule.
	Description string `json:"description,required"`
	// The rule group to which the current WAF rule belongs.
	Group WAFManagedRulesRuleWAFManagedRulesTraditionalAllowRuleGroup `json:"group,required"`
	// When set to `on`, the current rule will be used when evaluating the request.
	// Applies to traditional (allow) WAF rules.
	Mode WAFManagedRulesRuleWAFManagedRulesTraditionalAllowRuleMode `json:"mode,required"`
	// The unique identifier of a WAF package.
	PackageID string `json:"package_id,required"`
	// The order in which the individual WAF rule is executed within its rule group.
	Priority string                                                     `json:"priority,required"`
	JSON     wafManagedRulesRuleWAFManagedRulesTraditionalAllowRuleJSON `json:"-"`
}

type WAFManagedRulesRuleWAFManagedRulesTraditionalAllowRuleAllowedMode string

type WAFManagedRulesRuleWAFManagedRulesTraditionalAllowRuleGroup struct {
	// The unique identifier of the rule group.
	ID string `json:"id"`
	// The name of the rule group.
	Name string                                                          `json:"name"`
	JSON wafManagedRulesRuleWAFManagedRulesTraditionalAllowRuleGroupJSON `json:"-"`
}

type WAFManagedRulesRuleWAFManagedRulesTraditionalAllowRuleMode string

type WAFManagedRulesRuleWAFManagedRulesTraditionalDenyRule struct {
	// The unique identifier of the WAF rule.
	ID string `json:"id,required"`
	// The list of possible actions of the WAF rule when it is triggered.
	AllowedModes []WAFManagedRulesRuleWAFManagedRulesTraditionalDenyRuleAllowedMode `json:"allowed_modes,required"`
	// The default action/mode of a rule.
	DefaultMode WAFManagedRulesRuleWAFManagedRulesTraditionalDenyRuleDefaultMode `json:"default_mode,required"`
	// The public description of the WAF rule.
	Description string `json:"description,required"`
	// The rule group to which the current WAF rule belongs.
	Group WAFManagedRulesRuleWAFManagedRulesTraditionalDenyRuleGroup `json:"group,required"`
	// The action that the current WAF rule will perform when triggered. Applies to
	// traditional (deny) WAF rules.
	Mode WAFManagedRulesRuleWAFManagedRulesTraditionalDenyRuleMode `json:"mode,required"`
	// The unique identifier of a WAF package.
	PackageID string `json:"package_id,required"`
	// The order in which the individual WAF rule is executed within its rule group.
	Priority string                                                    `json:"priority,required"`
	JSON     wafManagedRulesRuleWAFManagedRulesTraditionalDenyRuleJSON `json:"-"`
}

type WAFManagedRulesRuleWAFManagedRulesTraditionalDenyRuleAllowedMode string

type WAFManagedRulesRuleWAFManagedRulesTraditionalDenyRuleDefaultMode string

type WAFManagedRulesRuleWAFManagedRulesTraditionalDenyRuleGroup struct {
	// The unique identifier of the rule group.
	ID string `json:"id"`
	// The name of the rule group.
	Name string                                                         `json:"name"`
	JSON wafManagedRulesRuleWAFManagedRulesTraditionalDenyRuleGroupJSON `json:"-"`
}

type WAFManagedRulesRuleWAFManagedRulesTraditionalDenyRuleMode string

type WAFManagedRulesSchemasGroup struct {
	// The unique identifier of the rule group.
	ID string `json:"id,required"`
	// An informative summary of what the rule group does.
	Description string `json:"description,required,nullable"`
	// The state of the rules contained in the rule group. When `on`, the rules in the
	// group are configurable/usable.
	Mode WAFManagedRulesSchemasGroupMode `json:"mode,required"`
	// The name of the rule group.
	Name string `json:"name,required"`
	// The number of rules in the current rule group.
	RulesCount float64 `json:"rules_count,required"`
	// The available states for the rule group.
	AllowedModes []WAFManagedRulesSchemasGroupAllowedMode `json:"allowed_modes"`
	// The number of rules within the group that have been modified from their default
	// configuration.
	ModifiedRulesCount float64 `json:"modified_rules_count"`
	// The unique identifier of a WAF package.
	PackageID string                          `json:"package_id"`
	JSON      wafManagedRulesSchemasGroupJSON `json:"-"`
}

type WAFManagedRulesSchemasGroupAllowedMode string

type WAFManagedRulesSchemasGroupMode string

type WAFOverrideDeleteResponse struct {
	// The unique identifier of the WAF override.
	ID   string                        `json:"id"`
	JSON wafOverrideDeleteResponseJSON `json:"-"`
}

type WAFOverrideDeleteResponseEnvelope struct {
	Result WAFOverrideDeleteResponse             `json:"result"`
	JSON   wafOverrideDeleteResponseEnvelopeJSON `json:"-"`
}

type WAFOverrideGetResponseEnvelope struct {
	Errors   []WAFOverrideGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WAFOverrideGetResponseEnvelopeMessages `json:"messages,required"`
	Result   LegacyJhsOverride                        `json:"result,required,nullable"`
	// Whether the API call was successful
	Success WAFOverrideGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    wafOverrideGetResponseEnvelopeJSON    `json:"-"`
}

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

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

type WAFOverrideGetResponseEnvelopeSuccess bool

type WAFOverrideListParams struct {
	// The page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// The number of WAF overrides per page.
	PerPage param.Field[float64] `query:"per_page"`
}

type WAFOverrideNewParams struct {
	Body param.Field[interface{}] `json:"body,required"`
}

type WAFOverrideNewResponseEnvelope struct {
	Errors   []WAFOverrideNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WAFOverrideNewResponseEnvelopeMessages `json:"messages,required"`
	Result   LegacyJhsOverride                        `json:"result,required,nullable"`
	// Whether the API call was successful
	Success WAFOverrideNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    wafOverrideNewResponseEnvelopeJSON    `json:"-"`
}

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

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

type WAFOverrideNewResponseEnvelopeSuccess bool

type WAFOverrideService struct {
	Options []option.RequestOption
}

type WAFOverrideUpdateParams struct {
	Body param.Field[interface{}] `json:"body,required"`
}

type WAFOverrideUpdateResponseEnvelope struct {
	Errors   []WAFOverrideUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WAFOverrideUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   LegacyJhsOverride                           `json:"result,required,nullable"`
	// Whether the API call was successful
	Success WAFOverrideUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    wafOverrideUpdateResponseEnvelopeJSON    `json:"-"`
}

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

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

type WAFOverrideUpdateResponseEnvelopeSuccess bool

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

type WAFPackageGetResponseLegacyJhsAPIResponseSingle struct {
	Errors   []WAFPackageGetResponseLegacyJhsAPIResponseSingleError   `json:"errors,required"`
	Messages []WAFPackageGetResponseLegacyJhsAPIResponseSingleMessage `json:"messages,required"`
	Result   WAFPackageGetResponseLegacyJhsAPIResponseSingleResult    `json:"result,required,nullable"`
	// Whether the API call was successful
	Success WAFPackageGetResponseLegacyJhsAPIResponseSingleSuccess `json:"success,required"`
	JSON    wafPackageGetResponseLegacyJhsAPIResponseSingleJSON    `json:"-"`
}

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

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

type WAFPackageGetResponseLegacyJhsAPIResponseSingleResult interface {
	ImplementsFirewallWAFPackageGetResponseLegacyJhsAPIResponseSingleResult()
}

type WAFPackageGetResponseLegacyJhsAPIResponseSingleSuccess bool

type WAFPackageGetResponseObject struct {
	Result interface{}                     `json:"result"`
	JSON   wafPackageGetResponseObjectJSON `json:"-"`
}

type WAFPackageGroupEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The state of the rules contained in the rule group. When `on`, the rules in the
	// group are configurable/usable.
	Mode param.Field[WAFPackageGroupEditParamsMode] `json:"mode"`
}

type WAFPackageGroupEditParamsMode string

type WAFPackageGroupEditResponse interface {
	ImplementsFirewallWAFPackageGroupEditResponse()
}

type WAFPackageGroupEditResponseArray []interface{}

type WAFPackageGroupEditResponseEnvelope struct {
	Errors   []WAFPackageGroupEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WAFPackageGroupEditResponseEnvelopeMessages `json:"messages,required"`
	Result   WAFPackageGroupEditResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success WAFPackageGroupEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    wafPackageGroupEditResponseEnvelopeJSON    `json:"-"`
}

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

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

type WAFPackageGroupEditResponseEnvelopeSuccess bool

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

type WAFPackageGroupGetResponse interface {
	ImplementsFirewallWAFPackageGroupGetResponse()
}

type WAFPackageGroupGetResponseArray []interface{}

type WAFPackageGroupGetResponseEnvelope struct {
	Errors   []WAFPackageGroupGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WAFPackageGroupGetResponseEnvelopeMessages `json:"messages,required"`
	Result   WAFPackageGroupGetResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success WAFPackageGroupGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    wafPackageGroupGetResponseEnvelopeJSON    `json:"-"`
}

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

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

type WAFPackageGroupGetResponseEnvelopeSuccess bool

type WAFPackageGroupListParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The direction used to sort returned rule groups.
	Direction param.Field[WAFPackageGroupListParamsDirection] `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[WAFPackageGroupListParamsMatch] `query:"match"`
	// The state of the rules contained in the rule group. When `on`, the rules in the
	// group are configurable/usable.
	Mode param.Field[WAFPackageGroupListParamsMode] `query:"mode"`
	// The field used to sort returned rule groups.
	Order param.Field[WAFPackageGroupListParamsOrder] `query:"order"`
	// The page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// The number of rule groups per page.
	PerPage param.Field[float64] `query:"per_page"`
}

type WAFPackageGroupListParamsDirection string

type WAFPackageGroupListParamsMatch string

type WAFPackageGroupListParamsMode string

type WAFPackageGroupListParamsOrder string

type WAFPackageGroupService struct {
	Options []option.RequestOption
}

type WAFPackageListParams struct {
	// The direction used to sort returned packages.
	Direction param.Field[WAFPackageListParamsDirection] `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[WAFPackageListParamsMatch] `query:"match"`
	// The field used to sort returned packages.
	Order param.Field[WAFPackageListParamsOrder] `query:"order"`
	// The page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// The number of packages per page.
	PerPage param.Field[float64] `query:"per_page"`
}

type WAFPackageListParamsDirection string

type WAFPackageListParamsMatch string

type WAFPackageListParamsOrder string

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

type WAFPackageListResponseLegacyJhsAPIResponseCollection struct {
	Errors   []WAFPackageListResponseLegacyJhsAPIResponseCollectionError   `json:"errors,required"`
	Messages []WAFPackageListResponseLegacyJhsAPIResponseCollectionMessage `json:"messages,required"`
	Result   WAFPackageListResponseLegacyJhsAPIResponseCollectionResult    `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    WAFPackageListResponseLegacyJhsAPIResponseCollectionSuccess    `json:"success,required"`
	ResultInfo WAFPackageListResponseLegacyJhsAPIResponseCollectionResultInfo `json:"result_info"`
	JSON       wafPackageListResponseLegacyJhsAPIResponseCollectionJSON       `json:"-"`
}

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

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

type WAFPackageListResponseLegacyJhsAPIResponseCollectionResult interface {
	ImplementsFirewallWAFPackageListResponseLegacyJhsAPIResponseCollectionResult()
}

type WAFPackageListResponseLegacyJhsAPIResponseCollectionResultArray []interface{}

type WAFPackageListResponseLegacyJhsAPIResponseCollectionResultInfo 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       wafPackageListResponseLegacyJhsAPIResponseCollectionResultInfoJSON `json:"-"`
}

type WAFPackageListResponseLegacyJhsAPIResponseCollectionSuccess bool

type WAFPackageListResponseObject struct {
	Result []WAFPackageListResponseObjectResult `json:"result"`
	JSON   wafPackageListResponseObjectJSON     `json:"-"`
}

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

type WAFPackageListResponseObjectResultLegacyJhsAnomalyPackage struct {
	// The unique identifier of a WAF package.
	ID string `json:"id,required"`
	// A summary of the purpose/function of the WAF package.
	Description string `json:"description,required"`
	// When a WAF package uses anomaly detection, each rule is given a score when
	// triggered. If the total score of all triggered rules exceeds the sensitivity
	// defined on the WAF package, the action defined on the package will be taken.
	DetectionMode WAFPackageListResponseObjectResultLegacyJhsAnomalyPackageDetectionMode `json:"detection_mode,required"`
	// The name of the WAF package.
	Name string `json:"name,required"`
	// Identifier
	ZoneID string `json:"zone_id,required"`
	// The default action performed by the rules in the WAF package.
	ActionMode WAFPackageListResponseObjectResultLegacyJhsAnomalyPackageActionMode `json:"action_mode"`
	// The sensitivity of the WAF package.
	Sensitivity WAFPackageListResponseObjectResultLegacyJhsAnomalyPackageSensitivity `json:"sensitivity"`
	// When set to `active`, indicates that the WAF package will be applied to the
	// zone.
	Status WAFPackageListResponseObjectResultLegacyJhsAnomalyPackageStatus `json:"status"`
	JSON   wafPackageListResponseObjectResultLegacyJhsAnomalyPackageJSON   `json:"-"`
}

type WAFPackageListResponseObjectResultLegacyJhsAnomalyPackageActionMode string

type WAFPackageListResponseObjectResultLegacyJhsAnomalyPackageDetectionMode string

type WAFPackageListResponseObjectResultLegacyJhsAnomalyPackageSensitivity string

type WAFPackageListResponseObjectResultLegacyJhsAnomalyPackageStatus string

type WAFPackageListResponseObjectResultLegacyJhsPackageDefinition struct {
	// The unique identifier of a WAF package.
	ID string `json:"id,required"`
	// A summary of the purpose/function of the WAF package.
	Description string `json:"description,required"`
	// The mode that defines how rules within the package are evaluated during the
	// course of a request. When a package uses anomaly detection mode (`anomaly`
	// value), each rule is given a score when triggered. If the total score of all
	// triggered rules exceeds the sensitivity defined in the WAF package, the action
	// configured in the package will be performed. Traditional detection mode
	// (`traditional` value) will decide the action to take when it is triggered by the
	// request. If multiple rules are triggered, the action providing the highest
	// protection will be applied (for example, a 'block' action will win over a
	// 'challenge' action).
	DetectionMode WAFPackageListResponseObjectResultLegacyJhsPackageDefinitionDetectionMode `json:"detection_mode,required"`
	// The name of the WAF package.
	Name string `json:"name,required"`
	// Identifier
	ZoneID string `json:"zone_id,required"`
	// When set to `active`, indicates that the WAF package will be applied to the
	// zone.
	Status WAFPackageListResponseObjectResultLegacyJhsPackageDefinitionStatus `json:"status"`
	JSON   wafPackageListResponseObjectResultLegacyJhsPackageDefinitionJSON   `json:"-"`
}

type WAFPackageListResponseObjectResultLegacyJhsPackageDefinitionDetectionMode string

type WAFPackageListResponseObjectResultLegacyJhsPackageDefinitionStatus string

type WAFPackageRuleEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The mode/action of the rule when triggered. You must use a value from the
	// `allowed_modes` array of the current rule.
	Mode param.Field[WAFPackageRuleEditParamsMode] `json:"mode"`
}

type WAFPackageRuleEditParamsMode string

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

type WAFPackageRuleEditResponseEnvelope struct {
	Errors   []WAFPackageRuleEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WAFPackageRuleEditResponseEnvelopeMessages `json:"messages,required"`
	// When triggered, anomaly detection WAF rules contribute to an overall threat
	// score that will determine if a request is considered malicious. You can
	// configure the total scoring threshold through the 'sensitivity' property of the
	// WAF package.
	Result WAFPackageRuleEditResponse `json:"result,required"`
	// Whether the API call was successful
	Success WAFPackageRuleEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    wafPackageRuleEditResponseEnvelopeJSON    `json:"-"`
}

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

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

type WAFPackageRuleEditResponseEnvelopeSuccess bool

type WAFPackageRuleEditResponseWAFManagedRulesAnomalyRule struct {
	// The unique identifier of the WAF rule.
	ID string `json:"id,required"`
	// Defines the available modes for the current WAF rule. Applies to anomaly
	// detection WAF rules.
	AllowedModes []WAFPackageRuleEditResponseWAFManagedRulesAnomalyRuleAllowedMode `json:"allowed_modes,required"`
	// The public description of the WAF rule.
	Description string `json:"description,required"`
	// The rule group to which the current WAF rule belongs.
	Group WAFPackageRuleEditResponseWAFManagedRulesAnomalyRuleGroup `json:"group,required"`
	// When set to `on`, the current WAF rule will be used when evaluating the request.
	// Applies to anomaly detection WAF rules.
	Mode WAFPackageRuleEditResponseWAFManagedRulesAnomalyRuleMode `json:"mode,required"`
	// The unique identifier of a WAF package.
	PackageID string `json:"package_id,required"`
	// The order in which the individual WAF rule is executed within its rule group.
	Priority string                                                   `json:"priority,required"`
	JSON     wafPackageRuleEditResponseWAFManagedRulesAnomalyRuleJSON `json:"-"`
}

type WAFPackageRuleEditResponseWAFManagedRulesAnomalyRuleAllowedMode string

type WAFPackageRuleEditResponseWAFManagedRulesAnomalyRuleGroup struct {
	// The unique identifier of the rule group.
	ID string `json:"id"`
	// The name of the rule group.
	Name string                                                        `json:"name"`
	JSON wafPackageRuleEditResponseWAFManagedRulesAnomalyRuleGroupJSON `json:"-"`
}

type WAFPackageRuleEditResponseWAFManagedRulesAnomalyRuleMode string

type WAFPackageRuleEditResponseWAFManagedRulesTraditionalAllowRule struct {
	// The unique identifier of the WAF rule.
	ID string `json:"id,required"`
	// Defines the available modes for the current WAF rule.
	AllowedModes []WAFPackageRuleEditResponseWAFManagedRulesTraditionalAllowRuleAllowedMode `json:"allowed_modes,required"`
	// The public description of the WAF rule.
	Description string `json:"description,required"`
	// The rule group to which the current WAF rule belongs.
	Group WAFPackageRuleEditResponseWAFManagedRulesTraditionalAllowRuleGroup `json:"group,required"`
	// When set to `on`, the current rule will be used when evaluating the request.
	// Applies to traditional (allow) WAF rules.
	Mode WAFPackageRuleEditResponseWAFManagedRulesTraditionalAllowRuleMode `json:"mode,required"`
	// The unique identifier of a WAF package.
	PackageID string `json:"package_id,required"`
	// The order in which the individual WAF rule is executed within its rule group.
	Priority string                                                            `json:"priority,required"`
	JSON     wafPackageRuleEditResponseWAFManagedRulesTraditionalAllowRuleJSON `json:"-"`
}

type WAFPackageRuleEditResponseWAFManagedRulesTraditionalAllowRuleAllowedMode string

type WAFPackageRuleEditResponseWAFManagedRulesTraditionalAllowRuleGroup struct {
	// The unique identifier of the rule group.
	ID string `json:"id"`
	// The name of the rule group.
	Name string                                                                 `json:"name"`
	JSON wafPackageRuleEditResponseWAFManagedRulesTraditionalAllowRuleGroupJSON `json:"-"`
}