func (m *MockedIpsetDeps) ipsetIPHashCreate(name string, v6 bool) error {
	args := m.Called(name, v6)
	return args.Error(0)
}

func (m *MockedIpsetDeps) destroySet(name string) error {
	args := m.Called(name)
	return args.Error(0)
}

func (m *MockedIpsetDeps) addIP(name string, ip netip.Addr, ipProto uint8, comment string, replace bool) error {
	args := m.Called(name, ip, ipProto, comment, replace)
	return args.Error(0)
}

// The linker can prune methods that are not directly called or
// assigned to interfaces, but only if reflect.Type.Method is
// never used. Test it here.

package main

import "reflect"

var called = false

type M int

func (m M) UniqueMethodName() {
	called = true
}

var v M

func main() {
	reflect.TypeOf(v).Method(0).Func.Interface().(func(M))(v)
	if !called {
		panic("UniqueMethodName not called")
	}

// The linker can prune methods that are not directly called or
// assigned to interfaces, but only if reflect.Value.Method is
// never used. Test it here.

package main

import "reflect"

var called = false

type M int

func (m M) UniqueMethodName() {
	called = true
}

var v M

func main() {
	reflect.ValueOf(v).Method(0).Interface().(func())()
	if !called {
		panic("UniqueMethodName not called")
	}

// If called multiple times, the Type field is set to the value of the last call.
func (b *JSONSchemaPropsApplyConfiguration) WithType(value string) *JSONSchemaPropsApplyConfiguration {
	b.Type = &value
	return b
}

// WithFormat sets the Format field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.

	codec ClientCodec

	reqMutex sync.Mutex // protects following
	request  Request

	mutex    sync.Mutex // protects following
	seq      uint64
	pending  map[uint64]*Call
	closing  bool // user has called Close
	shutdown bool // server has told us to stop
}

// A ClientCodec implements writing of RPC requests and
// reading of RPC responses for the client side of an RPC session.

// license that can be found in the LICENSE file.

// The linker can prune methods that are not directly called or
// assigned to interfaces, but only if reflect.Type.MethodByName is
// never used. Test it here.

package main

import reflect1 "reflect"

var called = false

type M int

func (m M) UniqueMethodName() {
	called = true
}

var v M

type MyType interface {
	MethodByName(string) (reflect1.Method, bool)

// license that can be found in the LICENSE file.

// The linker can prune methods that are not directly called or
// assigned to interfaces, but only if reflect.Type.Method is
// never used. Test it here.

package main

import "reflect"

var called = false

type M int

func (m M) UniqueMethodName() {
	called = true
}

var v M

type MyType interface {
	Method(int) reflect.Method
}

}

// WithCapacity sets the Capacity field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Capacity field is set to the value of the last call.
func (b *PersistentVolumeSpecApplyConfiguration) WithCapacity(value v1.ResourceList) *PersistentVolumeSpecApplyConfiguration {
	b.Capacity = &value
	return b

}

// WithName sets the Name field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Name field is set to the value of the last call.
func (b *EphemeralContainerApplyConfiguration) WithName(value string) *EphemeralContainerApplyConfiguration {
	b.Name = &value
	return b
}

     * {@link #files(org.gradle.api.specs.Spec)}.
     *
     * @implSpec Usage: This method should only be called on resolvable configurations and should fail if
     * called on a configuration that does not permit this usage.  It should warn if called on a configuration that has
     * allowed this usage but marked it as deprecated.
     *