"foo": *spec.Int64Property(),
					},
				},
			},
			assertions: []assertionFunc{
				toHaveFieldRef("spec.validations[0].expression"),
				toContain(`found no matching overload`),
			},
		},
		{
			name:   "params",
			policy: paramsRefPolicy,
			schemaToReturn: &spec.Schema{
				SchemaProps: spec.SchemaProps{
					Type: []string{"object"},

import org.jetbrains.kotlin.analysis.api.lifetime.validityAsserted
import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion

/**
 * A candidate considered for a call. I.e., one of the overload candidates in scope at the call site.
 */
public sealed class KaCallCandidateInfo(
    candidate: KaCall,
    isInBestCandidates: Boolean,
) : KaLifetimeOwner {
    private val backingCandidate: KaCall = candidate

	// calculations to if the size is not well known (i.e. a constant).
	SizeEstimator checker.CostEstimator
}

func (l *CostEstimator) CallCost(function, overloadId string, args []ref.Val, result ref.Val) *uint64 {
	switch function {
	case "check":
		// An authorization check has a fixed cost
		// This cost is set to allow for only two authorization checks per expression

	}
	if err != nil {
		return err
	}
	return nil
}

// OverlayTrees performs a sequential JSON strategic of overlays over base.
func OverlayTrees(base map[string]any, overlays ...map[string]any) (map[string]any, error) {
	needsOverlay := false
	for _, o := range overlays {
		if len(o) > 0 {
			needsOverlay = true
			break
		}
	}
	if !needsOverlay {
		// Avoid expensive overlay if possible

}

// Equal implements ref.Val.Equal.
func (d CIDR) Equal(other ref.Val) ref.Val {
	otherD, ok := other.(CIDR)
	if !ok {
		return types.ValOrErr(other, "no such overload")
	}

	return types.Bool(d.Prefix == otherD.Prefix)
}

// Type implements ref.Val.Type.
func (d CIDR) Type() ref.Type {
	return CIDRType
}

// Value implements ref.Val.Value.

				"self.unsetPlainStr == null":     "no matching overload for '_==_' applied to '(string, null)",
				"self.unsetDefaultedStr != null": "no matching overload for '_!=_' applied to '(string, null)",
				"self.unsetNullableStr == null":  "no matching overload for '_==_' applied to '(string, null)",
				"self.setPlainStr != null":       "no matching overload for '_!=_' applied to '(string, null)",

        MethodDoc method2 = methodDoc('methodName', id: 'method2Id', returnType: 'ReturnType2', description: 'overloaded description', comment: 'overloaded comment', paramTypes: ['ParamType'])
        _ * classDoc.classProperties >> []
        _ * classDoc.classMethods >> [method1, method2]
        _ * classDoc.classBlocks >> []

    // TODO Remove once the third-party usage is considered obsolete.
    /**
     * @deprecated Use the overload accepting the TaskDependencyFactory
     */
    @Deprecated
    @SuppressWarnings("InlineMeSuggester")
    public LazilyInitializedFileCollection() {
        this(DefaultTaskDependencyFactory.withNoAssociatedProject());

   * in a {@code RuntimeException}. <b>Note:</b> Be sure to declare all of the checked exception
   * types your try block can throw when calling an overload of this method so as to avoid losing
   * the original exception type.
   *
   * <p>This method always throws, and as such should be called as {@code throw closer.rethrow(e);}

	if cfg == nil {
		return
	}

	cfg.ControlPlaneValues = `
components:
  egressGateways:
  - enabled: true
    name: istio-egressgateway
    k8s:
      overlays:
        - kind: Deployment
          name: istio-egressgateway
          patches:
            - path: spec.template.spec.volumes[100]
              value: |-
                name: server-certs