// Code generated by MockGen. DO NOT EDIT.
//
// Generated by this command:
//
//

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

import (
	context "context"
	http "net/http"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockUserSvcAPI is a mock of UserSvcAPI interface.
type MockUserSvcAPI struct {
	ctrl     *gomock.Controller
	recorder *MockUserSvcAPIMockRecorder
	isgomock struct{}
}

// MockUserSvcAPIMockRecorder is the mock recorder for MockUserSvcAPI.
type MockUserSvcAPIMockRecorder struct {
	mock *MockUserSvcAPI
}

// NewMockUserSvcAPI creates a new mock instance.
func NewMockUserSvcAPI(ctrl *gomock.Controller) *MockUserSvcAPI {
	mock := &MockUserSvcAPI{ctrl: ctrl}
	mock.recorder = &MockUserSvcAPIMockRecorder{mock}
	return mock
}

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

// ChangePassword mocks base method.
func (m *MockUserSvcAPI) ChangePassword(ctx context.Context) ApiChangePasswordRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangePassword", ctx)
	ret0, _ := ret[0].(ApiChangePasswordRequest)
	return ret0
}

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

// ChangePasswordExecute mocks base method.
func (m *MockUserSvcAPI) ChangePasswordExecute(r ApiChangePasswordRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangePasswordExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangePasswordExecute indicates an expected call of ChangePasswordExecute.
func (mr *MockUserSvcAPIMockRecorder) ChangePasswordExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePasswordExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ChangePasswordExecute), r)
}

// CreateUser mocks base method.
func (m *MockUserSvcAPI) CreateUser(ctx context.Context) ApiCreateUserRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUser", ctx)
	ret0, _ := ret[0].(ApiCreateUserRequest)
	return ret0
}

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

// CreateUserExecute mocks base method.
func (m *MockUserSvcAPI) CreateUserExecute(r ApiCreateUserRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUserExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateUserExecute indicates an expected call of CreateUserExecute.
func (mr *MockUserSvcAPIMockRecorder) CreateUserExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).CreateUserExecute), r)
}

// DeleteMembership mocks base method.
func (m *MockUserSvcAPI) DeleteMembership(ctx context.Context, organizationId, userId string) ApiDeleteMembershipRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMembership", ctx, organizationId, userId)
	ret0, _ := ret[0].(ApiDeleteMembershipRequest)
	return ret0
}

// DeleteMembership indicates an expected call of DeleteMembership.
func (mr *MockUserSvcAPIMockRecorder) DeleteMembership(ctx, organizationId, userId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMembership", reflect.TypeOf((*MockUserSvcAPI)(nil).DeleteMembership), ctx, organizationId, userId)
}

// DeleteMembershipExecute mocks base method.
func (m *MockUserSvcAPI) DeleteMembershipExecute(r ApiDeleteMembershipRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMembershipExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteMembershipExecute indicates an expected call of DeleteMembershipExecute.
func (mr *MockUserSvcAPIMockRecorder) DeleteMembershipExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMembershipExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).DeleteMembershipExecute), r)
}

// DeleteUser mocks base method.
func (m *MockUserSvcAPI) DeleteUser(ctx context.Context, userId string) ApiDeleteUserRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUser", ctx, userId)
	ret0, _ := ret[0].(ApiDeleteUserRequest)
	return ret0
}

// DeleteUser indicates an expected call of DeleteUser.
func (mr *MockUserSvcAPIMockRecorder) DeleteUser(ctx, userId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUser", reflect.TypeOf((*MockUserSvcAPI)(nil).DeleteUser), ctx, userId)
}

// DeleteUserExecute mocks base method.
func (m *MockUserSvcAPI) DeleteUserExecute(r ApiDeleteUserRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteUserExecute indicates an expected call of DeleteUserExecute.
func (mr *MockUserSvcAPIMockRecorder) DeleteUserExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).DeleteUserExecute), r)
}

// ExchangeToken mocks base method.
func (m *MockUserSvcAPI) ExchangeToken(ctx context.Context) ApiExchangeTokenRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExchangeToken", ctx)
	ret0, _ := ret[0].(ApiExchangeTokenRequest)
	return ret0
}

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

// ExchangeTokenExecute mocks base method.
func (m *MockUserSvcAPI) ExchangeTokenExecute(r ApiExchangeTokenRequest) (*UserSvcExchangeTokenResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExchangeTokenExecute", r)
	ret0, _ := ret[0].(*UserSvcExchangeTokenResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ExchangeTokenExecute indicates an expected call of ExchangeTokenExecute.
func (mr *MockUserSvcAPIMockRecorder) ExchangeTokenExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExchangeTokenExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ExchangeTokenExecute), r)
}

// ExchangeToken_1 mocks base method.
func (m *MockUserSvcAPI) ExchangeToken_1(ctx context.Context) ApiExchangeToken_0Request {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExchangeToken_1", ctx)
	ret0, _ := ret[0].(ApiExchangeToken_0Request)
	return ret0
}

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

// ExchangeToken_1Execute mocks base method.
func (m *MockUserSvcAPI) ExchangeToken_1Execute(r ApiExchangeToken_0Request) (*UserSvcExchangeTokenResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExchangeToken_1Execute", r)
	ret0, _ := ret[0].(*UserSvcExchangeTokenResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ExchangeToken_1Execute indicates an expected call of ExchangeToken_1Execute.
func (mr *MockUserSvcAPIMockRecorder) ExchangeToken_1Execute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExchangeToken_1Execute", reflect.TypeOf((*MockUserSvcAPI)(nil).ExchangeToken_1Execute), r)
}

// GetPublicKey mocks base method.
func (m *MockUserSvcAPI) GetPublicKey(ctx context.Context) ApiGetPublicKeyRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPublicKey", ctx)
	ret0, _ := ret[0].(ApiGetPublicKeyRequest)
	return ret0
}

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

// GetPublicKeyExecute mocks base method.
func (m *MockUserSvcAPI) GetPublicKeyExecute(r ApiGetPublicKeyRequest) (*UserSvcGetPublicKeyResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPublicKeyExecute", r)
	ret0, _ := ret[0].(*UserSvcGetPublicKeyResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPublicKeyExecute indicates an expected call of GetPublicKeyExecute.
func (mr *MockUserSvcAPIMockRecorder) GetPublicKeyExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicKeyExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).GetPublicKeyExecute), r)
}

// HasPermission mocks base method.
func (m *MockUserSvcAPI) HasPermission(ctx context.Context, permission string) ApiHasPermissionRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasPermission", ctx, permission)
	ret0, _ := ret[0].(ApiHasPermissionRequest)
	return ret0
}

// HasPermission indicates an expected call of HasPermission.
func (mr *MockUserSvcAPIMockRecorder) HasPermission(ctx, permission any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPermission", reflect.TypeOf((*MockUserSvcAPI)(nil).HasPermission), ctx, permission)
}

// HasPermissionExecute mocks base method.
func (m *MockUserSvcAPI) HasPermissionExecute(r ApiHasPermissionRequest) (*UserSvcHasPermissionResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasPermissionExecute", r)
	ret0, _ := ret[0].(*UserSvcHasPermissionResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// HasPermissionExecute indicates an expected call of HasPermissionExecute.
func (mr *MockUserSvcAPIMockRecorder) HasPermissionExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPermissionExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).HasPermissionExecute), r)
}

// ListApps mocks base method.
func (m *MockUserSvcAPI) ListApps(ctx context.Context) ApiListAppsRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApps", ctx)
	ret0, _ := ret[0].(ApiListAppsRequest)
	return ret0
}

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

// ListAppsExecute mocks base method.
func (m *MockUserSvcAPI) ListAppsExecute(r ApiListAppsRequest) (*UserSvcListAppsResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAppsExecute", r)
	ret0, _ := ret[0].(*UserSvcListAppsResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListAppsExecute indicates an expected call of ListAppsExecute.
func (mr *MockUserSvcAPIMockRecorder) ListAppsExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAppsExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ListAppsExecute), r)
}

// ListEnrolls mocks base method.
func (m *MockUserSvcAPI) ListEnrolls(ctx context.Context) ApiListEnrollsRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEnrolls", ctx)
	ret0, _ := ret[0].(ApiListEnrollsRequest)
	return ret0
}

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

// ListEnrollsExecute mocks base method.
func (m *MockUserSvcAPI) ListEnrollsExecute(r ApiListEnrollsRequest) (*UserSvcListEnrollsResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEnrollsExecute", r)
	ret0, _ := ret[0].(*UserSvcListEnrollsResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListEnrollsExecute indicates an expected call of ListEnrollsExecute.
func (mr *MockUserSvcAPIMockRecorder) ListEnrollsExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEnrollsExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ListEnrollsExecute), r)
}

// ListOrganizations mocks base method.
func (m *MockUserSvcAPI) ListOrganizations(ctx context.Context) ApiListOrganizationsRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOrganizations", ctx)
	ret0, _ := ret[0].(ApiListOrganizationsRequest)
	return ret0
}

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

// ListOrganizationsExecute mocks base method.
func (m *MockUserSvcAPI) ListOrganizationsExecute(r ApiListOrganizationsRequest) (*UserSvcListOrganizationsResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOrganizationsExecute", r)
	ret0, _ := ret[0].(*UserSvcListOrganizationsResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListOrganizationsExecute indicates an expected call of ListOrganizationsExecute.
func (mr *MockUserSvcAPIMockRecorder) ListOrganizationsExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOrganizationsExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ListOrganizationsExecute), r)
}

// ListPermissions mocks base method.
func (m *MockUserSvcAPI) ListPermissions(ctx context.Context, roleId string) ApiListPermissionsRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPermissions", ctx, roleId)
	ret0, _ := ret[0].(ApiListPermissionsRequest)
	return ret0
}

// ListPermissions indicates an expected call of ListPermissions.
func (mr *MockUserSvcAPIMockRecorder) ListPermissions(ctx, roleId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPermissions", reflect.TypeOf((*MockUserSvcAPI)(nil).ListPermissions), ctx, roleId)
}

// ListPermissionsExecute mocks base method.
func (m *MockUserSvcAPI) ListPermissionsExecute(r ApiListPermissionsRequest) (*UserSvcListPermissionsResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPermissionsExecute", r)
	ret0, _ := ret[0].(*UserSvcListPermissionsResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListPermissionsExecute indicates an expected call of ListPermissionsExecute.
func (mr *MockUserSvcAPIMockRecorder) ListPermissionsExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPermissionsExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ListPermissionsExecute), r)
}

// ListPermits mocks base method.
func (m *MockUserSvcAPI) ListPermits(ctx context.Context) ApiListPermitsRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPermits", ctx)
	ret0, _ := ret[0].(ApiListPermitsRequest)
	return ret0
}

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

// ListPermitsExecute mocks base method.
func (m *MockUserSvcAPI) ListPermitsExecute(r ApiListPermitsRequest) (*UserSvcListPermitsResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPermitsExecute", r)
	ret0, _ := ret[0].(*UserSvcListPermitsResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListPermitsExecute indicates an expected call of ListPermitsExecute.
func (mr *MockUserSvcAPIMockRecorder) ListPermitsExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPermitsExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ListPermitsExecute), r)
}

// ListUsers mocks base method.
func (m *MockUserSvcAPI) ListUsers(ctx context.Context) ApiListUsersRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUsers", ctx)
	ret0, _ := ret[0].(ApiListUsersRequest)
	return ret0
}

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

// ListUsersExecute mocks base method.
func (m *MockUserSvcAPI) ListUsersExecute(r ApiListUsersRequest) (*UserSvcListUsersResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUsersExecute", r)
	ret0, _ := ret[0].(*UserSvcListUsersResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListUsersExecute indicates an expected call of ListUsersExecute.
func (mr *MockUserSvcAPIMockRecorder) ListUsersExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ListUsersExecute), r)
}

// Login mocks base method.
func (m *MockUserSvcAPI) Login(ctx context.Context) ApiLoginRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Login", ctx)
	ret0, _ := ret[0].(ApiLoginRequest)
	return ret0
}

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

// LoginExecute mocks base method.
func (m *MockUserSvcAPI) LoginExecute(r ApiLoginRequest) (*UserSvcLoginResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoginExecute", r)
	ret0, _ := ret[0].(*UserSvcLoginResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// LoginExecute indicates an expected call of LoginExecute.
func (mr *MockUserSvcAPIMockRecorder) LoginExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoginExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).LoginExecute), r)
}

// ReadApp mocks base method.
func (m *MockUserSvcAPI) ReadApp(ctx context.Context) ApiReadAppRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadApp", ctx)
	ret0, _ := ret[0].(ApiReadAppRequest)
	return ret0
}

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

// ReadAppExecute mocks base method.
func (m *MockUserSvcAPI) ReadAppExecute(r ApiReadAppRequest) (*UserSvcReadAppResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadAppExecute", r)
	ret0, _ := ret[0].(*UserSvcReadAppResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadAppExecute indicates an expected call of ReadAppExecute.
func (mr *MockUserSvcAPIMockRecorder) ReadAppExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAppExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ReadAppExecute), r)
}

// ReadSelf mocks base method.
func (m *MockUserSvcAPI) ReadSelf(ctx context.Context) ApiReadSelfRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadSelf", ctx)
	ret0, _ := ret[0].(ApiReadSelfRequest)
	return ret0
}

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

// ReadSelfExecute mocks base method.
func (m *MockUserSvcAPI) ReadSelfExecute(r ApiReadSelfRequest) (*UserSvcReadSelfResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadSelfExecute", r)
	ret0, _ := ret[0].(*UserSvcReadSelfResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadSelfExecute indicates an expected call of ReadSelfExecute.
func (mr *MockUserSvcAPIMockRecorder) ReadSelfExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSelfExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ReadSelfExecute), r)
}

// RefreshToken mocks base method.
func (m *MockUserSvcAPI) RefreshToken(ctx context.Context) ApiRefreshTokenRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshToken", ctx)
	ret0, _ := ret[0].(ApiRefreshTokenRequest)
	return ret0
}

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

// RefreshTokenExecute mocks base method.
func (m *MockUserSvcAPI) RefreshTokenExecute(r ApiRefreshTokenRequest) (*UserSvcRefreshTokenResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshTokenExecute", r)
	ret0, _ := ret[0].(*UserSvcRefreshTokenResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RefreshTokenExecute indicates an expected call of RefreshTokenExecute.
func (mr *MockUserSvcAPIMockRecorder) RefreshTokenExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshTokenExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).RefreshTokenExecute), r)
}

// Register mocks base method.
func (m *MockUserSvcAPI) Register(ctx context.Context) ApiRegisterRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Register", ctx)
	ret0, _ := ret[0].(ApiRegisterRequest)
	return ret0
}

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

// RegisterExecute mocks base method.
func (m *MockUserSvcAPI) RegisterExecute(r ApiRegisterRequest) (*UserSvcRegisterResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterExecute", r)
	ret0, _ := ret[0].(*UserSvcRegisterResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RegisterExecute indicates an expected call of RegisterExecute.
func (mr *MockUserSvcAPIMockRecorder) RegisterExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).RegisterExecute), r)
}

// ResetPassword mocks base method.
func (m *MockUserSvcAPI) ResetPassword(ctx context.Context, userId string) ApiResetPasswordRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetPassword", ctx, userId)
	ret0, _ := ret[0].(ApiResetPasswordRequest)
	return ret0
}

// ResetPassword indicates an expected call of ResetPassword.
func (mr *MockUserSvcAPIMockRecorder) ResetPassword(ctx, userId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPassword", reflect.TypeOf((*MockUserSvcAPI)(nil).ResetPassword), ctx, userId)
}

// ResetPasswordExecute mocks base method.
func (m *MockUserSvcAPI) ResetPasswordExecute(r ApiResetPasswordRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetPasswordExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ResetPasswordExecute indicates an expected call of ResetPasswordExecute.
func (mr *MockUserSvcAPIMockRecorder) ResetPasswordExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPasswordExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).ResetPasswordExecute), r)
}

// RevokeTokens mocks base method.
func (m *MockUserSvcAPI) RevokeTokens(ctx context.Context) ApiRevokeTokensRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeTokens", ctx)
	ret0, _ := ret[0].(ApiRevokeTokensRequest)
	return ret0
}

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

// RevokeTokensExecute mocks base method.
func (m *MockUserSvcAPI) RevokeTokensExecute(r ApiRevokeTokensRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeTokensExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RevokeTokensExecute indicates an expected call of RevokeTokensExecute.
func (mr *MockUserSvcAPIMockRecorder) RevokeTokensExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeTokensExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).RevokeTokensExecute), r)
}

// SaveEnrolls mocks base method.
func (m *MockUserSvcAPI) SaveEnrolls(ctx context.Context) ApiSaveEnrollsRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveEnrolls", ctx)
	ret0, _ := ret[0].(ApiSaveEnrollsRequest)
	return ret0
}

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

// SaveEnrollsExecute mocks base method.
func (m *MockUserSvcAPI) SaveEnrollsExecute(r ApiSaveEnrollsRequest) (*UserSvcSaveEnrollsResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveEnrollsExecute", r)
	ret0, _ := ret[0].(*UserSvcSaveEnrollsResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SaveEnrollsExecute indicates an expected call of SaveEnrollsExecute.
func (mr *MockUserSvcAPIMockRecorder) SaveEnrollsExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveEnrollsExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).SaveEnrollsExecute), r)
}

// SaveMembership mocks base method.
func (m *MockUserSvcAPI) SaveMembership(ctx context.Context, organizationId, userId string) ApiSaveMembershipRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveMembership", ctx, organizationId, userId)
	ret0, _ := ret[0].(ApiSaveMembershipRequest)
	return ret0
}

// SaveMembership indicates an expected call of SaveMembership.
func (mr *MockUserSvcAPIMockRecorder) SaveMembership(ctx, organizationId, userId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveMembership", reflect.TypeOf((*MockUserSvcAPI)(nil).SaveMembership), ctx, organizationId, userId)
}

// SaveMembershipExecute mocks base method.
func (m *MockUserSvcAPI) SaveMembershipExecute(r ApiSaveMembershipRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveMembershipExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SaveMembershipExecute indicates an expected call of SaveMembershipExecute.
func (mr *MockUserSvcAPIMockRecorder) SaveMembershipExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveMembershipExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).SaveMembershipExecute), r)
}

// SaveOrganization mocks base method.
func (m *MockUserSvcAPI) SaveOrganization(ctx context.Context) ApiSaveOrganizationRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveOrganization", ctx)
	ret0, _ := ret[0].(ApiSaveOrganizationRequest)
	return ret0
}

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

// SaveOrganizationExecute mocks base method.
func (m *MockUserSvcAPI) SaveOrganizationExecute(r ApiSaveOrganizationRequest) (*UserSvcSaveOrganizationResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveOrganizationExecute", r)
	ret0, _ := ret[0].(*UserSvcSaveOrganizationResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SaveOrganizationExecute indicates an expected call of SaveOrganizationExecute.
func (mr *MockUserSvcAPIMockRecorder) SaveOrganizationExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveOrganizationExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).SaveOrganizationExecute), r)
}

// SavePermits mocks base method.
func (m *MockUserSvcAPI) SavePermits(ctx context.Context) ApiSavePermitsRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SavePermits", ctx)
	ret0, _ := ret[0].(ApiSavePermitsRequest)
	return ret0
}

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

// SavePermitsExecute mocks base method.
func (m *MockUserSvcAPI) SavePermitsExecute(r ApiSavePermitsRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SavePermitsExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SavePermitsExecute indicates an expected call of SavePermitsExecute.
func (mr *MockUserSvcAPIMockRecorder) SavePermitsExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SavePermitsExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).SavePermitsExecute), r)
}

// SaveSelf mocks base method.
func (m *MockUserSvcAPI) SaveSelf(ctx context.Context) ApiSaveSelfRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveSelf", ctx)
	ret0, _ := ret[0].(ApiSaveSelfRequest)
	return ret0
}

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

// SaveSelfExecute mocks base method.
func (m *MockUserSvcAPI) SaveSelfExecute(r ApiSaveSelfRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveSelfExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SaveSelfExecute indicates an expected call of SaveSelfExecute.
func (mr *MockUserSvcAPIMockRecorder) SaveSelfExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSelfExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).SaveSelfExecute), r)
}

// SaveUser mocks base method.
func (m *MockUserSvcAPI) SaveUser(ctx context.Context, userId string) ApiSaveUserRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveUser", ctx, userId)
	ret0, _ := ret[0].(ApiSaveUserRequest)
	return ret0
}

// SaveUser indicates an expected call of SaveUser.
func (mr *MockUserSvcAPIMockRecorder) SaveUser(ctx, userId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveUser", reflect.TypeOf((*MockUserSvcAPI)(nil).SaveUser), ctx, userId)
}

// SaveUserExecute mocks base method.
func (m *MockUserSvcAPI) SaveUserExecute(r ApiSaveUserRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveUserExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SaveUserExecute indicates an expected call of SaveUserExecute.
func (mr *MockUserSvcAPIMockRecorder) SaveUserExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveUserExecute", reflect.TypeOf((*MockUserSvcAPI)(nil).SaveUserExecute), r)
}
