// permissive environment available.
	//
	// StoredExpressions is appropriate for use with CEL expressions in
	// configuration files.
	StoredExpressions Type = "StoredExpressions"
)

// EnvSet manages the creation and extension of CEL environments. Each EnvSet contains
// both an NewExpressions and StoredExpressions environment. EnvSets are created

			typeVersionCombinations: []envTypeAndVersion{
				{version.MajorMinor(1, 28), NewExpressions},
				{version.MajorMinor(1, 26), StoredExpressions},
				{version.MajorMinor(1, 27), StoredExpressions},
				{version.MajorMinor(1, 28), StoredExpressions},
			},
			validExpressions: []string{"test() == false", "testV1() == true"},
			opts: []VersionedOptions{
				{

		},
		{
			name: "compile with storage environment should recognize functions available only in the storage environment",
			expressions: []string{
				"test() == true",
			},
			envType: environment.StoredExpressions,
		},
		{
			name: "compile with supported environment should not recognize functions available only in the storage environment",
			errorExpressions: map[string]string{

			expressions,
			cel.OptionalVariableDeclarations{
				HasParams:     false,
				HasAuthorizer: true,
				StrictCost:    strictCost,
			},
			environment.StoredExpressions,
		), m.FailurePolicy, "webhook", "admit", m.Name)
	})
	return m.compiledMatcher
}

func (m *mutatingWebhookAccessor) GetParsedNamespaceSelector() (labels.Selector, error) {

}

// EnvLoader delegates the decision of which CEL environment to use for each expression.
// Callers should return the appropriate CEL environment based on the guidelines from
// environment.NewExpressions and environment.StoredExpressions.
type EnvLoader interface {
	// RuleEnv returns the appropriate environment from the EnvSet for the given CEL rule.
	RuleEnv(envSet *environment.EnvSet, expression string) *cel.Env

		}
		compiler.CompileAndStoreVariables(convertv1beta1Variables(ctx.variables), options, environment.StoredExpressions)
		result := compiler.CompileCELExpression(celExpression(expression), options, environment.StoredExpressions)
		if err := result.Error; err != nil {
			typeCheckingResult := &TypeCheckingResult{GVK: gvk}
			if err.Type == apiservercel.ErrorTypeInvalid {

		t.Run(name, func(t *testing.T) {
			// At the moment, there's no difference between stored and new expressions.
			// This uses the stricter validation.
			opts := Options{
				StoredExpressions: false,
			}
			errs := validateSelector(opts, scenario.selector, nil)
			assert.Equal(t, scenario.wantFailures, errs)
		})
	}

	entries := sets.New[string]()
	if model.NamedResources != nil {
		entries.Insert("namedResources")
		allErrs = append(allErrs, namedresourcesvalidation.ValidateRequest(namedresourcesvalidation.Options{StoredExpressions: requestStored}, model.NamedResources, fldPath.Child("namedResources"))...)
	}
	switch len(entries) {
	case 0:
		allErrs = append(allErrs, field.Required(fldPath, "exactly one structured model field must be set"))

	f := fc.Compile([]cel.ExpressionAccessor{&ValidationCondition{Expression: "[1,2,3,4,5,6,7,8,9,10].map(x, [1,2,3,4,5,6,7,8,9,10].map(y, x*y)) == []"}}, cel.OptionalVariableDeclarations{HasParams: false, HasAuthorizer: false}, environment.StoredExpressions)
	v := validator{
		failPolicy:       &fail,
		celMatcher:       &fakeCELMatcher{matches: true},
		validationFilter: f,
		messageFilter:    f,
		auditAnnotationFilter: &fakeCelFilter{
			evaluations: nil,