pagerules

type Error = apierror.Error

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"`
	Result   PageruleDeleteResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success PageruleDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    pageruleDeleteResponseEnvelopeJSON    `json:"-"`
}

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

type PageruleDeleteResponseEnvelopeMessages struct {
	Code    int64                                      `json:"code,required"`
	Message string                                     `json:"message,required"`
	JSON    pageruleDeleteResponseEnvelopeMessagesJSON `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[[]PageruleEditParamsAction] `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[[]PageruleEditParamsTarget] `json:"targets"`
}

type PageruleEditParamsAction struct {
	// The type of route.
	Name  param.Field[PageruleEditParamsActionsName]  `json:"name"`
	Value param.Field[PageruleEditParamsActionsValue] `json:"value"`
}

type PageruleEditParamsActionsName string

type PageruleEditParamsActionsValue struct {
	// The response type for the URL redirect.
	Type param.Field[PageruleEditParamsActionsValueType] `json:"type"`
	// 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 PageruleEditParamsActionsValueType string

type PageruleEditParamsStatus string

type PageruleEditParamsTarget struct {
	// String constraint.
	Constraint param.Field[PageruleEditParamsTargetsConstraint] `json:"constraint,required"`
	// A target based on the URL of the request.
	Target param.Field[PageruleEditParamsTargetsTarget] `json:"target,required"`
}

type PageruleEditParamsTargetsConstraint struct {
	// The matches operator can use asterisks and pipes as wildcard and 'or' operators.
	Operator param.Field[PageruleEditParamsTargetsConstraintOperator] `json:"operator,required"`
	// The URL pattern to match against the current request. The pattern may contain up
	// to four asterisks ('\*') as placeholders.
	Value param.Field[string] `json:"value,required"`
}

type PageruleEditParamsTargetsConstraintOperator string

type PageruleEditParamsTargetsTarget string

type PageruleEditResponse interface {
	ImplementsPagerulesPageruleEditResponse()
}

type PageruleEditResponseEnvelope struct {
	Errors   []PageruleEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PageruleEditResponseEnvelopeMessages `json:"messages,required"`
	Result   PageruleEditResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success PageruleEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    pageruleEditResponseEnvelopeJSON    `json:"-"`
}

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

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

type PageruleEditResponseEnvelopeSuccess bool

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

type PageruleGetResponse interface {
	ImplementsPagerulesPageruleGetResponse()
}

type PageruleGetResponseEnvelope struct {
	Errors   []PageruleGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PageruleGetResponseEnvelopeMessages `json:"messages,required"`
	Result   PageruleGetResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success PageruleGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    pageruleGetResponseEnvelopeJSON    `json:"-"`
}

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

type PageruleGetResponseEnvelopeMessages struct {
	Code    int64                                   `json:"code,required"`
	Message string                                  `json:"message,required"`
	JSON    pageruleGetResponseEnvelopeMessagesJSON `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"`
	Result   []ZonesPageRule                        `json:"result,required"`
	// Whether the API call was successful
	Success PageruleListResponseEnvelopeSuccess `json:"success,required"`
	JSON    pageruleListResponseEnvelopeJSON    `json:"-"`
}

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

type PageruleListResponseEnvelopeMessages struct {
	Code    int64                                    `json:"code,required"`
	Message string                                   `json:"message,required"`
	JSON    pageruleListResponseEnvelopeMessagesJSON `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[[]PageruleNewParamsAction] `json:"actions,required"`
	// The rule targets to evaluate on each request.
	Targets param.Field[[]PageruleNewParamsTarget] `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 {
	// The type of route.
	Name  param.Field[PageruleNewParamsActionsName]  `json:"name"`
	Value param.Field[PageruleNewParamsActionsValue] `json:"value"`
}

type PageruleNewParamsActionsName string

type PageruleNewParamsActionsValue struct {
	// The response type for the URL redirect.
	Type param.Field[PageruleNewParamsActionsValueType] `json:"type"`
	// 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 PageruleNewParamsActionsValueType string

type PageruleNewParamsStatus string

type PageruleNewParamsTarget struct {
	// String constraint.
	Constraint param.Field[PageruleNewParamsTargetsConstraint] `json:"constraint,required"`
	// A target based on the URL of the request.
	Target param.Field[PageruleNewParamsTargetsTarget] `json:"target,required"`
}

type PageruleNewParamsTargetsConstraint struct {
	// The matches operator can use asterisks and pipes as wildcard and 'or' operators.
	Operator param.Field[PageruleNewParamsTargetsConstraintOperator] `json:"operator,required"`
	// The URL pattern to match against the current request. The pattern may contain up
	// to four asterisks ('\*') as placeholders.
	Value param.Field[string] `json:"value,required"`
}

type PageruleNewParamsTargetsConstraintOperator string

type PageruleNewParamsTargetsTarget string

type PageruleNewResponse interface {
	ImplementsPagerulesPageruleNewResponse()
}

type PageruleNewResponseEnvelope struct {
	Errors   []PageruleNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PageruleNewResponseEnvelopeMessages `json:"messages,required"`
	Result   PageruleNewResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success PageruleNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    pageruleNewResponseEnvelopeJSON    `json:"-"`
}

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

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

type PageruleNewResponseEnvelopeSuccess bool

type PageruleService struct {
	Options  []option.RequestOption
	Settings *SettingService
}

type PageruleUpdateParams 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[[]PageruleUpdateParamsAction] `json:"actions,required"`
	// The rule targets to evaluate on each request.
	Targets param.Field[[]PageruleUpdateParamsTarget] `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[PageruleUpdateParamsStatus] `json:"status"`
}

type PageruleUpdateParamsAction struct {
	// The type of route.
	Name  param.Field[PageruleUpdateParamsActionsName]  `json:"name"`
	Value param.Field[PageruleUpdateParamsActionsValue] `json:"value"`
}

type PageruleUpdateParamsActionsName string

type PageruleUpdateParamsActionsValue struct {
	// The response type for the URL redirect.
	Type param.Field[PageruleUpdateParamsActionsValueType] `json:"type"`
	// 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 PageruleUpdateParamsActionsValueType string

type PageruleUpdateParamsStatus string

type PageruleUpdateParamsTarget struct {
	// String constraint.
	Constraint param.Field[PageruleUpdateParamsTargetsConstraint] `json:"constraint,required"`
	// A target based on the URL of the request.
	Target param.Field[PageruleUpdateParamsTargetsTarget] `json:"target,required"`
}

type PageruleUpdateParamsTargetsConstraint struct {
	// The matches operator can use asterisks and pipes as wildcard and 'or' operators.
	Operator param.Field[PageruleUpdateParamsTargetsConstraintOperator] `json:"operator,required"`
	// The URL pattern to match against the current request. The pattern may contain up
	// to four asterisks ('\*') as placeholders.
	Value param.Field[string] `json:"value,required"`
}

type PageruleUpdateParamsTargetsConstraintOperator string

type PageruleUpdateParamsTargetsTarget string

type PageruleUpdateResponse interface {
	ImplementsPagerulesPageruleUpdateResponse()
}

type PageruleUpdateResponseEnvelope struct {
	Errors   []PageruleUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PageruleUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   PageruleUpdateResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success PageruleUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    pageruleUpdateResponseEnvelopeJSON    `json:"-"`
}

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

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

type PageruleUpdateResponseEnvelopeSuccess bool

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

type SettingListResponse = interface{}

type SettingListResponseEnvelope struct {
	Errors   []SettingListResponseEnvelopeErrors   `json:"errors,required"`
	Messages []SettingListResponseEnvelopeMessages `json:"messages,required"`
	// Settings available for the zone.
	Result ZonesSettings `json:"result,required"`
	// Whether the API call was successful
	Success SettingListResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingListResponseEnvelopeJSON    `json:"-"`
}

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

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

type SettingListResponseEnvelopeSuccess bool

type SettingService struct {
	Options []option.RequestOption
}

type ZonesPageRule 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 []ZonesPageRuleAction `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 ZonesPageRuleStatus `json:"status,required"`
	// The rule targets to evaluate on each request.
	Targets []ZonesPageRuleTarget `json:"targets,required"`
	JSON    zonesPageRuleJSON     `json:"-"`
}

type ZonesPageRuleAction struct {
	// The timestamp of when the override was last modified.
	ModifiedOn time.Time `json:"modified_on" format:"date-time"`
	// The type of route.
	Name  ZonesPageRuleActionsName  `json:"name"`
	Value ZonesPageRuleActionsValue `json:"value"`
	JSON  zonesPageRuleActionJSON   `json:"-"`
}

type ZonesPageRuleActionsName string

type ZonesPageRuleActionsValue struct {
	// The response type for the URL redirect.
	Type ZonesPageRuleActionsValueType `json:"type"`
	// The URL to redirect the request to. Notes: ${num} refers to the position of '\*'
	// in the constraint value.
	URL  string                        `json:"url"`
	JSON zonesPageRuleActionsValueJSON `json:"-"`
}

type ZonesPageRuleActionsValueType string

type ZonesPageRuleStatus string

type ZonesPageRuleTarget struct {
	// String constraint.
	Constraint ZonesPageRuleTargetsConstraint `json:"constraint,required"`
	// A target based on the URL of the request.
	Target ZonesPageRuleTargetsTarget `json:"target,required"`
	JSON   zonesPageRuleTargetJSON    `json:"-"`
}

type ZonesPageRuleTargetsConstraint struct {
	// The matches operator can use asterisks and pipes as wildcard and 'or' operators.
	Operator ZonesPageRuleTargetsConstraintOperator `json:"operator,required"`
	// The URL pattern to match against the current request. The pattern may contain up
	// to four asterisks ('\*') as placeholders.
	Value string                             `json:"value,required"`
	JSON  zonesPageRuleTargetsConstraintJSON `json:"-"`
}

type ZonesPageRuleTargetsConstraintOperator string

type ZonesPageRuleTargetsTarget string

type ZonesSettings []interface{}