// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/logger/logger.go
//
// Generated by this command:
//
//	mockgen -source pkg/logger/logger.go -destination internal/mocks/mock_logger.go -package mocks
//

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

import (
	context "context"
	reflect "reflect"

	logger "github.com/openfga/openfga/pkg/logger"
	gomock "go.uber.org/mock/gomock"
	zap "go.uber.org/zap"
)

// MockLogger is a mock of Logger interface.
type MockLogger struct {
	ctrl     *gomock.Controller
	recorder *MockLoggerMockRecorder
	isgomock struct{}
}

// MockLoggerMockRecorder is the mock recorder for MockLogger.
type MockLoggerMockRecorder struct {
	mock *MockLogger
}

// NewMockLogger creates a new mock instance.
func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
	mock := &MockLogger{ctrl: ctrl}
	mock.recorder = &MockLoggerMockRecorder{mock}
	return mock
}

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

// Debug mocks base method.
func (m *MockLogger) Debug(arg0 string, arg1 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debug", varargs...)
}

// Debug indicates an expected call of Debug.
func (mr *MockLoggerMockRecorder) Debug(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), varargs...)
}

// DebugWithContext mocks base method.
func (m *MockLogger) DebugWithContext(arg0 context.Context, arg1 string, arg2 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "DebugWithContext", varargs...)
}

// DebugWithContext indicates an expected call of DebugWithContext.
func (mr *MockLoggerMockRecorder) DebugWithContext(arg0, arg1 any, arg2 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugWithContext", reflect.TypeOf((*MockLogger)(nil).DebugWithContext), varargs...)
}

// Error mocks base method.
func (m *MockLogger) Error(arg0 string, arg1 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Error", varargs...)
}

// Error indicates an expected call of Error.
func (mr *MockLoggerMockRecorder) Error(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), varargs...)
}

// ErrorWithContext mocks base method.
func (m *MockLogger) ErrorWithContext(arg0 context.Context, arg1 string, arg2 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "ErrorWithContext", varargs...)
}

// ErrorWithContext indicates an expected call of ErrorWithContext.
func (mr *MockLoggerMockRecorder) ErrorWithContext(arg0, arg1 any, arg2 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ErrorWithContext", reflect.TypeOf((*MockLogger)(nil).ErrorWithContext), varargs...)
}

// Fatal mocks base method.
func (m *MockLogger) Fatal(arg0 string, arg1 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Fatal", varargs...)
}

// Fatal indicates an expected call of Fatal.
func (mr *MockLoggerMockRecorder) Fatal(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fatal", reflect.TypeOf((*MockLogger)(nil).Fatal), varargs...)
}

// FatalWithContext mocks base method.
func (m *MockLogger) FatalWithContext(arg0 context.Context, arg1 string, arg2 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "FatalWithContext", varargs...)
}

// FatalWithContext indicates an expected call of FatalWithContext.
func (mr *MockLoggerMockRecorder) FatalWithContext(arg0, arg1 any, arg2 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FatalWithContext", reflect.TypeOf((*MockLogger)(nil).FatalWithContext), varargs...)
}

// Info mocks base method.
func (m *MockLogger) Info(arg0 string, arg1 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Info", varargs...)
}

// Info indicates an expected call of Info.
func (mr *MockLoggerMockRecorder) Info(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), varargs...)
}

// InfoWithContext mocks base method.
func (m *MockLogger) InfoWithContext(arg0 context.Context, arg1 string, arg2 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "InfoWithContext", varargs...)
}

// InfoWithContext indicates an expected call of InfoWithContext.
func (mr *MockLoggerMockRecorder) InfoWithContext(arg0, arg1 any, arg2 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InfoWithContext", reflect.TypeOf((*MockLogger)(nil).InfoWithContext), varargs...)
}

// Panic mocks base method.
func (m *MockLogger) Panic(arg0 string, arg1 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Panic", varargs...)
}

// Panic indicates an expected call of Panic.
func (mr *MockLoggerMockRecorder) Panic(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Panic", reflect.TypeOf((*MockLogger)(nil).Panic), varargs...)
}

// PanicWithContext mocks base method.
func (m *MockLogger) PanicWithContext(arg0 context.Context, arg1 string, arg2 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "PanicWithContext", varargs...)
}

// PanicWithContext indicates an expected call of PanicWithContext.
func (mr *MockLoggerMockRecorder) PanicWithContext(arg0, arg1 any, arg2 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PanicWithContext", reflect.TypeOf((*MockLogger)(nil).PanicWithContext), varargs...)
}

// Warn mocks base method.
func (m *MockLogger) Warn(arg0 string, arg1 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warn", varargs...)
}

// Warn indicates an expected call of Warn.
func (mr *MockLoggerMockRecorder) Warn(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockLogger)(nil).Warn), varargs...)
}

// WarnWithContext mocks base method.
func (m *MockLogger) WarnWithContext(arg0 context.Context, arg1 string, arg2 ...zap.Field) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "WarnWithContext", varargs...)
}

// WarnWithContext indicates an expected call of WarnWithContext.
func (mr *MockLoggerMockRecorder) WarnWithContext(arg0, arg1 any, arg2 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WarnWithContext", reflect.TypeOf((*MockLogger)(nil).WarnWithContext), varargs...)
}

// With mocks base method.
func (m *MockLogger) With(arg0 ...zap.Field) logger.Logger {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "With", varargs...)
	ret0, _ := ret[0].(logger.Logger)
	return ret0
}

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