api_client_requester.go

// Code generated by mockery. DO NOT EDIT.

package mocks

import (
	context "context"

	client "github.com/borderzero/border0-go/client"

	jwt "github.com/golang-jwt/jwt"

	mock "github.com/stretchr/testify/mock"
)

// APIClientRequester is an autogenerated mock type for the Requester type
type APIClientRequester struct {
	mock.Mock
}

type APIClientRequester_Expecter struct {
	mock *mock.Mock
}

func (_m *APIClientRequester) EXPECT() *APIClientRequester_Expecter {
	return &APIClientRequester_Expecter{mock: &_m.Mock}
}

// AttachPoliciesToSocket provides a mock function with given fields: ctx, policyIDs, socketID
func (_m *APIClientRequester) AttachPoliciesToSocket(ctx context.Context, policyIDs []string, socketID string) error {
	ret := _m.Called(ctx, policyIDs, socketID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []string, string) error); ok {
		r0 = rf(ctx, policyIDs, socketID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// APIClientRequester_AttachPoliciesToSocket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttachPoliciesToSocket'
type APIClientRequester_AttachPoliciesToSocket_Call struct {
	*mock.Call
}

// AttachPoliciesToSocket is a helper method to define mock.On call
//   - ctx context.Context
//   - policyIDs []string
//   - socketID string
func (_e *APIClientRequester_Expecter) AttachPoliciesToSocket(ctx interface{}, policyIDs interface{}, socketID interface{}) *APIClientRequester_AttachPoliciesToSocket_Call {
	return &APIClientRequester_AttachPoliciesToSocket_Call{Call: _e.mock.On("AttachPoliciesToSocket", ctx, policyIDs, socketID)}
}

func (_c *APIClientRequester_AttachPoliciesToSocket_Call) Run(run func(ctx context.Context, policyIDs []string, socketID string)) *APIClientRequester_AttachPoliciesToSocket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]string), args[2].(string))
	})
	return _c
}

func (_c *APIClientRequester_AttachPoliciesToSocket_Call) Return(err error) *APIClientRequester_AttachPoliciesToSocket_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *APIClientRequester_AttachPoliciesToSocket_Call) RunAndReturn(run func(context.Context, []string, string) error) *APIClientRequester_AttachPoliciesToSocket_Call {
	_c.Call.Return(run)
	return _c
}

// AttachPolicyToSocket provides a mock function with given fields: ctx, policyID, socketID
func (_m *APIClientRequester) AttachPolicyToSocket(ctx context.Context, policyID string, socketID string) error {
	ret := _m.Called(ctx, policyID, socketID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = rf(ctx, policyID, socketID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// APIClientRequester_AttachPolicyToSocket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttachPolicyToSocket'
type APIClientRequester_AttachPolicyToSocket_Call struct {
	*mock.Call
}

// AttachPolicyToSocket is a helper method to define mock.On call
//   - ctx context.Context
//   - policyID string
//   - socketID string
func (_e *APIClientRequester_Expecter) AttachPolicyToSocket(ctx interface{}, policyID interface{}, socketID interface{}) *APIClientRequester_AttachPolicyToSocket_Call {
	return &APIClientRequester_AttachPolicyToSocket_Call{Call: _e.mock.On("AttachPolicyToSocket", ctx, policyID, socketID)}
}

func (_c *APIClientRequester_AttachPolicyToSocket_Call) Run(run func(ctx context.Context, policyID string, socketID string)) *APIClientRequester_AttachPolicyToSocket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *APIClientRequester_AttachPolicyToSocket_Call) Return(err error) *APIClientRequester_AttachPolicyToSocket_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *APIClientRequester_AttachPolicyToSocket_Call) RunAndReturn(run func(context.Context, string, string) error) *APIClientRequester_AttachPolicyToSocket_Call {
	_c.Call.Return(run)
	return _c
}

// Connector provides a mock function with given fields: ctx, id
func (_m *APIClientRequester) Connector(ctx context.Context, id string) (*client.Connector, error) {
	ret := _m.Called(ctx, id)

	var r0 *client.Connector
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*client.Connector, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *client.Connector); ok {
		r0 = rf(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Connector)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_Connector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connector'
type APIClientRequester_Connector_Call struct {
	*mock.Call
}

// Connector is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *APIClientRequester_Expecter) Connector(ctx interface{}, id interface{}) *APIClientRequester_Connector_Call {
	return &APIClientRequester_Connector_Call{Call: _e.mock.On("Connector", ctx, id)}
}

func (_c *APIClientRequester_Connector_Call) Run(run func(ctx context.Context, id string)) *APIClientRequester_Connector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *APIClientRequester_Connector_Call) Return(out *client.Connector, err error) *APIClientRequester_Connector_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_Connector_Call) RunAndReturn(run func(context.Context, string) (*client.Connector, error)) *APIClientRequester_Connector_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectorTokens provides a mock function with given fields: ctx, connectorID
func (_m *APIClientRequester) ConnectorTokens(ctx context.Context, connectorID string) (*client.ConnectorTokens, error) {
	ret := _m.Called(ctx, connectorID)

	var r0 *client.ConnectorTokens
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*client.ConnectorTokens, error)); ok {
		return rf(ctx, connectorID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *client.ConnectorTokens); ok {
		r0 = rf(ctx, connectorID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.ConnectorTokens)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, connectorID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_ConnectorTokens_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectorTokens'
type APIClientRequester_ConnectorTokens_Call struct {
	*mock.Call
}

// ConnectorTokens is a helper method to define mock.On call
//   - ctx context.Context
//   - connectorID string
func (_e *APIClientRequester_Expecter) ConnectorTokens(ctx interface{}, connectorID interface{}) *APIClientRequester_ConnectorTokens_Call {
	return &APIClientRequester_ConnectorTokens_Call{Call: _e.mock.On("ConnectorTokens", ctx, connectorID)}
}

func (_c *APIClientRequester_ConnectorTokens_Call) Run(run func(ctx context.Context, connectorID string)) *APIClientRequester_ConnectorTokens_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *APIClientRequester_ConnectorTokens_Call) Return(out *client.ConnectorTokens, err error) *APIClientRequester_ConnectorTokens_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_ConnectorTokens_Call) RunAndReturn(run func(context.Context, string) (*client.ConnectorTokens, error)) *APIClientRequester_ConnectorTokens_Call {
	_c.Call.Return(run)
	return _c
}

// Connectors provides a mock function with given fields: ctx
func (_m *APIClientRequester) Connectors(ctx context.Context) ([]client.Connector, error) {
	ret := _m.Called(ctx)

	var r0 []client.Connector
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]client.Connector, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []client.Connector); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Connector)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_Connectors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connectors'
type APIClientRequester_Connectors_Call struct {
	*mock.Call
}

// Connectors is a helper method to define mock.On call
//   - ctx context.Context
func (_e *APIClientRequester_Expecter) Connectors(ctx interface{}) *APIClientRequester_Connectors_Call {
	return &APIClientRequester_Connectors_Call{Call: _e.mock.On("Connectors", ctx)}
}

func (_c *APIClientRequester_Connectors_Call) Run(run func(ctx context.Context)) *APIClientRequester_Connectors_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *APIClientRequester_Connectors_Call) Return(out []client.Connector, err error) *APIClientRequester_Connectors_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_Connectors_Call) RunAndReturn(run func(context.Context) ([]client.Connector, error)) *APIClientRequester_Connectors_Call {
	_c.Call.Return(run)
	return _c
}

// CreateConnector provides a mock function with given fields: ctx, in
func (_m *APIClientRequester) CreateConnector(ctx context.Context, in *client.Connector) (*client.Connector, error) {
	ret := _m.Called(ctx, in)

	var r0 *client.Connector
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.Connector) (*client.Connector, error)); ok {
		return rf(ctx, in)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *client.Connector) *client.Connector); ok {
		r0 = rf(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Connector)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *client.Connector) error); ok {
		r1 = rf(ctx, in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_CreateConnector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateConnector'
type APIClientRequester_CreateConnector_Call struct {
	*mock.Call
}

// CreateConnector is a helper method to define mock.On call
//   - ctx context.Context
//   - in *client.Connector
func (_e *APIClientRequester_Expecter) CreateConnector(ctx interface{}, in interface{}) *APIClientRequester_CreateConnector_Call {
	return &APIClientRequester_CreateConnector_Call{Call: _e.mock.On("CreateConnector", ctx, in)}
}

func (_c *APIClientRequester_CreateConnector_Call) Run(run func(ctx context.Context, in *client.Connector)) *APIClientRequester_CreateConnector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.Connector))
	})
	return _c
}

func (_c *APIClientRequester_CreateConnector_Call) Return(out *client.Connector, err error) *APIClientRequester_CreateConnector_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_CreateConnector_Call) RunAndReturn(run func(context.Context, *client.Connector) (*client.Connector, error)) *APIClientRequester_CreateConnector_Call {
	_c.Call.Return(run)
	return _c
}

// CreateConnectorToken provides a mock function with given fields: ctx, in
func (_m *APIClientRequester) CreateConnectorToken(ctx context.Context, in *client.ConnectorToken) (*client.ConnectorToken, error) {
	ret := _m.Called(ctx, in)

	var r0 *client.ConnectorToken
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.ConnectorToken) (*client.ConnectorToken, error)); ok {
		return rf(ctx, in)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *client.ConnectorToken) *client.ConnectorToken); ok {
		r0 = rf(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.ConnectorToken)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *client.ConnectorToken) error); ok {
		r1 = rf(ctx, in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_CreateConnectorToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateConnectorToken'
type APIClientRequester_CreateConnectorToken_Call struct {
	*mock.Call
}

// CreateConnectorToken is a helper method to define mock.On call
//   - ctx context.Context
//   - in *client.ConnectorToken
func (_e *APIClientRequester_Expecter) CreateConnectorToken(ctx interface{}, in interface{}) *APIClientRequester_CreateConnectorToken_Call {
	return &APIClientRequester_CreateConnectorToken_Call{Call: _e.mock.On("CreateConnectorToken", ctx, in)}
}

func (_c *APIClientRequester_CreateConnectorToken_Call) Run(run func(ctx context.Context, in *client.ConnectorToken)) *APIClientRequester_CreateConnectorToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.ConnectorToken))
	})
	return _c
}

func (_c *APIClientRequester_CreateConnectorToken_Call) Return(out *client.ConnectorToken, err error) *APIClientRequester_CreateConnectorToken_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_CreateConnectorToken_Call) RunAndReturn(run func(context.Context, *client.ConnectorToken) (*client.ConnectorToken, error)) *APIClientRequester_CreateConnectorToken_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePolicy provides a mock function with given fields: ctx, in
func (_m *APIClientRequester) CreatePolicy(ctx context.Context, in *client.Policy) (*client.Policy, error) {
	ret := _m.Called(ctx, in)

	var r0 *client.Policy
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.Policy) (*client.Policy, error)); ok {
		return rf(ctx, in)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *client.Policy) *client.Policy); ok {
		r0 = rf(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Policy)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *client.Policy) error); ok {
		r1 = rf(ctx, in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_CreatePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePolicy'
type APIClientRequester_CreatePolicy_Call struct {
	*mock.Call
}

// CreatePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - in *client.Policy
func (_e *APIClientRequester_Expecter) CreatePolicy(ctx interface{}, in interface{}) *APIClientRequester_CreatePolicy_Call {
	return &APIClientRequester_CreatePolicy_Call{Call: _e.mock.On("CreatePolicy", ctx, in)}
}

func (_c *APIClientRequester_CreatePolicy_Call) Run(run func(ctx context.Context, in *client.Policy)) *APIClientRequester_CreatePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.Policy))
	})
	return _c
}

func (_c *APIClientRequester_CreatePolicy_Call) Return(out *client.Policy, err error) *APIClientRequester_CreatePolicy_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_CreatePolicy_Call) RunAndReturn(run func(context.Context, *client.Policy) (*client.Policy, error)) *APIClientRequester_CreatePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSocket provides a mock function with given fields: ctx, in
func (_m *APIClientRequester) CreateSocket(ctx context.Context, in *client.Socket) (*client.Socket, error) {
	ret := _m.Called(ctx, in)

	var r0 *client.Socket
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.Socket) (*client.Socket, error)); ok {
		return rf(ctx, in)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *client.Socket) *client.Socket); ok {
		r0 = rf(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Socket)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *client.Socket) error); ok {
		r1 = rf(ctx, in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_CreateSocket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSocket'
type APIClientRequester_CreateSocket_Call struct {
	*mock.Call
}

// CreateSocket is a helper method to define mock.On call
//   - ctx context.Context
//   - in *client.Socket
func (_e *APIClientRequester_Expecter) CreateSocket(ctx interface{}, in interface{}) *APIClientRequester_CreateSocket_Call {
	return &APIClientRequester_CreateSocket_Call{Call: _e.mock.On("CreateSocket", ctx, in)}
}

func (_c *APIClientRequester_CreateSocket_Call) Run(run func(ctx context.Context, in *client.Socket)) *APIClientRequester_CreateSocket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.Socket))
	})
	return _c
}

func (_c *APIClientRequester_CreateSocket_Call) Return(out *client.Socket, err error) *APIClientRequester_CreateSocket_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_CreateSocket_Call) RunAndReturn(run func(context.Context, *client.Socket) (*client.Socket, error)) *APIClientRequester_CreateSocket_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteConnector provides a mock function with given fields: ctx, id
func (_m *APIClientRequester) DeleteConnector(ctx context.Context, id string) error {
	ret := _m.Called(ctx, id)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// APIClientRequester_DeleteConnector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteConnector'
type APIClientRequester_DeleteConnector_Call struct {
	*mock.Call
}

// DeleteConnector is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *APIClientRequester_Expecter) DeleteConnector(ctx interface{}, id interface{}) *APIClientRequester_DeleteConnector_Call {
	return &APIClientRequester_DeleteConnector_Call{Call: _e.mock.On("DeleteConnector", ctx, id)}
}

func (_c *APIClientRequester_DeleteConnector_Call) Run(run func(ctx context.Context, id string)) *APIClientRequester_DeleteConnector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *APIClientRequester_DeleteConnector_Call) Return(err error) *APIClientRequester_DeleteConnector_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *APIClientRequester_DeleteConnector_Call) RunAndReturn(run func(context.Context, string) error) *APIClientRequester_DeleteConnector_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteConnectorToken provides a mock function with given fields: ctx, connectorID, tokenID
func (_m *APIClientRequester) DeleteConnectorToken(ctx context.Context, connectorID string, tokenID string) error {
	ret := _m.Called(ctx, connectorID, tokenID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = rf(ctx, connectorID, tokenID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// APIClientRequester_DeleteConnectorToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteConnectorToken'
type APIClientRequester_DeleteConnectorToken_Call struct {
	*mock.Call
}

// DeleteConnectorToken is a helper method to define mock.On call
//   - ctx context.Context
//   - connectorID string
//   - tokenID string
func (_e *APIClientRequester_Expecter) DeleteConnectorToken(ctx interface{}, connectorID interface{}, tokenID interface{}) *APIClientRequester_DeleteConnectorToken_Call {
	return &APIClientRequester_DeleteConnectorToken_Call{Call: _e.mock.On("DeleteConnectorToken", ctx, connectorID, tokenID)}
}

func (_c *APIClientRequester_DeleteConnectorToken_Call) Run(run func(ctx context.Context, connectorID string, tokenID string)) *APIClientRequester_DeleteConnectorToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *APIClientRequester_DeleteConnectorToken_Call) Return(err error) *APIClientRequester_DeleteConnectorToken_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *APIClientRequester_DeleteConnectorToken_Call) RunAndReturn(run func(context.Context, string, string) error) *APIClientRequester_DeleteConnectorToken_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePolicy provides a mock function with given fields: ctx, id
func (_m *APIClientRequester) DeletePolicy(ctx context.Context, id string) error {
	ret := _m.Called(ctx, id)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// APIClientRequester_DeletePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePolicy'
type APIClientRequester_DeletePolicy_Call struct {
	*mock.Call
}

// DeletePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *APIClientRequester_Expecter) DeletePolicy(ctx interface{}, id interface{}) *APIClientRequester_DeletePolicy_Call {
	return &APIClientRequester_DeletePolicy_Call{Call: _e.mock.On("DeletePolicy", ctx, id)}
}

func (_c *APIClientRequester_DeletePolicy_Call) Run(run func(ctx context.Context, id string)) *APIClientRequester_DeletePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *APIClientRequester_DeletePolicy_Call) Return(err error) *APIClientRequester_DeletePolicy_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *APIClientRequester_DeletePolicy_Call) RunAndReturn(run func(context.Context, string) error) *APIClientRequester_DeletePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSocket provides a mock function with given fields: ctx, idOrName
func (_m *APIClientRequester) DeleteSocket(ctx context.Context, idOrName string) error {
	ret := _m.Called(ctx, idOrName)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, idOrName)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// APIClientRequester_DeleteSocket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSocket'
type APIClientRequester_DeleteSocket_Call struct {
	*mock.Call
}

// DeleteSocket is a helper method to define mock.On call
//   - ctx context.Context
//   - idOrName string
func (_e *APIClientRequester_Expecter) DeleteSocket(ctx interface{}, idOrName interface{}) *APIClientRequester_DeleteSocket_Call {
	return &APIClientRequester_DeleteSocket_Call{Call: _e.mock.On("DeleteSocket", ctx, idOrName)}
}

func (_c *APIClientRequester_DeleteSocket_Call) Run(run func(ctx context.Context, idOrName string)) *APIClientRequester_DeleteSocket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *APIClientRequester_DeleteSocket_Call) Return(err error) *APIClientRequester_DeleteSocket_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *APIClientRequester_DeleteSocket_Call) RunAndReturn(run func(context.Context, string) error) *APIClientRequester_DeleteSocket_Call {
	_c.Call.Return(run)
	return _c
}

// Policies provides a mock function with given fields: ctx
func (_m *APIClientRequester) Policies(ctx context.Context) ([]client.Policy, error) {
	ret := _m.Called(ctx)

	var r0 []client.Policy
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]client.Policy, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []client.Policy); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Policy)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_Policies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Policies'
type APIClientRequester_Policies_Call struct {
	*mock.Call
}

// Policies is a helper method to define mock.On call
//   - ctx context.Context
func (_e *APIClientRequester_Expecter) Policies(ctx interface{}) *APIClientRequester_Policies_Call {
	return &APIClientRequester_Policies_Call{Call: _e.mock.On("Policies", ctx)}
}

func (_c *APIClientRequester_Policies_Call) Run(run func(ctx context.Context)) *APIClientRequester_Policies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *APIClientRequester_Policies_Call) Return(out []client.Policy, err error) *APIClientRequester_Policies_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_Policies_Call) RunAndReturn(run func(context.Context) ([]client.Policy, error)) *APIClientRequester_Policies_Call {
	_c.Call.Return(run)
	return _c
}

// PoliciesByNames provides a mock function with given fields: ctx, names
func (_m *APIClientRequester) PoliciesByNames(ctx context.Context, names ...string) ([]client.Policy, error) {
	_va := make([]interface{}, len(names))
	for _i := range names {
		_va[_i] = names[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 []client.Policy
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ...string) ([]client.Policy, error)); ok {
		return rf(ctx, names...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ...string) []client.Policy); ok {
		r0 = rf(ctx, names...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Policy)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ...string) error); ok {
		r1 = rf(ctx, names...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_PoliciesByNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PoliciesByNames'
type APIClientRequester_PoliciesByNames_Call struct {
	*mock.Call
}

// PoliciesByNames is a helper method to define mock.On call
//   - ctx context.Context
//   - names ...string
func (_e *APIClientRequester_Expecter) PoliciesByNames(ctx interface{}, names ...interface{}) *APIClientRequester_PoliciesByNames_Call {
	return &APIClientRequester_PoliciesByNames_Call{Call: _e.mock.On("PoliciesByNames",
		append([]interface{}{ctx}, names...)...)}
}

func (_c *APIClientRequester_PoliciesByNames_Call) Run(run func(ctx context.Context, names ...string)) *APIClientRequester_PoliciesByNames_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]string, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

func (_c *APIClientRequester_PoliciesByNames_Call) Return(out []client.Policy, err error) *APIClientRequester_PoliciesByNames_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_PoliciesByNames_Call) RunAndReturn(run func(context.Context, ...string) ([]client.Policy, error)) *APIClientRequester_PoliciesByNames_Call {
	_c.Call.Return(run)
	return _c
}

// Policy provides a mock function with given fields: ctx, id
func (_m *APIClientRequester) Policy(ctx context.Context, id string) (*client.Policy, error) {
	ret := _m.Called(ctx, id)

	var r0 *client.Policy
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*client.Policy, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *client.Policy); ok {
		r0 = rf(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Policy)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_Policy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Policy'
type APIClientRequester_Policy_Call struct {
	*mock.Call
}

// Policy is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *APIClientRequester_Expecter) Policy(ctx interface{}, id interface{}) *APIClientRequester_Policy_Call {
	return &APIClientRequester_Policy_Call{Call: _e.mock.On("Policy", ctx, id)}
}

func (_c *APIClientRequester_Policy_Call) Run(run func(ctx context.Context, id string)) *APIClientRequester_Policy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *APIClientRequester_Policy_Call) Return(out *client.Policy, err error) *APIClientRequester_Policy_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_Policy_Call) RunAndReturn(run func(context.Context, string) (*client.Policy, error)) *APIClientRequester_Policy_Call {
	_c.Call.Return(run)
	return _c
}

// RemovePoliciesFromSocket provides a mock function with given fields: ctx, policyIDs, socketID
func (_m *APIClientRequester) RemovePoliciesFromSocket(ctx context.Context, policyIDs []string, socketID string) error {
	ret := _m.Called(ctx, policyIDs, socketID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []string, string) error); ok {
		r0 = rf(ctx, policyIDs, socketID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// APIClientRequester_RemovePoliciesFromSocket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePoliciesFromSocket'
type APIClientRequester_RemovePoliciesFromSocket_Call struct {
	*mock.Call
}

// RemovePoliciesFromSocket is a helper method to define mock.On call
//   - ctx context.Context
//   - policyIDs []string
//   - socketID string
func (_e *APIClientRequester_Expecter) RemovePoliciesFromSocket(ctx interface{}, policyIDs interface{}, socketID interface{}) *APIClientRequester_RemovePoliciesFromSocket_Call {
	return &APIClientRequester_RemovePoliciesFromSocket_Call{Call: _e.mock.On("RemovePoliciesFromSocket", ctx, policyIDs, socketID)}
}

func (_c *APIClientRequester_RemovePoliciesFromSocket_Call) Run(run func(ctx context.Context, policyIDs []string, socketID string)) *APIClientRequester_RemovePoliciesFromSocket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]string), args[2].(string))
	})
	return _c
}

func (_c *APIClientRequester_RemovePoliciesFromSocket_Call) Return(err error) *APIClientRequester_RemovePoliciesFromSocket_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *APIClientRequester_RemovePoliciesFromSocket_Call) RunAndReturn(run func(context.Context, []string, string) error) *APIClientRequester_RemovePoliciesFromSocket_Call {
	_c.Call.Return(run)
	return _c
}

// RemovePolicyFromSocket provides a mock function with given fields: ctx, policyID, socketID
func (_m *APIClientRequester) RemovePolicyFromSocket(ctx context.Context, policyID string, socketID string) error {
	ret := _m.Called(ctx, policyID, socketID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = rf(ctx, policyID, socketID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// APIClientRequester_RemovePolicyFromSocket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePolicyFromSocket'
type APIClientRequester_RemovePolicyFromSocket_Call struct {
	*mock.Call
}

// RemovePolicyFromSocket is a helper method to define mock.On call
//   - ctx context.Context
//   - policyID string
//   - socketID string
func (_e *APIClientRequester_Expecter) RemovePolicyFromSocket(ctx interface{}, policyID interface{}, socketID interface{}) *APIClientRequester_RemovePolicyFromSocket_Call {
	return &APIClientRequester_RemovePolicyFromSocket_Call{Call: _e.mock.On("RemovePolicyFromSocket", ctx, policyID, socketID)}
}

func (_c *APIClientRequester_RemovePolicyFromSocket_Call) Run(run func(ctx context.Context, policyID string, socketID string)) *APIClientRequester_RemovePolicyFromSocket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *APIClientRequester_RemovePolicyFromSocket_Call) Return(err error) *APIClientRequester_RemovePolicyFromSocket_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *APIClientRequester_RemovePolicyFromSocket_Call) RunAndReturn(run func(context.Context, string, string) error) *APIClientRequester_RemovePolicyFromSocket_Call {
	_c.Call.Return(run)
	return _c
}

// SignSocketKey provides a mock function with given fields: ctx, idOrName, in
func (_m *APIClientRequester) SignSocketKey(ctx context.Context, idOrName string, in *client.SocketKeyToSign) (*client.SignedSocketKey, error) {
	ret := _m.Called(ctx, idOrName, in)

	var r0 *client.SignedSocketKey
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *client.SocketKeyToSign) (*client.SignedSocketKey, error)); ok {
		return rf(ctx, idOrName, in)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, *client.SocketKeyToSign) *client.SignedSocketKey); ok {
		r0 = rf(ctx, idOrName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.SignedSocketKey)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, *client.SocketKeyToSign) error); ok {
		r1 = rf(ctx, idOrName, in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_SignSocketKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignSocketKey'
type APIClientRequester_SignSocketKey_Call struct {
	*mock.Call
}

// SignSocketKey is a helper method to define mock.On call
//   - ctx context.Context
//   - idOrName string
//   - in *client.SocketKeyToSign
func (_e *APIClientRequester_Expecter) SignSocketKey(ctx interface{}, idOrName interface{}, in interface{}) *APIClientRequester_SignSocketKey_Call {
	return &APIClientRequester_SignSocketKey_Call{Call: _e.mock.On("SignSocketKey", ctx, idOrName, in)}
}

func (_c *APIClientRequester_SignSocketKey_Call) Run(run func(ctx context.Context, idOrName string, in *client.SocketKeyToSign)) *APIClientRequester_SignSocketKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*client.SocketKeyToSign))
	})
	return _c
}

func (_c *APIClientRequester_SignSocketKey_Call) Return(out *client.SignedSocketKey, err error) *APIClientRequester_SignSocketKey_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_SignSocketKey_Call) RunAndReturn(run func(context.Context, string, *client.SocketKeyToSign) (*client.SignedSocketKey, error)) *APIClientRequester_SignSocketKey_Call {
	_c.Call.Return(run)
	return _c
}

// Socket provides a mock function with given fields: ctx, idOrName
func (_m *APIClientRequester) Socket(ctx context.Context, idOrName string) (*client.Socket, error) {
	ret := _m.Called(ctx, idOrName)

	var r0 *client.Socket
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*client.Socket, error)); ok {
		return rf(ctx, idOrName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *client.Socket); ok {
		r0 = rf(ctx, idOrName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Socket)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, idOrName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_Socket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Socket'
type APIClientRequester_Socket_Call struct {
	*mock.Call
}

// Socket is a helper method to define mock.On call
//   - ctx context.Context
//   - idOrName string
func (_e *APIClientRequester_Expecter) Socket(ctx interface{}, idOrName interface{}) *APIClientRequester_Socket_Call {
	return &APIClientRequester_Socket_Call{Call: _e.mock.On("Socket", ctx, idOrName)}
}

func (_c *APIClientRequester_Socket_Call) Run(run func(ctx context.Context, idOrName string)) *APIClientRequester_Socket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *APIClientRequester_Socket_Call) Return(out *client.Socket, err error) *APIClientRequester_Socket_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_Socket_Call) RunAndReturn(run func(context.Context, string) (*client.Socket, error)) *APIClientRequester_Socket_Call {
	_c.Call.Return(run)
	return _c
}

// SocketConnectors provides a mock function with given fields: ctx, idOrName
func (_m *APIClientRequester) SocketConnectors(ctx context.Context, idOrName string) (*client.SocketConnectors, error) {
	ret := _m.Called(ctx, idOrName)

	var r0 *client.SocketConnectors
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*client.SocketConnectors, error)); ok {
		return rf(ctx, idOrName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *client.SocketConnectors); ok {
		r0 = rf(ctx, idOrName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.SocketConnectors)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, idOrName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_SocketConnectors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SocketConnectors'
type APIClientRequester_SocketConnectors_Call struct {
	*mock.Call
}

// SocketConnectors is a helper method to define mock.On call
//   - ctx context.Context
//   - idOrName string
func (_e *APIClientRequester_Expecter) SocketConnectors(ctx interface{}, idOrName interface{}) *APIClientRequester_SocketConnectors_Call {
	return &APIClientRequester_SocketConnectors_Call{Call: _e.mock.On("SocketConnectors", ctx, idOrName)}
}

func (_c *APIClientRequester_SocketConnectors_Call) Run(run func(ctx context.Context, idOrName string)) *APIClientRequester_SocketConnectors_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *APIClientRequester_SocketConnectors_Call) Return(out *client.SocketConnectors, err error) *APIClientRequester_SocketConnectors_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_SocketConnectors_Call) RunAndReturn(run func(context.Context, string) (*client.SocketConnectors, error)) *APIClientRequester_SocketConnectors_Call {
	_c.Call.Return(run)
	return _c
}

// SocketUpstreamConfigs provides a mock function with given fields: ctx, idOrName
func (_m *APIClientRequester) SocketUpstreamConfigs(ctx context.Context, idOrName string) (*client.SocketUpstreamConfigs, error) {
	ret := _m.Called(ctx, idOrName)

	var r0 *client.SocketUpstreamConfigs
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*client.SocketUpstreamConfigs, error)); ok {
		return rf(ctx, idOrName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *client.SocketUpstreamConfigs); ok {
		r0 = rf(ctx, idOrName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.SocketUpstreamConfigs)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, idOrName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_SocketUpstreamConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SocketUpstreamConfigs'
type APIClientRequester_SocketUpstreamConfigs_Call struct {
	*mock.Call
}

// SocketUpstreamConfigs is a helper method to define mock.On call
//   - ctx context.Context
//   - idOrName string
func (_e *APIClientRequester_Expecter) SocketUpstreamConfigs(ctx interface{}, idOrName interface{}) *APIClientRequester_SocketUpstreamConfigs_Call {
	return &APIClientRequester_SocketUpstreamConfigs_Call{Call: _e.mock.On("SocketUpstreamConfigs", ctx, idOrName)}
}

func (_c *APIClientRequester_SocketUpstreamConfigs_Call) Run(run func(ctx context.Context, idOrName string)) *APIClientRequester_SocketUpstreamConfigs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *APIClientRequester_SocketUpstreamConfigs_Call) Return(out *client.SocketUpstreamConfigs, err error) *APIClientRequester_SocketUpstreamConfigs_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_SocketUpstreamConfigs_Call) RunAndReturn(run func(context.Context, string) (*client.SocketUpstreamConfigs, error)) *APIClientRequester_SocketUpstreamConfigs_Call {
	_c.Call.Return(run)
	return _c
}

// Sockets provides a mock function with given fields: ctx
func (_m *APIClientRequester) Sockets(ctx context.Context) ([]client.Socket, error) {
	ret := _m.Called(ctx)

	var r0 []client.Socket
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]client.Socket, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []client.Socket); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Socket)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_Sockets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sockets'
type APIClientRequester_Sockets_Call struct {
	*mock.Call
}

// Sockets is a helper method to define mock.On call
//   - ctx context.Context
func (_e *APIClientRequester_Expecter) Sockets(ctx interface{}) *APIClientRequester_Sockets_Call {
	return &APIClientRequester_Sockets_Call{Call: _e.mock.On("Sockets", ctx)}
}

func (_c *APIClientRequester_Sockets_Call) Run(run func(ctx context.Context)) *APIClientRequester_Sockets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *APIClientRequester_Sockets_Call) Return(out []client.Socket, err error) *APIClientRequester_Sockets_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_Sockets_Call) RunAndReturn(run func(context.Context) ([]client.Socket, error)) *APIClientRequester_Sockets_Call {
	_c.Call.Return(run)
	return _c
}

// TokenClaims provides a mock function with given fields:
func (_m *APIClientRequester) TokenClaims() (jwt.MapClaims, error) {
	ret := _m.Called()

	var r0 jwt.MapClaims
	var r1 error
	if rf, ok := ret.Get(0).(func() (jwt.MapClaims, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() jwt.MapClaims); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(jwt.MapClaims)
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_TokenClaims_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TokenClaims'
type APIClientRequester_TokenClaims_Call struct {
	*mock.Call
}

// TokenClaims is a helper method to define mock.On call
func (_e *APIClientRequester_Expecter) TokenClaims() *APIClientRequester_TokenClaims_Call {
	return &APIClientRequester_TokenClaims_Call{Call: _e.mock.On("TokenClaims")}
}

func (_c *APIClientRequester_TokenClaims_Call) Run(run func()) *APIClientRequester_TokenClaims_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *APIClientRequester_TokenClaims_Call) Return(_a0 jwt.MapClaims, _a1 error) *APIClientRequester_TokenClaims_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *APIClientRequester_TokenClaims_Call) RunAndReturn(run func() (jwt.MapClaims, error)) *APIClientRequester_TokenClaims_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateConnector provides a mock function with given fields: ctx, in
func (_m *APIClientRequester) UpdateConnector(ctx context.Context, in *client.Connector) (*client.Connector, error) {
	ret := _m.Called(ctx, in)

	var r0 *client.Connector
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.Connector) (*client.Connector, error)); ok {
		return rf(ctx, in)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *client.Connector) *client.Connector); ok {
		r0 = rf(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Connector)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *client.Connector) error); ok {
		r1 = rf(ctx, in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_UpdateConnector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateConnector'
type APIClientRequester_UpdateConnector_Call struct {
	*mock.Call
}

// UpdateConnector is a helper method to define mock.On call
//   - ctx context.Context
//   - in *client.Connector
func (_e *APIClientRequester_Expecter) UpdateConnector(ctx interface{}, in interface{}) *APIClientRequester_UpdateConnector_Call {
	return &APIClientRequester_UpdateConnector_Call{Call: _e.mock.On("UpdateConnector", ctx, in)}
}

func (_c *APIClientRequester_UpdateConnector_Call) Run(run func(ctx context.Context, in *client.Connector)) *APIClientRequester_UpdateConnector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.Connector))
	})
	return _c
}

func (_c *APIClientRequester_UpdateConnector_Call) Return(out *client.Connector, err error) *APIClientRequester_UpdateConnector_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_UpdateConnector_Call) RunAndReturn(run func(context.Context, *client.Connector) (*client.Connector, error)) *APIClientRequester_UpdateConnector_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePolicy provides a mock function with given fields: ctx, id, in
func (_m *APIClientRequester) UpdatePolicy(ctx context.Context, id string, in *client.Policy) (*client.Policy, error) {
	ret := _m.Called(ctx, id, in)

	var r0 *client.Policy
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *client.Policy) (*client.Policy, error)); ok {
		return rf(ctx, id, in)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, *client.Policy) *client.Policy); ok {
		r0 = rf(ctx, id, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Policy)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, *client.Policy) error); ok {
		r1 = rf(ctx, id, in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_UpdatePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePolicy'
type APIClientRequester_UpdatePolicy_Call struct {
	*mock.Call
}

// UpdatePolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - in *client.Policy
func (_e *APIClientRequester_Expecter) UpdatePolicy(ctx interface{}, id interface{}, in interface{}) *APIClientRequester_UpdatePolicy_Call {
	return &APIClientRequester_UpdatePolicy_Call{Call: _e.mock.On("UpdatePolicy", ctx, id, in)}
}

func (_c *APIClientRequester_UpdatePolicy_Call) Run(run func(ctx context.Context, id string, in *client.Policy)) *APIClientRequester_UpdatePolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*client.Policy))
	})
	return _c
}

func (_c *APIClientRequester_UpdatePolicy_Call) Return(out *client.Policy, err error) *APIClientRequester_UpdatePolicy_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_UpdatePolicy_Call) RunAndReturn(run func(context.Context, string, *client.Policy) (*client.Policy, error)) *APIClientRequester_UpdatePolicy_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSocket provides a mock function with given fields: ctx, idOrName, in
func (_m *APIClientRequester) UpdateSocket(ctx context.Context, idOrName string, in *client.Socket) (*client.Socket, error) {
	ret := _m.Called(ctx, idOrName, in)

	var r0 *client.Socket
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *client.Socket) (*client.Socket, error)); ok {
		return rf(ctx, idOrName, in)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, *client.Socket) *client.Socket); ok {
		r0 = rf(ctx, idOrName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Socket)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, *client.Socket) error); ok {
		r1 = rf(ctx, idOrName, in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// APIClientRequester_UpdateSocket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSocket'
type APIClientRequester_UpdateSocket_Call struct {
	*mock.Call
}

// UpdateSocket is a helper method to define mock.On call
//   - ctx context.Context
//   - idOrName string
//   - in *client.Socket
func (_e *APIClientRequester_Expecter) UpdateSocket(ctx interface{}, idOrName interface{}, in interface{}) *APIClientRequester_UpdateSocket_Call {
	return &APIClientRequester_UpdateSocket_Call{Call: _e.mock.On("UpdateSocket", ctx, idOrName, in)}
}

func (_c *APIClientRequester_UpdateSocket_Call) Run(run func(ctx context.Context, idOrName string, in *client.Socket)) *APIClientRequester_UpdateSocket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*client.Socket))
	})
	return _c
}

func (_c *APIClientRequester_UpdateSocket_Call) Return(out *client.Socket, err error) *APIClientRequester_UpdateSocket_Call {
	_c.Call.Return(out, err)
	return _c
}

func (_c *APIClientRequester_UpdateSocket_Call) RunAndReturn(run func(context.Context, string, *client.Socket) (*client.Socket, error)) *APIClientRequester_UpdateSocket_Call {
	_c.Call.Return(run)
	return _c
}

type mockConstructorTestingTNewAPIClientRequester interface {
	mock.TestingT
	Cleanup(func())
}

// NewAPIClientRequester creates a new instance of APIClientRequester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewAPIClientRequester(t mockConstructorTestingTNewAPIClientRequester) *APIClientRequester {
	mock := &APIClientRequester{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}