// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/macaroons/interfaces.go
//
// Generated by this command:
//
//	mockgen -source pkg/macaroons/interfaces.go -destination pkg/macaroons/mock_gen.go -package macaroons
//

// Package macaroons is a generated GoMock package.
package macaroons

import (
	context "context"
	reflect "reflect"
	time "time"

	fiber "github.com/gofiber/fiber/v2"
	gomock "go.uber.org/mock/gomock"
)

// MockCaveatParserInterface is a mock of CaveatParserInterface interface.
type MockCaveatParserInterface struct {
	ctrl     *gomock.Controller
	recorder *MockCaveatParserInterfaceMockRecorder
	isgomock struct{}
}

// MockCaveatParserInterfaceMockRecorder is the mock recorder for MockCaveatParserInterface.
type MockCaveatParserInterfaceMockRecorder struct {
	mock *MockCaveatParserInterface
}

// NewMockCaveatParserInterface creates a new mock instance.
func NewMockCaveatParserInterface(ctrl *gomock.Controller) *MockCaveatParserInterface {
	mock := &MockCaveatParserInterface{ctrl: ctrl}
	mock.recorder = &MockCaveatParserInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCaveatParserInterface) EXPECT() *MockCaveatParserInterfaceMockRecorder {
	return m.recorder
}

// Parse mocks base method.
func (m *MockCaveatParserInterface) Parse(arg0 string) (Caveat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Parse", arg0)
	ret0, _ := ret[0].(Caveat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Parse indicates an expected call of Parse.
func (mr *MockCaveatParserInterfaceMockRecorder) Parse(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parse", reflect.TypeOf((*MockCaveatParserInterface)(nil).Parse), arg0)
}

// Register mocks base method.
func (m *MockCaveatParserInterface) Register(typ string, constructor CaveatConstructor) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Register", typ, constructor)
	ret0, _ := ret[0].(error)
	return ret0
}

// Register indicates an expected call of Register.
func (mr *MockCaveatParserInterfaceMockRecorder) Register(typ, constructor any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Register", reflect.TypeOf((*MockCaveatParserInterface)(nil).Register), typ, constructor)
}

// MockCaveat is a mock of Caveat interface.
type MockCaveat struct {
	ctrl     *gomock.Controller
	recorder *MockCaveatMockRecorder
	isgomock struct{}
}

// MockCaveatMockRecorder is the mock recorder for MockCaveat.
type MockCaveatMockRecorder struct {
	mock *MockCaveat
}

// NewMockCaveat creates a new mock instance.
func NewMockCaveat(ctrl *gomock.Controller) *MockCaveat {
	mock := &MockCaveat{ctrl: ctrl}
	mock.recorder = &MockCaveatMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCaveat) EXPECT() *MockCaveatMockRecorder {
	return m.recorder
}

// Type mocks base method.
func (m *MockCaveat) Type() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(string)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockCaveatMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockCaveat)(nil).Type))
}

// Validate mocks base method.
func (m *MockCaveat) Validate(arg0 *fiber.Ctx) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Validate", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Validate indicates an expected call of Validate.
func (mr *MockCaveatMockRecorder) Validate(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validate", reflect.TypeOf((*MockCaveat)(nil).Validate), arg0)
}

// MockMacaroonParserInterface is a mock of MacaroonParserInterface interface.
type MockMacaroonParserInterface struct {
	ctrl     *gomock.Controller
	recorder *MockMacaroonParserInterfaceMockRecorder
	isgomock struct{}
}

// MockMacaroonParserInterfaceMockRecorder is the mock recorder for MockMacaroonParserInterface.
type MockMacaroonParserInterfaceMockRecorder struct {
	mock *MockMacaroonParserInterface
}

// NewMockMacaroonParserInterface creates a new mock instance.
func NewMockMacaroonParserInterface(ctrl *gomock.Controller) *MockMacaroonParserInterface {
	mock := &MockMacaroonParserInterface{ctrl: ctrl}
	mock.recorder = &MockMacaroonParserInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMacaroonParserInterface) EXPECT() *MockMacaroonParserInterfaceMockRecorder {
	return m.recorder
}

// CreateToken mocks base method.
func (m *MockMacaroonParserInterface) CreateToken(ctx context.Context, userID int32, caveats []Caveat, ttl time.Duration) (*Macaroon, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateToken", ctx, userID, caveats, ttl)
	ret0, _ := ret[0].(*Macaroon)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateToken indicates an expected call of CreateToken.
func (mr *MockMacaroonParserInterfaceMockRecorder) CreateToken(ctx, userID, caveats, ttl any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateToken", reflect.TypeOf((*MockMacaroonParserInterface)(nil).CreateToken), ctx, userID, caveats, ttl)
}

// InvalidateUserTokens mocks base method.
func (m *MockMacaroonParserInterface) InvalidateUserTokens(ctx context.Context, userID int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InvalidateUserTokens", ctx, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

// InvalidateUserTokens indicates an expected call of InvalidateUserTokens.
func (mr *MockMacaroonParserInterfaceMockRecorder) InvalidateUserTokens(ctx, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvalidateUserTokens", reflect.TypeOf((*MockMacaroonParserInterface)(nil).InvalidateUserTokens), ctx, userID)
}

// Parse mocks base method.
func (m *MockMacaroonParserInterface) Parse(ctx context.Context, token string) (*Macaroon, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Parse", ctx, token)
	ret0, _ := ret[0].(*Macaroon)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Parse indicates an expected call of Parse.
func (mr *MockMacaroonParserInterfaceMockRecorder) Parse(ctx, token any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parse", reflect.TypeOf((*MockMacaroonParserInterface)(nil).Parse), ctx, token)
}
