schema_validation

type ASN = shared.ASN

type ASNParam = shared.ASNParam

type AuditLog = shared.AuditLog

type AuditLogAction = shared.AuditLogAction

type AuditLogActor = shared.AuditLogActor

type AuditLogActorType = shared.AuditLogActorType

type AuditLogOwner = shared.AuditLogOwner

type AuditLogResource = shared.AuditLogResource

type CertificateCA = shared.CertificateCA

type CertificateRequestType = shared.CertificateRequestType

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConfigSrc = shared.CloudflareTunnelConfigSrc

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelStatus = shared.CloudflareTunnelStatus

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type Error = apierror.Error

type ErrorData = shared.ErrorData

type ErrorDataSource = shared.ErrorDataSource

type Member = shared.Member

type MemberPoliciesAccess = shared.MemberPoliciesAccess

type MemberPoliciesPermissionGroup = shared.MemberPoliciesPermissionGroup

type MemberPoliciesPermissionGroupsMeta = shared.MemberPoliciesPermissionGroupsMeta

type MemberPoliciesResourceGroup = shared.MemberPoliciesResourceGroup

type MemberPoliciesResourceGroupsMeta = shared.MemberPoliciesResourceGroupsMeta

type MemberPoliciesResourceGroupsScope = shared.MemberPoliciesResourceGroupsScope

type MemberPoliciesResourceGroupsScopeObject = shared.MemberPoliciesResourceGroupsScopeObject

type MemberPolicy = shared.MemberPolicy

type MemberStatus = shared.MemberStatus

type MemberUser = shared.MemberUser

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type PublicSchema struct {
	CreatedAt time.Time `json:"created_at,required" format:"date-time"`
	// The kind of the schema
	Kind PublicSchemaKind `json:"kind,required"`
	// A human-readable name for the schema
	Name string `json:"name,required"`
	// A unique identifier of this schema
	SchemaID string `json:"schema_id,required" format:"uuid"`
	// The raw schema, e.g., the OpenAPI schema, either as JSON or YAML
	Source string `json:"source,required"`
	// An indicator if this schema is enabled
	ValidationEnabled bool             `json:"validation_enabled"`
	JSON              publicSchemaJSON `json:"-"`
}

type PublicSchemaKind string

type RatePlan = shared.RatePlan

type RatePlanID = shared.RatePlanID

type RatePlanParam = shared.RatePlanParam

type ResponseInfo = shared.ResponseInfo

type ResponseInfoSource = shared.ResponseInfoSource

type Role = shared.Role

type RoleParam = shared.RoleParam

type RolePermissions = shared.RolePermissions

type RolePermissionsParam = shared.RolePermissionsParam

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

type SchemaDeleteResponse struct {
	// The ID of the schema that was just deleted
	ID   string                   `json:"id,required" format:"uuid"`
	JSON schemaDeleteResponseJSON `json:"-"`
}

type SchemaDeleteResponseEnvelope struct {
	Errors   api_gateway.Message  `json:"errors,required"`
	Messages api_gateway.Message  `json:"messages,required"`
	Result   SchemaDeleteResponse `json:"result,required"`
	// Whether the API call was successful.
	Success SchemaDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    schemaDeleteResponseEnvelopeJSON    `json:"-"`
}

type SchemaDeleteResponseEnvelopeSuccess bool

type SchemaEditParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Flag whether schema is enabled for validation.
	ValidationEnabled param.Field[bool] `json:"validation_enabled"`
}

type SchemaEditResponseEnvelope struct {
	Errors   api_gateway.Message `json:"errors,required"`
	Messages api_gateway.Message `json:"messages,required"`
	// A schema used in schema validation
	Result PublicSchema `json:"result,required"`
	// Whether the API call was successful.
	Success SchemaEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    schemaEditResponseEnvelopeJSON    `json:"-"`
}

type SchemaEditResponseEnvelopeSuccess bool

type SchemaGetParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Omit the source-files of schemas and only retrieve their meta-data.
	OmitSource param.Field[bool] `query:"omit_source"`
}

type SchemaGetResponseEnvelope struct {
	Errors   api_gateway.Message `json:"errors,required"`
	Messages api_gateway.Message `json:"messages,required"`
	// A schema used in schema validation
	Result PublicSchema `json:"result,required"`
	// Whether the API call was successful.
	Success SchemaGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    schemaGetResponseEnvelopeJSON    `json:"-"`
}

type SchemaGetResponseEnvelopeSuccess bool

type SchemaListParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Omit the source-files of schemas and only retrieve their meta-data.
	OmitSource param.Field[bool] `query:"omit_source"`
	// Page number of paginated results.
	Page param.Field[int64] `query:"page"`
	// Maximum number of results per page.
	PerPage param.Field[int64] `query:"per_page"`
	// Filter for enabled schemas
	ValidationEnabled param.Field[bool] `query:"validation_enabled"`
}

type SchemaNewParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The kind of the schema
	Kind param.Field[SchemaNewParamsKind] `json:"kind,required"`
	// A human-readable name for the schema
	Name param.Field[string] `json:"name,required"`
	// The raw schema, e.g., the OpenAPI schema, either as JSON or YAML
	Source param.Field[string] `json:"source,required"`
	// An indicator if this schema is enabled
	ValidationEnabled param.Field[bool] `json:"validation_enabled,required"`
}

type SchemaNewParamsKind string

type SchemaNewResponseEnvelope struct {
	Errors   []SchemaNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []SchemaNewResponseEnvelopeMessages `json:"messages,required"`
	// A schema used in schema validation
	Result PublicSchema `json:"result,required"`
	// Whether the API call was successful.
	Success SchemaNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    schemaNewResponseEnvelopeJSON    `json:"-"`
}

type SchemaNewResponseEnvelopeErrors struct {
	// A unique error code that describes the kind of issue with the schema
	Code int64 `json:"code,required"`
	// A short text explaining the issue with the schema
	Message          string                                `json:"message,required"`
	DocumentationURL string                                `json:"documentation_url"`
	Source           SchemaNewResponseEnvelopeErrorsSource `json:"source"`
	JSON             schemaNewResponseEnvelopeErrorsJSON   `json:"-"`
}

type SchemaNewResponseEnvelopeErrorsSource struct {
	// A list of JSON path expression(s) that describe the location(s) of the issue
	// within the provided resource. See
	// [https://goessner.net/articles/JsonPath/](https://goessner.net/articles/JsonPath/)
	// for JSONPath specification.
	Locations []string                                  `json:"locations"`
	Pointer   string                                    `json:"pointer"`
	JSON      schemaNewResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type SchemaNewResponseEnvelopeMessages struct {
	// A unique error code that describes the kind of issue with the schema
	Code int64 `json:"code,required"`
	// A short text explaining the issue with the schema
	Message          string                                  `json:"message,required"`
	DocumentationURL string                                  `json:"documentation_url"`
	Source           SchemaNewResponseEnvelopeMessagesSource `json:"source"`
	JSON             schemaNewResponseEnvelopeMessagesJSON   `json:"-"`
}

type SchemaNewResponseEnvelopeMessagesSource struct {
	// A list of JSON path expression(s) that describe the location(s) of the issue
	// within the provided resource. See
	// [https://goessner.net/articles/JsonPath/](https://goessner.net/articles/JsonPath/)
	// for JSONPath specification.
	Locations []string                                    `json:"locations"`
	Pointer   string                                      `json:"pointer"`
	JSON      schemaNewResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type SchemaNewResponseEnvelopeSuccess bool

type SchemaService struct {
	Options []option.RequestOption
}

type SchemaValidationService struct {
	Options  []option.RequestOption
	Schemas  *SchemaService
	Settings *SettingService
}

type SettingEditParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The default mitigation action used Mitigation actions are as follows:
	//
	// - `"log"` - log request when request does not conform to schema
	// - `"block"` - deny access to the site when request does not conform to schema
	// - `"none"` - skip running schema validation
	ValidationDefaultMitigationAction param.Field[SettingEditParamsValidationDefaultMitigationAction] `json:"validation_default_mitigation_action"`
	// When set, this overrides both zone level and operation level mitigation actions.
	//
	// - `"none"` - skip running schema validation entirely for the request
	// - `null` - clears any existing override
	ValidationOverrideMitigationAction param.Field[SettingEditParamsValidationOverrideMitigationAction] `json:"validation_override_mitigation_action"`
}

type SettingEditParamsValidationDefaultMitigationAction string

type SettingEditParamsValidationOverrideMitigationAction string

type SettingEditResponse struct {
	// The default mitigation action used
	//
	// Mitigation actions are as follows:
	//
	// - `log` - log request when request does not conform to schema
	// - `block` - deny access to the site when request does not conform to schema
	// - `none` - skip running schema validation
	ValidationDefaultMitigationAction SettingEditResponseValidationDefaultMitigationAction `json:"validation_default_mitigation_action,required"`
	// When not null, this overrides global both zone level and operation level
	// mitigation actions. This can serve as a quick way to disable schema validation
	// for the whole zone.
	//
	// - `"none"` will skip running schema validation entirely for the request
	ValidationOverrideMitigationAction SettingEditResponseValidationOverrideMitigationAction `json:"validation_override_mitigation_action"`
	JSON                               settingEditResponseJSON                               `json:"-"`
}

type SettingEditResponseEnvelope struct {
	Errors   api_gateway.Message `json:"errors,required"`
	Messages api_gateway.Message `json:"messages,required"`
	Result   SettingEditResponse `json:"result,required"`
	// Whether the API call was successful.
	Success SettingEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingEditResponseEnvelopeJSON    `json:"-"`
}

type SettingEditResponseEnvelopeSuccess bool

type SettingEditResponseValidationDefaultMitigationAction string

type SettingEditResponseValidationOverrideMitigationAction string

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

type SettingGetResponse struct {
	// The default mitigation action used
	//
	// Mitigation actions are as follows:
	//
	// - `log` - log request when request does not conform to schema
	// - `block` - deny access to the site when request does not conform to schema
	// - `none` - skip running schema validation
	ValidationDefaultMitigationAction SettingGetResponseValidationDefaultMitigationAction `json:"validation_default_mitigation_action,required"`
	// When not null, this overrides global both zone level and operation level
	// mitigation actions. This can serve as a quick way to disable schema validation
	// for the whole zone.
	//
	// - `"none"` will skip running schema validation entirely for the request
	ValidationOverrideMitigationAction SettingGetResponseValidationOverrideMitigationAction `json:"validation_override_mitigation_action"`
	JSON                               settingGetResponseJSON                               `json:"-"`
}

type SettingGetResponseEnvelope struct {
	Errors   api_gateway.Message `json:"errors,required"`
	Messages api_gateway.Message `json:"messages,required"`
	Result   SettingGetResponse  `json:"result,required"`
	// Whether the API call was successful.
	Success SettingGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingGetResponseEnvelopeJSON    `json:"-"`
}

type SettingGetResponseEnvelopeSuccess bool

type SettingGetResponseValidationDefaultMitigationAction string

type SettingGetResponseValidationOverrideMitigationAction string

type SettingOperationBulkEditParams struct {
	// Identifier.
	ZoneID param.Field[string]                           `path:"zone_id,required"`
	Body   map[string]SettingOperationBulkEditParamsBody `json:"body,required"`
}

type SettingOperationBulkEditParamsBody struct {
	// Mitigation actions are as follows:
	//
	//   - `log` - log request when request does not conform to schema _ `block` - deny
	//     access to the site when request does not conform to schema _ `none` - skip
	//     running schema validation \* null - clears any existing per-operation setting
	MitigationAction param.Field[SettingOperationBulkEditParamsBodyMitigationAction] `json:"mitigation_action"`
}

type SettingOperationBulkEditParamsBodyMitigationAction string

type SettingOperationBulkEditResponse map[string]SettingOperationBulkEditResponseItem

type SettingOperationBulkEditResponseEnvelope struct {
	Errors   api_gateway.Message `json:"errors,required"`
	Messages api_gateway.Message `json:"messages,required"`
	// Operation ID to per operation setting mapping
	Result SettingOperationBulkEditResponse `json:"result,required"`
	// Whether the API call was successful.
	Success SettingOperationBulkEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingOperationBulkEditResponseEnvelopeJSON    `json:"-"`
}

type SettingOperationBulkEditResponseEnvelopeSuccess bool

type SettingOperationBulkEditResponseItem struct {
	// When set, this applies a mitigation action to this operation which supersedes a
	// global schema validation setting just for this operation
	//
	//   - `"log"` - log request when request does not conform to schema for this
	//     operation
	//   - `"block"` - deny access to the site when request does not conform to schema
	//     for this operation
	//   - `"none"` - will skip mitigation for this operation
	MitigationAction SettingOperationBulkEditResponseItemMitigationAction `json:"mitigation_action,required"`
	// UUID.
	OperationID string                                   `json:"operation_id,required"`
	JSON        settingOperationBulkEditResponseItemJSON `json:"-"`
}

type SettingOperationBulkEditResponseItemMitigationAction string

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

type SettingOperationDeleteResponse struct {
	// UUID.
	OperationID string                             `json:"operation_id"`
	JSON        settingOperationDeleteResponseJSON `json:"-"`
}

type SettingOperationDeleteResponseEnvelope struct {
	Errors   api_gateway.Message            `json:"errors,required"`
	Messages api_gateway.Message            `json:"messages,required"`
	Result   SettingOperationDeleteResponse `json:"result,required"`
	// Whether the API call was successful.
	Success SettingOperationDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingOperationDeleteResponseEnvelopeJSON    `json:"-"`
}

type SettingOperationDeleteResponseEnvelopeSuccess bool

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

type SettingOperationGetResponse struct {
	// When set, this applies a mitigation action to this operation which supersedes a
	// global schema validation setting just for this operation
	//
	//   - `"log"` - log request when request does not conform to schema for this
	//     operation
	//   - `"block"` - deny access to the site when request does not conform to schema
	//     for this operation
	//   - `"none"` - will skip mitigation for this operation
	MitigationAction SettingOperationGetResponseMitigationAction `json:"mitigation_action,required"`
	// UUID.
	OperationID string                          `json:"operation_id,required"`
	JSON        settingOperationGetResponseJSON `json:"-"`
}

type SettingOperationGetResponseEnvelope struct {
	Errors   api_gateway.Message         `json:"errors,required"`
	Messages api_gateway.Message         `json:"messages,required"`
	Result   SettingOperationGetResponse `json:"result,required"`
	// Whether the API call was successful.
	Success SettingOperationGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingOperationGetResponseEnvelopeJSON    `json:"-"`
}

type SettingOperationGetResponseEnvelopeSuccess bool

type SettingOperationGetResponseMitigationAction string

type SettingOperationListParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Page number of paginated results.
	Page param.Field[int64] `query:"page"`
	// Maximum number of results per page.
	PerPage param.Field[int64] `query:"per_page"`
}

type SettingOperationListResponse struct {
	// When set, this applies a mitigation action to this operation which supersedes a
	// global schema validation setting just for this operation
	//
	//   - `"log"` - log request when request does not conform to schema for this
	//     operation
	//   - `"block"` - deny access to the site when request does not conform to schema
	//     for this operation
	//   - `"none"` - will skip mitigation for this operation
	MitigationAction SettingOperationListResponseMitigationAction `json:"mitigation_action,required"`
	// UUID.
	OperationID string                           `json:"operation_id,required"`
	JSON        settingOperationListResponseJSON `json:"-"`
}

type SettingOperationListResponseMitigationAction string

type SettingOperationService struct {
	Options []option.RequestOption
}

type SettingOperationUpdateParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// When set, this applies a mitigation action to this operation
	//
	//   - `"log"` - log request when request does not conform to schema for this
	//     operation
	//   - `"block"` - deny access to the site when request does not conform to schema
	//     for this operation
	//   - `"none"` - will skip mitigation for this operation
	//   - `null` - clears any mitigation action
	MitigationAction param.Field[SettingOperationUpdateParamsMitigationAction] `json:"mitigation_action,required"`
}

type SettingOperationUpdateParamsMitigationAction string

type SettingOperationUpdateResponse struct {
	// When set, this applies a mitigation action to this operation which supersedes a
	// global schema validation setting just for this operation
	//
	//   - `"log"` - log request when request does not conform to schema for this
	//     operation
	//   - `"block"` - deny access to the site when request does not conform to schema
	//     for this operation
	//   - `"none"` - will skip mitigation for this operation
	MitigationAction SettingOperationUpdateResponseMitigationAction `json:"mitigation_action,required"`
	// UUID.
	OperationID string                             `json:"operation_id,required"`
	JSON        settingOperationUpdateResponseJSON `json:"-"`
}

type SettingOperationUpdateResponseEnvelope struct {
	Errors   api_gateway.Message            `json:"errors,required"`
	Messages api_gateway.Message            `json:"messages,required"`
	Result   SettingOperationUpdateResponse `json:"result,required"`
	// Whether the API call was successful.
	Success SettingOperationUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingOperationUpdateResponseEnvelopeJSON    `json:"-"`
}

type SettingOperationUpdateResponseEnvelopeSuccess bool

type SettingOperationUpdateResponseMitigationAction string

type SettingService struct {
	Options    []option.RequestOption
	Operations *SettingOperationService
}

type SettingUpdateParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The default mitigation action used Mitigation actions are as follows:
	//
	// - `"log"` - log request when request does not conform to schema
	// - `"block"` - deny access to the site when request does not conform to schema
	// - `"none"` - skip running schema validation
	ValidationDefaultMitigationAction param.Field[SettingUpdateParamsValidationDefaultMitigationAction] `json:"validation_default_mitigation_action,required"`
	// When set, this overrides both zone level and operation level mitigation actions.
	//
	// - `"none"` - skip running schema validation entirely for the request
	// - `null` - clears any existing override
	ValidationOverrideMitigationAction param.Field[SettingUpdateParamsValidationOverrideMitigationAction] `json:"validation_override_mitigation_action"`
}

type SettingUpdateParamsValidationDefaultMitigationAction string

type SettingUpdateParamsValidationOverrideMitigationAction string

type SettingUpdateResponse struct {
	// The default mitigation action used
	//
	// Mitigation actions are as follows:
	//
	// - `log` - log request when request does not conform to schema
	// - `block` - deny access to the site when request does not conform to schema
	// - `none` - skip running schema validation
	ValidationDefaultMitigationAction SettingUpdateResponseValidationDefaultMitigationAction `json:"validation_default_mitigation_action,required"`
	// When not null, this overrides global both zone level and operation level
	// mitigation actions. This can serve as a quick way to disable schema validation
	// for the whole zone.
	//
	// - `"none"` will skip running schema validation entirely for the request
	ValidationOverrideMitigationAction SettingUpdateResponseValidationOverrideMitigationAction `json:"validation_override_mitigation_action"`
	JSON                               settingUpdateResponseJSON                               `json:"-"`
}

type SettingUpdateResponseEnvelope struct {
	Errors   api_gateway.Message   `json:"errors,required"`
	Messages api_gateway.Message   `json:"messages,required"`
	Result   SettingUpdateResponse `json:"result,required"`
	// Whether the API call was successful.
	Success SettingUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    settingUpdateResponseEnvelopeJSON    `json:"-"`
}

type SettingUpdateResponseEnvelopeSuccess bool

type SettingUpdateResponseValidationDefaultMitigationAction string

type SettingUpdateResponseValidationOverrideMitigationAction string

type SortDirection = shared.SortDirection

type Subscription = shared.Subscription

type SubscriptionFrequency = shared.SubscriptionFrequency

type SubscriptionParam = shared.SubscriptionParam

type SubscriptionState = shared.SubscriptionState

type Token = shared.Token

type TokenCondition = shared.TokenCondition

type TokenConditionCIDRList = shared.TokenConditionCIDRList

type TokenConditionCIDRListParam = shared.TokenConditionCIDRListParam

type TokenConditionParam = shared.TokenConditionParam

type TokenConditionRequestIP = shared.TokenConditionRequestIP

type TokenConditionRequestIPParam = shared.TokenConditionRequestIPParam

type TokenParam = shared.TokenParam

type TokenPolicy = shared.TokenPolicy

type TokenPolicyEffect = shared.TokenPolicyEffect

type TokenPolicyParam = shared.TokenPolicyParam

type TokenPolicyPermissionGroup = shared.TokenPolicyPermissionGroup

type TokenPolicyPermissionGroupParam = shared.TokenPolicyPermissionGroupParam

type TokenPolicyPermissionGroupsMeta = shared.TokenPolicyPermissionGroupsMeta

type TokenPolicyPermissionGroupsMetaParam = shared.TokenPolicyPermissionGroupsMetaParam

type TokenPolicyResourcesIAMResourcesTypeObjectNested = shared.TokenPolicyResourcesIAMResourcesTypeObjectNested

type TokenPolicyResourcesIAMResourcesTypeObjectNestedParam = shared.TokenPolicyResourcesIAMResourcesTypeObjectNestedParam

type TokenPolicyResourcesIAMResourcesTypeObjectString = shared.TokenPolicyResourcesIAMResourcesTypeObjectString

type TokenPolicyResourcesIAMResourcesTypeObjectStringParam = shared.TokenPolicyResourcesIAMResourcesTypeObjectStringParam

type TokenPolicyResourcesUnion = shared.TokenPolicyResourcesUnion

type TokenPolicyResourcesUnionParam = shared.TokenPolicyResourcesUnionParam

type TokenStatus = shared.TokenStatus

type TokenValue = shared.TokenValue