rate_limits

type ASN = shared.ASN

type ASNParam = shared.ASNParam

type Action string

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 CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type Error = apierror.Error

type ErrorData = shared.ErrorData

type Member = shared.Member

type MemberParam = shared.MemberParam

type MemberRole = shared.MemberRole

type MemberRoleParam = shared.MemberRoleParam

type MemberRolesPermissions = shared.MemberRolesPermissions

type MemberRolesPermissionsParam = shared.MemberRolesPermissionsParam

type MemberUser = shared.MemberUser

type MemberUserParam = shared.MemberUserParam

type Methods string

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type RateLimit struct {
	// The unique identifier of the rate limit.
	ID string `json:"id"`
	// The action to perform when the threshold of matched traffic within the
	// configured period is exceeded.
	Action RateLimitAction `json:"action"`
	// Criteria specifying when the current rate limit should be bypassed. You can
	// specify that the rate limit should not apply to one or more URLs.
	Bypass []RateLimitBypass `json:"bypass"`
	// An informative summary of the rate limit. This value is sanitized and any tags
	// will be removed.
	Description string `json:"description"`
	// When true, indicates that the rate limit is currently disabled.
	Disabled bool `json:"disabled"`
	// Determines which traffic the rate limit counts towards the threshold.
	Match RateLimitMatch `json:"match"`
	// The time in seconds (an integer value) to count matching traffic. If the count
	// exceeds the configured threshold within this period, Cloudflare will perform the
	// configured action.
	Period float64 `json:"period"`
	// The threshold that will trigger the configured mitigation action. Configure this
	// value along with the `period` property to establish a threshold per period.
	Threshold float64       `json:"threshold"`
	JSON      rateLimitJSON `json:"-"`
}

type RateLimitAction struct {
	// The action to perform.
	Mode RateLimitActionMode `json:"mode"`
	// A custom content type and reponse to return when the threshold is exceeded. The
	// custom response configured in this object will override the custom error for the
	// zone. This object is optional. Notes: If you omit this object, Cloudflare will
	// use the default HTML error page. If "mode" is "challenge", "managed_challenge",
	// or "js_challenge", Cloudflare will use the zone challenge pages and you should
	// not provide the "response" object.
	Response RateLimitActionResponse `json:"response"`
	// The time in seconds during which Cloudflare will perform the mitigation action.
	// Must be an integer value greater than or equal to the period. Notes: If "mode"
	// is "challenge", "managed_challenge", or "js_challenge", Cloudflare will use the
	// zone's Challenge Passage time and you should not provide this value.
	Timeout float64             `json:"timeout"`
	JSON    rateLimitActionJSON `json:"-"`
}

type RateLimitActionMode string

type RateLimitActionResponse struct {
	// The response body to return. The value must conform to the configured content
	// type.
	Body string `json:"body"`
	// The content type of the body. Must be one of the following: `text/plain`,
	// `text/xml`, or `application/json`.
	ContentType string                      `json:"content_type"`
	JSON        rateLimitActionResponseJSON `json:"-"`
}

type RateLimitBypass struct {
	Name RateLimitBypassName `json:"name"`
	// The URL to bypass.
	Value string              `json:"value"`
	JSON  rateLimitBypassJSON `json:"-"`
}

type RateLimitBypassName string

type RateLimitDeleteParams struct {
	Body interface{} `json:"body,required"`
}

type RateLimitDeleteResponse struct {
	// The unique identifier of the rate limit.
	ID   string                      `json:"id"`
	JSON rateLimitDeleteResponseJSON `json:"-"`
}

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

type RateLimitDeleteResponseEnvelopeSuccess bool

type RateLimitEditParams struct {
	Body interface{} `json:"body,required"`
}

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

type RateLimitEditResponseEnvelopeSuccess bool

type RateLimitEditResponseUnion interface {
	ImplementsRateLimitsRateLimitEditResponseUnion()
}

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

type RateLimitGetResponseEnvelopeSuccess bool

type RateLimitGetResponseUnion interface {
	ImplementsRateLimitsRateLimitGetResponseUnion()
}

type RateLimitListParams 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 RateLimitMatch struct {
	Headers  []RateLimitMatchHeader `json:"headers"`
	Request  RateLimitMatchRequest  `json:"request"`
	Response RateLimitMatchResponse `json:"response"`
	JSON     rateLimitMatchJSON     `json:"-"`
}

type RateLimitMatchHeader struct {
	// The name of the response header to match.
	Name string `json:"name"`
	// The operator used when matching: `eq` means "equal" and `ne` means "not equal".
	Op RateLimitMatchHeadersOp `json:"op"`
	// The value of the response header, which must match exactly.
	Value string                   `json:"value"`
	JSON  rateLimitMatchHeaderJSON `json:"-"`
}

type RateLimitMatchHeadersOp string

type RateLimitMatchRequest struct {
	// The HTTP methods to match. You can specify a subset (for example,
	// `['POST','PUT']`) or all methods (`['_ALL_']`). This field is optional when
	// creating a rate limit.
	Methods []Methods `json:"methods"`
	// The HTTP schemes to match. You can specify one scheme (`['HTTPS']`), both
	// schemes (`['HTTP','HTTPS']`), or all schemes (`['_ALL_']`). This field is
	// optional.
	Schemes []string `json:"schemes"`
	// The URL pattern to match, composed of a host and a path such as
	// `example.org/path*`. Normalization is applied before the pattern is matched. `*`
	// wildcards are expanded to match applicable traffic. Query strings are not
	// matched. Set the value to `*` to match all traffic to your zone.
	URL  string                    `json:"url"`
	JSON rateLimitMatchRequestJSON `json:"-"`
}

type RateLimitMatchResponse struct {
	// When true, only the uncached traffic served from your origin servers will count
	// towards rate limiting. In this case, any cached traffic served by Cloudflare
	// will not count towards rate limiting. This field is optional. Notes: This field
	// is deprecated. Instead, use response headers and set "origin_traffic" to "false"
	// to avoid legacy behaviour interacting with the "response_headers" property.
	OriginTraffic bool                       `json:"origin_traffic"`
	JSON          rateLimitMatchResponseJSON `json:"-"`
}

type RateLimitNewParams struct {
	Body interface{} `json:"body,required"`
}

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

type RateLimitNewResponseEnvelopeSuccess bool

type RateLimitNewResponseUnion interface {
	ImplementsRateLimitsRateLimitNewResponseUnion()
}

type RateLimitService struct {
	Options []option.RequestOption
}

type ResponseInfo = shared.ResponseInfo

type Role = shared.Role