return
}

func setupDiGetDeviceInstanceId(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, instanceId *uint16, instanceIdSize uint32, instanceIdRequiredSize *uint32) (err error) {
	r1, _, e1 := syscall.Syscall6(procSetupDiGetDeviceInstanceIdW.Addr(), 5, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(instanceId)), uintptr(instanceIdSize), uintptr(unsafe.Pointer(instanceIdRequiredSize)), 0)
	if r1 == 0 {

	return newOption("nodeID", value)
}

func NodeType(value string) Instance {
	ntype := strings.Split(value, "~")[0]
	return newOption("nodeType", ntype)
}

func XdsType(value string) Instance {
	return newOption("xds_type", value)
}

func Region(value string) Instance {
	return newOptionOrSkipIfZero("region", value)
}

func Zone(value string) Instance {

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
releaseNotes:
- |

	apply(map[string]any) error
}

var _ Instance = &instance{}

type (
	convertFunc func(*instance) (any, error)
	applyFunc   func(map[string]any, *instance) error
)

type instance struct {
	name      Name
	convertFn convertFunc
	applyFn   applyFunc
}

func (i *instance) Name() Name {
	return i.name
}

func (i *instance) withConvert(fn convertFunc) *instance {
	out := *i
	out.convertFn = fn

package resource

import (
	"istio.io/istio/pkg/config"
)

// Instance is the abstract representation of a versioned config resource in Istio.
type Instance struct {
	Metadata Metadata
	Message  config.Spec
	Origin   Origin
}

// IsEmpty returns true if the resource Instance.Message is nil.
func (r *Instance) IsEmpty() bool {
	return r.Message == nil
}

type Instance interface {
	io.Closer
	Start(onReady OnReadyFunc) error
	GetConfig() Config
}

// New creates a new endpoint Instance.
func New(cfg Config) (Instance, error) {
	if cfg.Port != nil {
		switch cfg.Port.Protocol {
		case protocol.HBONE:
			return newHBONE(cfg), nil
		case protocol.HTTP, protocol.HTTPS:
			return newHTTP(cfg), nil
		case protocol.HTTP2, protocol.GRPC:
			return newGRPC(cfg), nil

package timeseries

import (
	"sync"
	"time"
)

type Instance struct {
	data  Data
	times times
	mutex sync.Mutex
}

func (ts *Instance) AddObservation(val float64, t time.Time) {
	ts.mutex.Lock()
	defer ts.mutex.Unlock()
	ts.data = append(ts.data, val)
	ts.times = append(ts.times, t)
}

func (ts *Instance) AddAll(o *Instance) {
	ts.mutex.Lock()
	defer ts.mutex.Unlock()

	}

	// Success.
	return &Instance{
		isJSON:    i.isJSON,
		structure: value,
	}
}

func (i *Instance) appendConstraint(fn func() error) *Instance {
	i.constraints = append(i.constraints, fn)
	return i
}

func (i *Instance) Equals(expected any, path string, args ...any) *Instance {
	path = fmt.Sprintf(path, args...)
	return i.appendConstraint(func() error {

	Addresses() []string

	// Restart restarts the workloads associated with this echo instance
	Restart() error

	// UpdateWorkloadLabel update pod labels of this echo instance
	UpdateWorkloadLabel(add map[string]string, remove []string) error

	// WithWorkloads returns a target with only the specified subset of workloads
	WithWorkloads(wl ...Workload) Instance

	// the server Instance is shutting down, it will wait for the component
	// to complete before exiting.
	// Note: this is best effort; a process can die at any time.
	RunComponentAsyncAndWait(name string, t Component)

	// Wait for this server Instance to shutdown.
	Wait()
}

var _ Instance = &instance{}

// New creates a new server Instance.
func New() Instance {
	return &instance{