// Copyright (c) 2023 Gitpod GmbH. All rights reserved.
// Licensed under the GNU Affero General Public License (AGPL).
// See License.AGPL.txt in the project root for license information.

// Code generated by MockGen. DO NOT EDIT.
// Source: gitpod-service.go

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

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

	gomock "github.com/golang/mock/gomock"
)

// MockAPIInterface is a mock of APIInterface interface.
type MockAPIInterface struct {
	ctrl     *gomock.Controller
	recorder *MockAPIInterfaceMockRecorder
}

// MockAPIInterfaceMockRecorder is the mock recorder for MockAPIInterface.
type MockAPIInterfaceMockRecorder struct {
	mock *MockAPIInterface
}

// NewMockAPIInterface creates a new mock instance.
func NewMockAPIInterface(ctrl *gomock.Controller) *MockAPIInterface {
	mock := &MockAPIInterface{ctrl: ctrl}
	mock.recorder = &MockAPIInterfaceMockRecorder{mock}
	return mock
}

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

// AddSSHPublicKey mocks base method.
func (m *MockAPIInterface) AddSSHPublicKey(ctx context.Context, value *SSHPublicKeyValue) (*UserSSHPublicKeyValue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSSHPublicKey", ctx, value)
	ret0, _ := ret[0].(*UserSSHPublicKeyValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddSSHPublicKey indicates an expected call of AddSSHPublicKey.
func (mr *MockAPIInterfaceMockRecorder) AddSSHPublicKey(ctx, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSSHPublicKey", reflect.TypeOf((*MockAPIInterface)(nil).AddSSHPublicKey), ctx, value)
}

// AdminBlockUser mocks base method.
func (m *MockAPIInterface) AdminBlockUser(ctx context.Context, req *AdminBlockUserRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AdminBlockUser", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// AdminBlockUser indicates an expected call of AdminBlockUser.
func (mr *MockAPIInterfaceMockRecorder) AdminBlockUser(ctx, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminBlockUser", reflect.TypeOf((*MockAPIInterface)(nil).AdminBlockUser), ctx, req)
}

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

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

// ClosePort mocks base method.
func (m *MockAPIInterface) ClosePort(ctx context.Context, workspaceID string, port float32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClosePort", ctx, workspaceID, port)
	ret0, _ := ret[0].(error)
	return ret0
}

// ClosePort indicates an expected call of ClosePort.
func (mr *MockAPIInterfaceMockRecorder) ClosePort(ctx, workspaceID, port interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosePort", reflect.TypeOf((*MockAPIInterface)(nil).ClosePort), ctx, workspaceID, port)
}

// ControlAdmission mocks base method.
func (m *MockAPIInterface) ControlAdmission(ctx context.Context, id string, level *AdmissionLevel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ControlAdmission", ctx, id, level)
	ret0, _ := ret[0].(error)
	return ret0
}

// ControlAdmission indicates an expected call of ControlAdmission.
func (mr *MockAPIInterfaceMockRecorder) ControlAdmission(ctx, id, level interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControlAdmission", reflect.TypeOf((*MockAPIInterface)(nil).ControlAdmission), ctx, id, level)
}

// CreateProject mocks base method.
func (m *MockAPIInterface) CreateProject(ctx context.Context, options *CreateProjectOptions) (*Project, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProject", ctx, options)
	ret0, _ := ret[0].(*Project)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateProject indicates an expected call of CreateProject.
func (mr *MockAPIInterfaceMockRecorder) CreateProject(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProject", reflect.TypeOf((*MockAPIInterface)(nil).CreateProject), ctx, options)
}

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

// CreateTeam indicates an expected call of CreateTeam.
func (mr *MockAPIInterfaceMockRecorder) CreateTeam(ctx, teamName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTeam", reflect.TypeOf((*MockAPIInterface)(nil).CreateTeam), ctx, teamName)
}

// CreateWorkspace mocks base method.
func (m *MockAPIInterface) CreateWorkspace(ctx context.Context, options *CreateWorkspaceOptions) (*WorkspaceCreationResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkspace", ctx, options)
	ret0, _ := ret[0].(*WorkspaceCreationResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateWorkspace indicates an expected call of CreateWorkspace.
func (mr *MockAPIInterfaceMockRecorder) CreateWorkspace(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).CreateWorkspace), ctx, options)
}

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

// DeleteAccount indicates an expected call of DeleteAccount.
func (mr *MockAPIInterfaceMockRecorder) DeleteAccount(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccount", reflect.TypeOf((*MockAPIInterface)(nil).DeleteAccount), ctx)
}

// DeleteEnvVar mocks base method.
func (m *MockAPIInterface) DeleteEnvVar(ctx context.Context, variable *UserEnvVarValue) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEnvVar", ctx, variable)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteEnvVar indicates an expected call of DeleteEnvVar.
func (mr *MockAPIInterfaceMockRecorder) DeleteEnvVar(ctx, variable interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEnvVar", reflect.TypeOf((*MockAPIInterface)(nil).DeleteEnvVar), ctx, variable)
}

// DeleteGitpodToken mocks base method.
func (m *MockAPIInterface) DeleteGitpodToken(ctx context.Context, tokenHash string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGitpodToken", ctx, tokenHash)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteGitpodToken indicates an expected call of DeleteGitpodToken.
func (mr *MockAPIInterfaceMockRecorder) DeleteGitpodToken(ctx, tokenHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGitpodToken", reflect.TypeOf((*MockAPIInterface)(nil).DeleteGitpodToken), ctx, tokenHash)
}

// DeleteOwnAuthProvider mocks base method.
func (m *MockAPIInterface) DeleteOwnAuthProvider(ctx context.Context, params *DeleteOwnAuthProviderParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOwnAuthProvider", ctx, params)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOwnAuthProvider indicates an expected call of DeleteOwnAuthProvider.
func (mr *MockAPIInterfaceMockRecorder) DeleteOwnAuthProvider(ctx, params interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOwnAuthProvider", reflect.TypeOf((*MockAPIInterface)(nil).DeleteOwnAuthProvider), ctx, params)
}

// DeleteProject mocks base method.
func (m *MockAPIInterface) DeleteProject(ctx context.Context, projectID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProject", ctx, projectID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteProject indicates an expected call of DeleteProject.
func (mr *MockAPIInterfaceMockRecorder) DeleteProject(ctx, projectID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProject", reflect.TypeOf((*MockAPIInterface)(nil).DeleteProject), ctx, projectID)
}

// DeleteSSHPublicKey mocks base method.
func (m *MockAPIInterface) DeleteSSHPublicKey(ctx context.Context, id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSSHPublicKey", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSSHPublicKey indicates an expected call of DeleteSSHPublicKey.
func (mr *MockAPIInterfaceMockRecorder) DeleteSSHPublicKey(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSSHPublicKey", reflect.TypeOf((*MockAPIInterface)(nil).DeleteSSHPublicKey), ctx, id)
}

// DeleteTeam mocks base method.
func (m *MockAPIInterface) DeleteTeam(ctx context.Context, teamID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTeam", ctx, teamID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTeam indicates an expected call of DeleteTeam.
func (mr *MockAPIInterfaceMockRecorder) DeleteTeam(ctx, teamID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTeam", reflect.TypeOf((*MockAPIInterface)(nil).DeleteTeam), ctx, teamID)
}

// DeleteWorkspace mocks base method.
func (m *MockAPIInterface) DeleteWorkspace(ctx context.Context, id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkspace", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWorkspace indicates an expected call of DeleteWorkspace.
func (mr *MockAPIInterfaceMockRecorder) DeleteWorkspace(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).DeleteWorkspace), ctx, id)
}

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

// GenerateNewGitpodToken indicates an expected call of GenerateNewGitpodToken.
func (mr *MockAPIInterfaceMockRecorder) GenerateNewGitpodToken(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateNewGitpodToken", reflect.TypeOf((*MockAPIInterface)(nil).GenerateNewGitpodToken), ctx, options)
}

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

// GetAuthProviders indicates an expected call of GetAuthProviders.
func (mr *MockAPIInterfaceMockRecorder) GetAuthProviders(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthProviders", reflect.TypeOf((*MockAPIInterface)(nil).GetAuthProviders), ctx)
}

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

// GetClientRegion indicates an expected call of GetClientRegion.
func (mr *MockAPIInterfaceMockRecorder) GetClientRegion(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientRegion", reflect.TypeOf((*MockAPIInterface)(nil).GetClientRegion), ctx)
}

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

// GetConfiguration indicates an expected call of GetConfiguration.
func (mr *MockAPIInterfaceMockRecorder) GetConfiguration(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfiguration", reflect.TypeOf((*MockAPIInterface)(nil).GetConfiguration), ctx)
}

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

// GetContentBlobDownloadURL indicates an expected call of GetContentBlobDownloadURL.
func (mr *MockAPIInterfaceMockRecorder) GetContentBlobDownloadURL(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContentBlobDownloadURL", reflect.TypeOf((*MockAPIInterface)(nil).GetContentBlobDownloadURL), ctx, name)
}

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

// GetContentBlobUploadURL indicates an expected call of GetContentBlobUploadURL.
func (mr *MockAPIInterfaceMockRecorder) GetContentBlobUploadURL(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContentBlobUploadURL", reflect.TypeOf((*MockAPIInterface)(nil).GetContentBlobUploadURL), ctx, name)
}

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

// GetEnvVars indicates an expected call of GetEnvVars.
func (mr *MockAPIInterfaceMockRecorder) GetEnvVars(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEnvVars", reflect.TypeOf((*MockAPIInterface)(nil).GetEnvVars), ctx)
}

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

// GetFeaturedRepositories indicates an expected call of GetFeaturedRepositories.
func (mr *MockAPIInterfaceMockRecorder) GetFeaturedRepositories(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeaturedRepositories", reflect.TypeOf((*MockAPIInterface)(nil).GetFeaturedRepositories), ctx)
}

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

// GetGenericInvite indicates an expected call of GetGenericInvite.
func (mr *MockAPIInterfaceMockRecorder) GetGenericInvite(ctx, teamID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGenericInvite", reflect.TypeOf((*MockAPIInterface)(nil).GetGenericInvite), ctx, teamID)
}

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

// GetGitpodTokenScopes indicates an expected call of GetGitpodTokenScopes.
func (mr *MockAPIInterfaceMockRecorder) GetGitpodTokenScopes(ctx, tokenHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGitpodTokenScopes", reflect.TypeOf((*MockAPIInterface)(nil).GetGitpodTokenScopes), ctx, tokenHash)
}

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

// GetGitpodTokens indicates an expected call of GetGitpodTokens.
func (mr *MockAPIInterfaceMockRecorder) GetGitpodTokens(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGitpodTokens", reflect.TypeOf((*MockAPIInterface)(nil).GetGitpodTokens), ctx)
}

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

// GetIDToken indicates an expected call of GetIDToken.
func (mr *MockAPIInterfaceMockRecorder) GetIDToken(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIDToken", reflect.TypeOf((*MockAPIInterface)(nil).GetIDToken), ctx)
}

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

// GetLoggedInUser indicates an expected call of GetLoggedInUser.
func (mr *MockAPIInterfaceMockRecorder) GetLoggedInUser(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoggedInUser", reflect.TypeOf((*MockAPIInterface)(nil).GetLoggedInUser), ctx)
}

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

// GetOpenPorts indicates an expected call of GetOpenPorts.
func (mr *MockAPIInterfaceMockRecorder) GetOpenPorts(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenPorts", reflect.TypeOf((*MockAPIInterface)(nil).GetOpenPorts), ctx, workspaceID)
}

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

// GetOwnAuthProviders indicates an expected call of GetOwnAuthProviders.
func (mr *MockAPIInterfaceMockRecorder) GetOwnAuthProviders(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOwnAuthProviders", reflect.TypeOf((*MockAPIInterface)(nil).GetOwnAuthProviders), ctx)
}

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

// GetOwnerToken indicates an expected call of GetOwnerToken.
func (mr *MockAPIInterfaceMockRecorder) GetOwnerToken(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOwnerToken", reflect.TypeOf((*MockAPIInterface)(nil).GetOwnerToken), ctx, workspaceID)
}

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

// GetPortAuthenticationToken indicates an expected call of GetPortAuthenticationToken.
func (mr *MockAPIInterfaceMockRecorder) GetPortAuthenticationToken(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPortAuthenticationToken", reflect.TypeOf((*MockAPIInterface)(nil).GetPortAuthenticationToken), ctx, workspaceID)
}

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

// GetSSHPublicKeys indicates an expected call of GetSSHPublicKeys.
func (mr *MockAPIInterfaceMockRecorder) GetSSHPublicKeys(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSSHPublicKeys", reflect.TypeOf((*MockAPIInterface)(nil).GetSSHPublicKeys), ctx)
}

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

// GetSnapshots indicates an expected call of GetSnapshots.
func (mr *MockAPIInterfaceMockRecorder) GetSnapshots(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshots", reflect.TypeOf((*MockAPIInterface)(nil).GetSnapshots), ctx, workspaceID)
}

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

// GetSupportedWorkspaceClasses indicates an expected call of GetSupportedWorkspaceClasses.
func (mr *MockAPIInterfaceMockRecorder) GetSupportedWorkspaceClasses(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupportedWorkspaceClasses", reflect.TypeOf((*MockAPIInterface)(nil).GetSupportedWorkspaceClasses), ctx)
}

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

// GetTeam indicates an expected call of GetTeam.
func (mr *MockAPIInterfaceMockRecorder) GetTeam(ctx, teamID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeam", reflect.TypeOf((*MockAPIInterface)(nil).GetTeam), ctx, teamID)
}

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

// GetTeamMembers indicates an expected call of GetTeamMembers.
func (mr *MockAPIInterfaceMockRecorder) GetTeamMembers(ctx, teamID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamMembers", reflect.TypeOf((*MockAPIInterface)(nil).GetTeamMembers), ctx, teamID)
}

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

// GetTeamProjects indicates an expected call of GetTeamProjects.
func (mr *MockAPIInterfaceMockRecorder) GetTeamProjects(ctx, teamID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamProjects", reflect.TypeOf((*MockAPIInterface)(nil).GetTeamProjects), ctx, teamID)
}

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

// GetTeams indicates an expected call of GetTeams.
func (mr *MockAPIInterfaceMockRecorder) GetTeams(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeams", reflect.TypeOf((*MockAPIInterface)(nil).GetTeams), ctx)
}

// GetToken mocks base method.
func (m *MockAPIInterface) GetToken(ctx context.Context, query *GetTokenSearchOptions) (*Token, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetToken", ctx, query)
	ret0, _ := ret[0].(*Token)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetToken indicates an expected call of GetToken.
func (mr *MockAPIInterfaceMockRecorder) GetToken(ctx, query interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetToken", reflect.TypeOf((*MockAPIInterface)(nil).GetToken), ctx, query)
}

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

// GetUserProjects indicates an expected call of GetUserProjects.
func (mr *MockAPIInterfaceMockRecorder) GetUserProjects(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserProjects", reflect.TypeOf((*MockAPIInterface)(nil).GetUserProjects), ctx)
}

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

// GetUserStorageResource indicates an expected call of GetUserStorageResource.
func (mr *MockAPIInterfaceMockRecorder) GetUserStorageResource(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserStorageResource", reflect.TypeOf((*MockAPIInterface)(nil).GetUserStorageResource), ctx, options)
}

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

// GetWorkspace indicates an expected call of GetWorkspace.
func (mr *MockAPIInterfaceMockRecorder) GetWorkspace(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspace), ctx, id)
}

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

// GetWorkspaceEnvVars indicates an expected call of GetWorkspaceEnvVars.
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaceEnvVars(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceEnvVars", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaceEnvVars), ctx, workspaceID)
}

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

// GetWorkspaceOwner indicates an expected call of GetWorkspaceOwner.
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaceOwner(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceOwner", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaceOwner), ctx, workspaceID)
}

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

// GetWorkspaceTimeout indicates an expected call of GetWorkspaceTimeout.
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaceTimeout(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceTimeout", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaceTimeout), ctx, workspaceID)
}

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

// GetWorkspaceUsers indicates an expected call of GetWorkspaceUsers.
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaceUsers(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceUsers", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaceUsers), ctx, workspaceID)
}

// GetWorkspaces mocks base method.
func (m *MockAPIInterface) GetWorkspaces(ctx context.Context, options *GetWorkspacesOptions) ([]*WorkspaceInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaces", ctx, options)
	ret0, _ := ret[0].([]*WorkspaceInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaces indicates an expected call of GetWorkspaces.
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaces(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaces", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaces), ctx, options)
}

// GuessGitTokenScopes mocks base method.
func (m *MockAPIInterface) GuessGitTokenScopes(ctx context.Context, params *GuessGitTokenScopesParams) (*GuessedGitTokenScopes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GuessGitTokenScopes", ctx, params)
	ret0, _ := ret[0].(*GuessedGitTokenScopes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GuessGitTokenScopes indicates an expected call of GuessGitTokenScopes.
func (mr *MockAPIInterfaceMockRecorder) GuessGitTokenScopes(ctx, params interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GuessGitTokenScopes", reflect.TypeOf((*MockAPIInterface)(nil).GuessGitTokenScopes), ctx, params)
}

// HasPermission mocks base method.
func (m *MockAPIInterface) HasPermission(ctx context.Context, permission *PermissionName) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasPermission", ctx, permission)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// HasSSHPublicKey indicates an expected call of HasSSHPublicKey.
func (mr *MockAPIInterfaceMockRecorder) HasSSHPublicKey(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasSSHPublicKey", reflect.TypeOf((*MockAPIInterface)(nil).HasSSHPublicKey), ctx)
}

// InstanceUpdates mocks base method.
func (m *MockAPIInterface) InstanceUpdates(ctx context.Context, instanceID string) (<-chan *WorkspaceInstance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstanceUpdates", ctx, instanceID)
	ret0, _ := ret[0].(<-chan *WorkspaceInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InstanceUpdates indicates an expected call of InstanceUpdates.
func (mr *MockAPIInterfaceMockRecorder) InstanceUpdates(ctx, instanceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceUpdates", reflect.TypeOf((*MockAPIInterface)(nil).InstanceUpdates), ctx, instanceID)
}

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

// IsPrebuildDone indicates an expected call of IsPrebuildDone.
func (mr *MockAPIInterfaceMockRecorder) IsPrebuildDone(ctx, pwsid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPrebuildDone", reflect.TypeOf((*MockAPIInterface)(nil).IsPrebuildDone), ctx, pwsid)
}

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

// IsWorkspaceOwner indicates an expected call of IsWorkspaceOwner.
func (mr *MockAPIInterfaceMockRecorder) IsWorkspaceOwner(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkspaceOwner", reflect.TypeOf((*MockAPIInterface)(nil).IsWorkspaceOwner), ctx, workspaceID)
}

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

// JoinTeam indicates an expected call of JoinTeam.
func (mr *MockAPIInterfaceMockRecorder) JoinTeam(ctx, teamID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinTeam", reflect.TypeOf((*MockAPIInterface)(nil).JoinTeam), ctx, teamID)
}

// OpenPort mocks base method.
func (m *MockAPIInterface) OpenPort(ctx context.Context, workspaceID string, port *WorkspaceInstancePort) (*WorkspaceInstancePort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenPort", ctx, workspaceID, port)
	ret0, _ := ret[0].(*WorkspaceInstancePort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenPort indicates an expected call of OpenPort.
func (mr *MockAPIInterfaceMockRecorder) OpenPort(ctx, workspaceID, port interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenPort", reflect.TypeOf((*MockAPIInterface)(nil).OpenPort), ctx, workspaceID, port)
}

// RegisterGithubApp mocks base method.
func (m *MockAPIInterface) RegisterGithubApp(ctx context.Context, installationID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterGithubApp", ctx, installationID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterGithubApp indicates an expected call of RegisterGithubApp.
func (mr *MockAPIInterfaceMockRecorder) RegisterGithubApp(ctx, installationID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterGithubApp", reflect.TypeOf((*MockAPIInterface)(nil).RegisterGithubApp), ctx, installationID)
}

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

// RemoveTeamMember indicates an expected call of RemoveTeamMember.
func (mr *MockAPIInterfaceMockRecorder) RemoveTeamMember(ctx, teamID, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTeamMember", reflect.TypeOf((*MockAPIInterface)(nil).RemoveTeamMember), ctx, teamID, userID)
}

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

// ResetGenericInvite indicates an expected call of ResetGenericInvite.
func (mr *MockAPIInterfaceMockRecorder) ResetGenericInvite(ctx, teamID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetGenericInvite", reflect.TypeOf((*MockAPIInterface)(nil).ResetGenericInvite), ctx, teamID)
}

// SendHeartBeat mocks base method.
func (m *MockAPIInterface) SendHeartBeat(ctx context.Context, options *SendHeartBeatOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeartBeat", ctx, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeartBeat indicates an expected call of SendHeartBeat.
func (mr *MockAPIInterfaceMockRecorder) SendHeartBeat(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeartBeat", reflect.TypeOf((*MockAPIInterface)(nil).SendHeartBeat), ctx, options)
}

// SetEnvVar mocks base method.
func (m *MockAPIInterface) SetEnvVar(ctx context.Context, variable *UserEnvVarValue) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEnvVar", ctx, variable)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetEnvVar indicates an expected call of SetEnvVar.
func (mr *MockAPIInterfaceMockRecorder) SetEnvVar(ctx, variable interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnvVar", reflect.TypeOf((*MockAPIInterface)(nil).SetEnvVar), ctx, variable)
}

// SetTeamMemberRole mocks base method.
func (m *MockAPIInterface) SetTeamMemberRole(ctx context.Context, teamID, userID string, role TeamMemberRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTeamMemberRole", ctx, teamID, userID, role)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetTeamMemberRole indicates an expected call of SetTeamMemberRole.
func (mr *MockAPIInterfaceMockRecorder) SetTeamMemberRole(ctx, teamID, userID, role interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTeamMemberRole", reflect.TypeOf((*MockAPIInterface)(nil).SetTeamMemberRole), ctx, teamID, userID, role)
}

// SetWorkspaceDescription mocks base method.
func (m *MockAPIInterface) SetWorkspaceDescription(ctx context.Context, id, desc string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetWorkspaceDescription", ctx, id, desc)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetWorkspaceDescription indicates an expected call of SetWorkspaceDescription.
func (mr *MockAPIInterfaceMockRecorder) SetWorkspaceDescription(ctx, id, desc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkspaceDescription", reflect.TypeOf((*MockAPIInterface)(nil).SetWorkspaceDescription), ctx, id, desc)
}

// SetWorkspaceTimeout mocks base method.
func (m *MockAPIInterface) SetWorkspaceTimeout(ctx context.Context, workspaceID string, duration time.Duration) (*SetWorkspaceTimeoutResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetWorkspaceTimeout", ctx, workspaceID, duration)
	ret0, _ := ret[0].(*SetWorkspaceTimeoutResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetWorkspaceTimeout indicates an expected call of SetWorkspaceTimeout.
func (mr *MockAPIInterfaceMockRecorder) SetWorkspaceTimeout(ctx, workspaceID, duration interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkspaceTimeout", reflect.TypeOf((*MockAPIInterface)(nil).SetWorkspaceTimeout), ctx, workspaceID, duration)
}

// StartWorkspace mocks base method.
func (m *MockAPIInterface) StartWorkspace(ctx context.Context, id string, options *StartWorkspaceOptions) (*StartWorkspaceResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartWorkspace", ctx, id, options)
	ret0, _ := ret[0].(*StartWorkspaceResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartWorkspace indicates an expected call of StartWorkspace.
func (mr *MockAPIInterfaceMockRecorder) StartWorkspace(ctx, id, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).StartWorkspace), ctx, id, options)
}

// StopWorkspace mocks base method.
func (m *MockAPIInterface) StopWorkspace(ctx context.Context, id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopWorkspace", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// StopWorkspace indicates an expected call of StopWorkspace.
func (mr *MockAPIInterfaceMockRecorder) StopWorkspace(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).StopWorkspace), ctx, id)
}

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

// TakeSnapshot indicates an expected call of TakeSnapshot.
func (mr *MockAPIInterfaceMockRecorder) TakeSnapshot(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TakeSnapshot", reflect.TypeOf((*MockAPIInterface)(nil).TakeSnapshot), ctx, options)
}

// TrackEvent mocks base method.
func (m *MockAPIInterface) TrackEvent(ctx context.Context, event *RemoteTrackMessage) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TrackEvent", ctx, event)
	ret0, _ := ret[0].(error)
	return ret0
}

// TrackEvent indicates an expected call of TrackEvent.
func (mr *MockAPIInterfaceMockRecorder) TrackEvent(ctx, event interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrackEvent", reflect.TypeOf((*MockAPIInterface)(nil).TrackEvent), ctx, event)
}

// UpdateLoggedInUser mocks base method.
func (m *MockAPIInterface) UpdateLoggedInUser(ctx context.Context, user *User) (*User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLoggedInUser", ctx, user)
	ret0, _ := ret[0].(*User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLoggedInUser indicates an expected call of UpdateLoggedInUser.
func (mr *MockAPIInterfaceMockRecorder) UpdateLoggedInUser(ctx, user interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLoggedInUser", reflect.TypeOf((*MockAPIInterface)(nil).UpdateLoggedInUser), ctx, user)
}

// UpdateOwnAuthProvider mocks base method.
func (m *MockAPIInterface) UpdateOwnAuthProvider(ctx context.Context, params *UpdateOwnAuthProviderParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOwnAuthProvider", ctx, params)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateOwnAuthProvider indicates an expected call of UpdateOwnAuthProvider.
func (mr *MockAPIInterfaceMockRecorder) UpdateOwnAuthProvider(ctx, params interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOwnAuthProvider", reflect.TypeOf((*MockAPIInterface)(nil).UpdateOwnAuthProvider), ctx, params)
}

// UpdateUserStorageResource mocks base method.
func (m *MockAPIInterface) UpdateUserStorageResource(ctx context.Context, options *UpdateUserStorageResourceOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserStorageResource", ctx, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateUserStorageResource indicates an expected call of UpdateUserStorageResource.
func (mr *MockAPIInterfaceMockRecorder) UpdateUserStorageResource(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserStorageResource", reflect.TypeOf((*MockAPIInterface)(nil).UpdateUserStorageResource), ctx, options)
}

// UpdateWorkspaceUserPin mocks base method.
func (m *MockAPIInterface) UpdateWorkspaceUserPin(ctx context.Context, id string, action *PinAction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceUserPin", ctx, id, action)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceUserPin indicates an expected call of UpdateWorkspaceUserPin.
func (mr *MockAPIInterfaceMockRecorder) UpdateWorkspaceUserPin(ctx, id, action interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceUserPin", reflect.TypeOf((*MockAPIInterface)(nil).UpdateWorkspaceUserPin), ctx, id, action)
}

// WaitForSnapshot mocks base method.
func (m *MockAPIInterface) WaitForSnapshot(ctx context.Context, snapshotId string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForSnapshot", ctx, snapshotId)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitForSnapshot indicates an expected call of WaitForSnapshot.
func (mr *MockAPIInterfaceMockRecorder) WaitForSnapshot(ctx, snapshotId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForSnapshot", reflect.TypeOf((*MockAPIInterface)(nil).WaitForSnapshot), ctx, snapshotId)
}

// WatchWorkspaceImageBuildLogs mocks base method.
func (m *MockAPIInterface) WatchWorkspaceImageBuildLogs(ctx context.Context, workspaceID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchWorkspaceImageBuildLogs", ctx, workspaceID)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchWorkspaceImageBuildLogs indicates an expected call of WatchWorkspaceImageBuildLogs.
func (mr *MockAPIInterfaceMockRecorder) WatchWorkspaceImageBuildLogs(ctx, workspaceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchWorkspaceImageBuildLogs", reflect.TypeOf((*MockAPIInterface)(nil).WatchWorkspaceImageBuildLogs), ctx, workspaceID)
}