KubernetesGateway_v1           = config.GroupVersionKind{Group: "gateway.networking.k8s.io", Version: "v1", Kind: "Gateway"}
	Lease                          = config.GroupVersionKind{Group: "coordination.k8s.io", Version: "v1", Kind: "Lease"}
	MeshConfig                     = config.GroupVersionKind{Group: "", Version: "v1alpha1", Kind: "MeshConfig"}

	}
	cli, err := clientv3.New(cfg.Config)
	if err != nil {
		return nil, err
	}
	cli.KV = namespace.NewKV(cli.KV, cfg.PathPrefix)
	cli.Watcher = namespace.NewWatcher(cli.Watcher, cfg.PathPrefix)
	cli.Lease = namespace.NewLease(cli.Lease, cfg.PathPrefix)
	return cli, nil
}

func parseEndpoints(endpoints string) ([]string, bool, error) {
	etcdEndpoints := strings.Split(endpoints, config.ValueSeparator)

	var etcdSecure bool

		return gvk.Ingress, true
	case *k8sioapinetworkingv1.IngressClass:
		return gvk.IngressClass, true
	case *sigsk8siogatewayapiapisv1beta1.Gateway:
		return gvk.KubernetesGateway, true
	case *k8sioapicoordinationv1.Lease:
		return gvk.Lease, true
	case *istioioapimeshv1alpha1.MeshConfig:
		return gvk.MeshConfig, true
	case *istioioapimeshv1alpha1.MeshNetworks:
		return gvk.MeshNetworks, true

    /**
     * Releases any project state locks or task execution locks currently held by this thread, allowing the current
     * thread to run as if it were executing an isolated task.
     *
     * Does not release worker lease.
     */
    void runAsIsolatedTask();

    /**
     * Returns {@code true} when this registry grants multiple threads access to projects (but no more than one thread per given project)

                        stats.startWaitingForNextItem();
                        // Release worker lease while waiting
                        workerLease.unlock();
                        return RETRY;
                    }

                    // Have a worker lease and work may be available

                    WorkSource.Selection<WorkItem> workItem;
                    try {

// It is controlled by "k8s:prerelease-lifecycle-gen:introduced" tags in types.go.
func (in *Lease) APILifecycleIntroduced() (major, minor int) {
	return 1, 14
}

      operator: DoesNotExist
    - key: istio.io/rev
      operator: DoesNotExist
    - key: "kubernetes.io/metadata.name"
      operator: "NotIn"
      values: ["kube-system","kube-public","kube-node-lease","local-path-storage"]
  objectSelector:
    matchExpressions:
    - key: sidecar.istio.io/inject
      operator: DoesNotExist
    - key: istio.io/rev
      operator: DoesNotExist

	status                   *v1.NodeStatus
	lease                    *coordv1.Lease
}

func (n *nodeHealthData) deepCopy() *nodeHealthData {
	if n == nil {
		return nil
	}
	return &nodeHealthData{
		probeTimestamp:           n.probeTimestamp,
		readyTransitionTimestamp: n.readyTransitionTimestamp,
		status:                   n.status.DeepCopy(),
		lease:                    n.lease.DeepCopy(),
	}
}

	}

	// the request must come from a node with the same name as the lease
	if a.GetOperation() == admission.Create {
		// a.GetName() won't return the name on create, so we drill down to the proposed object
		lease, ok := a.GetObject().(*coordapi.Lease)
		if !ok {
			return admission.NewForbidden(a, fmt.Errorf("unexpected type %T", a.GetObject()))
		}
		if lease.Name != nodeName {

		ClusterScoped: false,
		Synthetic:     false,
		Builtin:       false,
		ValidateProto: validation.EmptyValidate,
	}.MustBuild()

	Lease = resource.Builder{
		Identifier:    "Lease",
		Group:         "coordination.k8s.io",
		Kind:          "Lease",
		Plural:        "leases",
		Version:       "v1",
		Proto:         "k8s.io.api.coordination.v1.LeaseSpec",