github.com/haalcala/mattermost-server-change-repo@v0.0.0-20210713015153-16753fbeee5f/plugin/plugintest/api.go (about)

     1  // Code generated by mockery v1.0.0. DO NOT EDIT.
     2  
     3  // Regenerate this file using `make plugin-mocks`.
     4  
     5  package plugintest
     6  
     7  import (
     8  	io "io"
     9  	http "net/http"
    10  
    11  	mock "github.com/stretchr/testify/mock"
    12  
    13  	model "github.com/mattermost/mattermost-server/v5/model"
    14  )
    15  
    16  // API is an autogenerated mock type for the API type
    17  type API struct {
    18  	mock.Mock
    19  }
    20  
    21  // AddChannelMember provides a mock function with given fields: channelId, userId
    22  func (_m *API) AddChannelMember(channelId string, userId string) (*model.ChannelMember, *model.AppError) {
    23  	ret := _m.Called(channelId, userId)
    24  
    25  	var r0 *model.ChannelMember
    26  	if rf, ok := ret.Get(0).(func(string, string) *model.ChannelMember); ok {
    27  		r0 = rf(channelId, userId)
    28  	} else {
    29  		if ret.Get(0) != nil {
    30  			r0 = ret.Get(0).(*model.ChannelMember)
    31  		}
    32  	}
    33  
    34  	var r1 *model.AppError
    35  	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
    36  		r1 = rf(channelId, userId)
    37  	} else {
    38  		if ret.Get(1) != nil {
    39  			r1 = ret.Get(1).(*model.AppError)
    40  		}
    41  	}
    42  
    43  	return r0, r1
    44  }
    45  
    46  // AddReaction provides a mock function with given fields: reaction
    47  func (_m *API) AddReaction(reaction *model.Reaction) (*model.Reaction, *model.AppError) {
    48  	ret := _m.Called(reaction)
    49  
    50  	var r0 *model.Reaction
    51  	if rf, ok := ret.Get(0).(func(*model.Reaction) *model.Reaction); ok {
    52  		r0 = rf(reaction)
    53  	} else {
    54  		if ret.Get(0) != nil {
    55  			r0 = ret.Get(0).(*model.Reaction)
    56  		}
    57  	}
    58  
    59  	var r1 *model.AppError
    60  	if rf, ok := ret.Get(1).(func(*model.Reaction) *model.AppError); ok {
    61  		r1 = rf(reaction)
    62  	} else {
    63  		if ret.Get(1) != nil {
    64  			r1 = ret.Get(1).(*model.AppError)
    65  		}
    66  	}
    67  
    68  	return r0, r1
    69  }
    70  
    71  // AddUserToChannel provides a mock function with given fields: channelId, userId, asUserId
    72  func (_m *API) AddUserToChannel(channelId string, userId string, asUserId string) (*model.ChannelMember, *model.AppError) {
    73  	ret := _m.Called(channelId, userId, asUserId)
    74  
    75  	var r0 *model.ChannelMember
    76  	if rf, ok := ret.Get(0).(func(string, string, string) *model.ChannelMember); ok {
    77  		r0 = rf(channelId, userId, asUserId)
    78  	} else {
    79  		if ret.Get(0) != nil {
    80  			r0 = ret.Get(0).(*model.ChannelMember)
    81  		}
    82  	}
    83  
    84  	var r1 *model.AppError
    85  	if rf, ok := ret.Get(1).(func(string, string, string) *model.AppError); ok {
    86  		r1 = rf(channelId, userId, asUserId)
    87  	} else {
    88  		if ret.Get(1) != nil {
    89  			r1 = ret.Get(1).(*model.AppError)
    90  		}
    91  	}
    92  
    93  	return r0, r1
    94  }
    95  
    96  // CopyFileInfos provides a mock function with given fields: userId, fileIds
    97  func (_m *API) CopyFileInfos(userId string, fileIds []string) ([]string, *model.AppError) {
    98  	ret := _m.Called(userId, fileIds)
    99  
   100  	var r0 []string
   101  	if rf, ok := ret.Get(0).(func(string, []string) []string); ok {
   102  		r0 = rf(userId, fileIds)
   103  	} else {
   104  		if ret.Get(0) != nil {
   105  			r0 = ret.Get(0).([]string)
   106  		}
   107  	}
   108  
   109  	var r1 *model.AppError
   110  	if rf, ok := ret.Get(1).(func(string, []string) *model.AppError); ok {
   111  		r1 = rf(userId, fileIds)
   112  	} else {
   113  		if ret.Get(1) != nil {
   114  			r1 = ret.Get(1).(*model.AppError)
   115  		}
   116  	}
   117  
   118  	return r0, r1
   119  }
   120  
   121  // CreateBot provides a mock function with given fields: bot
   122  func (_m *API) CreateBot(bot *model.Bot) (*model.Bot, *model.AppError) {
   123  	ret := _m.Called(bot)
   124  
   125  	var r0 *model.Bot
   126  	if rf, ok := ret.Get(0).(func(*model.Bot) *model.Bot); ok {
   127  		r0 = rf(bot)
   128  	} else {
   129  		if ret.Get(0) != nil {
   130  			r0 = ret.Get(0).(*model.Bot)
   131  		}
   132  	}
   133  
   134  	var r1 *model.AppError
   135  	if rf, ok := ret.Get(1).(func(*model.Bot) *model.AppError); ok {
   136  		r1 = rf(bot)
   137  	} else {
   138  		if ret.Get(1) != nil {
   139  			r1 = ret.Get(1).(*model.AppError)
   140  		}
   141  	}
   142  
   143  	return r0, r1
   144  }
   145  
   146  // CreateChannel provides a mock function with given fields: channel
   147  func (_m *API) CreateChannel(channel *model.Channel) (*model.Channel, *model.AppError) {
   148  	ret := _m.Called(channel)
   149  
   150  	var r0 *model.Channel
   151  	if rf, ok := ret.Get(0).(func(*model.Channel) *model.Channel); ok {
   152  		r0 = rf(channel)
   153  	} else {
   154  		if ret.Get(0) != nil {
   155  			r0 = ret.Get(0).(*model.Channel)
   156  		}
   157  	}
   158  
   159  	var r1 *model.AppError
   160  	if rf, ok := ret.Get(1).(func(*model.Channel) *model.AppError); ok {
   161  		r1 = rf(channel)
   162  	} else {
   163  		if ret.Get(1) != nil {
   164  			r1 = ret.Get(1).(*model.AppError)
   165  		}
   166  	}
   167  
   168  	return r0, r1
   169  }
   170  
   171  // CreateCommand provides a mock function with given fields: cmd
   172  func (_m *API) CreateCommand(cmd *model.Command) (*model.Command, error) {
   173  	ret := _m.Called(cmd)
   174  
   175  	var r0 *model.Command
   176  	if rf, ok := ret.Get(0).(func(*model.Command) *model.Command); ok {
   177  		r0 = rf(cmd)
   178  	} else {
   179  		if ret.Get(0) != nil {
   180  			r0 = ret.Get(0).(*model.Command)
   181  		}
   182  	}
   183  
   184  	var r1 error
   185  	if rf, ok := ret.Get(1).(func(*model.Command) error); ok {
   186  		r1 = rf(cmd)
   187  	} else {
   188  		r1 = ret.Error(1)
   189  	}
   190  
   191  	return r0, r1
   192  }
   193  
   194  // CreatePost provides a mock function with given fields: post
   195  func (_m *API) CreatePost(post *model.Post) (*model.Post, *model.AppError) {
   196  	ret := _m.Called(post)
   197  
   198  	var r0 *model.Post
   199  	if rf, ok := ret.Get(0).(func(*model.Post) *model.Post); ok {
   200  		r0 = rf(post)
   201  	} else {
   202  		if ret.Get(0) != nil {
   203  			r0 = ret.Get(0).(*model.Post)
   204  		}
   205  	}
   206  
   207  	var r1 *model.AppError
   208  	if rf, ok := ret.Get(1).(func(*model.Post) *model.AppError); ok {
   209  		r1 = rf(post)
   210  	} else {
   211  		if ret.Get(1) != nil {
   212  			r1 = ret.Get(1).(*model.AppError)
   213  		}
   214  	}
   215  
   216  	return r0, r1
   217  }
   218  
   219  // CreateTeam provides a mock function with given fields: team
   220  func (_m *API) CreateTeam(team *model.Team) (*model.Team, *model.AppError) {
   221  	ret := _m.Called(team)
   222  
   223  	var r0 *model.Team
   224  	if rf, ok := ret.Get(0).(func(*model.Team) *model.Team); ok {
   225  		r0 = rf(team)
   226  	} else {
   227  		if ret.Get(0) != nil {
   228  			r0 = ret.Get(0).(*model.Team)
   229  		}
   230  	}
   231  
   232  	var r1 *model.AppError
   233  	if rf, ok := ret.Get(1).(func(*model.Team) *model.AppError); ok {
   234  		r1 = rf(team)
   235  	} else {
   236  		if ret.Get(1) != nil {
   237  			r1 = ret.Get(1).(*model.AppError)
   238  		}
   239  	}
   240  
   241  	return r0, r1
   242  }
   243  
   244  // CreateTeamMember provides a mock function with given fields: teamId, userId
   245  func (_m *API) CreateTeamMember(teamId string, userId string) (*model.TeamMember, *model.AppError) {
   246  	ret := _m.Called(teamId, userId)
   247  
   248  	var r0 *model.TeamMember
   249  	if rf, ok := ret.Get(0).(func(string, string) *model.TeamMember); ok {
   250  		r0 = rf(teamId, userId)
   251  	} else {
   252  		if ret.Get(0) != nil {
   253  			r0 = ret.Get(0).(*model.TeamMember)
   254  		}
   255  	}
   256  
   257  	var r1 *model.AppError
   258  	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
   259  		r1 = rf(teamId, userId)
   260  	} else {
   261  		if ret.Get(1) != nil {
   262  			r1 = ret.Get(1).(*model.AppError)
   263  		}
   264  	}
   265  
   266  	return r0, r1
   267  }
   268  
   269  // CreateTeamMembers provides a mock function with given fields: teamId, userIds, requestorId
   270  func (_m *API) CreateTeamMembers(teamId string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError) {
   271  	ret := _m.Called(teamId, userIds, requestorId)
   272  
   273  	var r0 []*model.TeamMember
   274  	if rf, ok := ret.Get(0).(func(string, []string, string) []*model.TeamMember); ok {
   275  		r0 = rf(teamId, userIds, requestorId)
   276  	} else {
   277  		if ret.Get(0) != nil {
   278  			r0 = ret.Get(0).([]*model.TeamMember)
   279  		}
   280  	}
   281  
   282  	var r1 *model.AppError
   283  	if rf, ok := ret.Get(1).(func(string, []string, string) *model.AppError); ok {
   284  		r1 = rf(teamId, userIds, requestorId)
   285  	} else {
   286  		if ret.Get(1) != nil {
   287  			r1 = ret.Get(1).(*model.AppError)
   288  		}
   289  	}
   290  
   291  	return r0, r1
   292  }
   293  
   294  // CreateTeamMembersGracefully provides a mock function with given fields: teamId, userIds, requestorId
   295  func (_m *API) CreateTeamMembersGracefully(teamId string, userIds []string, requestorId string) ([]*model.TeamMemberWithError, *model.AppError) {
   296  	ret := _m.Called(teamId, userIds, requestorId)
   297  
   298  	var r0 []*model.TeamMemberWithError
   299  	if rf, ok := ret.Get(0).(func(string, []string, string) []*model.TeamMemberWithError); ok {
   300  		r0 = rf(teamId, userIds, requestorId)
   301  	} else {
   302  		if ret.Get(0) != nil {
   303  			r0 = ret.Get(0).([]*model.TeamMemberWithError)
   304  		}
   305  	}
   306  
   307  	var r1 *model.AppError
   308  	if rf, ok := ret.Get(1).(func(string, []string, string) *model.AppError); ok {
   309  		r1 = rf(teamId, userIds, requestorId)
   310  	} else {
   311  		if ret.Get(1) != nil {
   312  			r1 = ret.Get(1).(*model.AppError)
   313  		}
   314  	}
   315  
   316  	return r0, r1
   317  }
   318  
   319  // CreateUser provides a mock function with given fields: user
   320  func (_m *API) CreateUser(user *model.User) (*model.User, *model.AppError) {
   321  	ret := _m.Called(user)
   322  
   323  	var r0 *model.User
   324  	if rf, ok := ret.Get(0).(func(*model.User) *model.User); ok {
   325  		r0 = rf(user)
   326  	} else {
   327  		if ret.Get(0) != nil {
   328  			r0 = ret.Get(0).(*model.User)
   329  		}
   330  	}
   331  
   332  	var r1 *model.AppError
   333  	if rf, ok := ret.Get(1).(func(*model.User) *model.AppError); ok {
   334  		r1 = rf(user)
   335  	} else {
   336  		if ret.Get(1) != nil {
   337  			r1 = ret.Get(1).(*model.AppError)
   338  		}
   339  	}
   340  
   341  	return r0, r1
   342  }
   343  
   344  // DeleteBotIconImage provides a mock function with given fields: botUserId
   345  func (_m *API) DeleteBotIconImage(botUserId string) *model.AppError {
   346  	ret := _m.Called(botUserId)
   347  
   348  	var r0 *model.AppError
   349  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
   350  		r0 = rf(botUserId)
   351  	} else {
   352  		if ret.Get(0) != nil {
   353  			r0 = ret.Get(0).(*model.AppError)
   354  		}
   355  	}
   356  
   357  	return r0
   358  }
   359  
   360  // DeleteChannel provides a mock function with given fields: channelId
   361  func (_m *API) DeleteChannel(channelId string) *model.AppError {
   362  	ret := _m.Called(channelId)
   363  
   364  	var r0 *model.AppError
   365  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
   366  		r0 = rf(channelId)
   367  	} else {
   368  		if ret.Get(0) != nil {
   369  			r0 = ret.Get(0).(*model.AppError)
   370  		}
   371  	}
   372  
   373  	return r0
   374  }
   375  
   376  // DeleteChannelMember provides a mock function with given fields: channelId, userId
   377  func (_m *API) DeleteChannelMember(channelId string, userId string) *model.AppError {
   378  	ret := _m.Called(channelId, userId)
   379  
   380  	var r0 *model.AppError
   381  	if rf, ok := ret.Get(0).(func(string, string) *model.AppError); ok {
   382  		r0 = rf(channelId, userId)
   383  	} else {
   384  		if ret.Get(0) != nil {
   385  			r0 = ret.Get(0).(*model.AppError)
   386  		}
   387  	}
   388  
   389  	return r0
   390  }
   391  
   392  // DeleteCommand provides a mock function with given fields: commandID
   393  func (_m *API) DeleteCommand(commandID string) error {
   394  	ret := _m.Called(commandID)
   395  
   396  	var r0 error
   397  	if rf, ok := ret.Get(0).(func(string) error); ok {
   398  		r0 = rf(commandID)
   399  	} else {
   400  		r0 = ret.Error(0)
   401  	}
   402  
   403  	return r0
   404  }
   405  
   406  // DeleteEphemeralPost provides a mock function with given fields: userId, postId
   407  func (_m *API) DeleteEphemeralPost(userId string, postId string) {
   408  	_m.Called(userId, postId)
   409  }
   410  
   411  // DeletePost provides a mock function with given fields: postId
   412  func (_m *API) DeletePost(postId string) *model.AppError {
   413  	ret := _m.Called(postId)
   414  
   415  	var r0 *model.AppError
   416  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
   417  		r0 = rf(postId)
   418  	} else {
   419  		if ret.Get(0) != nil {
   420  			r0 = ret.Get(0).(*model.AppError)
   421  		}
   422  	}
   423  
   424  	return r0
   425  }
   426  
   427  // DeletePreferencesForUser provides a mock function with given fields: userId, preferences
   428  func (_m *API) DeletePreferencesForUser(userId string, preferences []model.Preference) *model.AppError {
   429  	ret := _m.Called(userId, preferences)
   430  
   431  	var r0 *model.AppError
   432  	if rf, ok := ret.Get(0).(func(string, []model.Preference) *model.AppError); ok {
   433  		r0 = rf(userId, preferences)
   434  	} else {
   435  		if ret.Get(0) != nil {
   436  			r0 = ret.Get(0).(*model.AppError)
   437  		}
   438  	}
   439  
   440  	return r0
   441  }
   442  
   443  // DeleteTeam provides a mock function with given fields: teamId
   444  func (_m *API) DeleteTeam(teamId string) *model.AppError {
   445  	ret := _m.Called(teamId)
   446  
   447  	var r0 *model.AppError
   448  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
   449  		r0 = rf(teamId)
   450  	} else {
   451  		if ret.Get(0) != nil {
   452  			r0 = ret.Get(0).(*model.AppError)
   453  		}
   454  	}
   455  
   456  	return r0
   457  }
   458  
   459  // DeleteTeamMember provides a mock function with given fields: teamId, userId, requestorId
   460  func (_m *API) DeleteTeamMember(teamId string, userId string, requestorId string) *model.AppError {
   461  	ret := _m.Called(teamId, userId, requestorId)
   462  
   463  	var r0 *model.AppError
   464  	if rf, ok := ret.Get(0).(func(string, string, string) *model.AppError); ok {
   465  		r0 = rf(teamId, userId, requestorId)
   466  	} else {
   467  		if ret.Get(0) != nil {
   468  			r0 = ret.Get(0).(*model.AppError)
   469  		}
   470  	}
   471  
   472  	return r0
   473  }
   474  
   475  // DeleteUser provides a mock function with given fields: userId
   476  func (_m *API) DeleteUser(userId string) *model.AppError {
   477  	ret := _m.Called(userId)
   478  
   479  	var r0 *model.AppError
   480  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
   481  		r0 = rf(userId)
   482  	} else {
   483  		if ret.Get(0) != nil {
   484  			r0 = ret.Get(0).(*model.AppError)
   485  		}
   486  	}
   487  
   488  	return r0
   489  }
   490  
   491  // DisablePlugin provides a mock function with given fields: id
   492  func (_m *API) DisablePlugin(id string) *model.AppError {
   493  	ret := _m.Called(id)
   494  
   495  	var r0 *model.AppError
   496  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
   497  		r0 = rf(id)
   498  	} else {
   499  		if ret.Get(0) != nil {
   500  			r0 = ret.Get(0).(*model.AppError)
   501  		}
   502  	}
   503  
   504  	return r0
   505  }
   506  
   507  // EnablePlugin provides a mock function with given fields: id
   508  func (_m *API) EnablePlugin(id string) *model.AppError {
   509  	ret := _m.Called(id)
   510  
   511  	var r0 *model.AppError
   512  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
   513  		r0 = rf(id)
   514  	} else {
   515  		if ret.Get(0) != nil {
   516  			r0 = ret.Get(0).(*model.AppError)
   517  		}
   518  	}
   519  
   520  	return r0
   521  }
   522  
   523  // ExecuteSlashCommand provides a mock function with given fields: commandArgs
   524  func (_m *API) ExecuteSlashCommand(commandArgs *model.CommandArgs) (*model.CommandResponse, error) {
   525  	ret := _m.Called(commandArgs)
   526  
   527  	var r0 *model.CommandResponse
   528  	if rf, ok := ret.Get(0).(func(*model.CommandArgs) *model.CommandResponse); ok {
   529  		r0 = rf(commandArgs)
   530  	} else {
   531  		if ret.Get(0) != nil {
   532  			r0 = ret.Get(0).(*model.CommandResponse)
   533  		}
   534  	}
   535  
   536  	var r1 error
   537  	if rf, ok := ret.Get(1).(func(*model.CommandArgs) error); ok {
   538  		r1 = rf(commandArgs)
   539  	} else {
   540  		r1 = ret.Error(1)
   541  	}
   542  
   543  	return r0, r1
   544  }
   545  
   546  // GetBot provides a mock function with given fields: botUserId, includeDeleted
   547  func (_m *API) GetBot(botUserId string, includeDeleted bool) (*model.Bot, *model.AppError) {
   548  	ret := _m.Called(botUserId, includeDeleted)
   549  
   550  	var r0 *model.Bot
   551  	if rf, ok := ret.Get(0).(func(string, bool) *model.Bot); ok {
   552  		r0 = rf(botUserId, includeDeleted)
   553  	} else {
   554  		if ret.Get(0) != nil {
   555  			r0 = ret.Get(0).(*model.Bot)
   556  		}
   557  	}
   558  
   559  	var r1 *model.AppError
   560  	if rf, ok := ret.Get(1).(func(string, bool) *model.AppError); ok {
   561  		r1 = rf(botUserId, includeDeleted)
   562  	} else {
   563  		if ret.Get(1) != nil {
   564  			r1 = ret.Get(1).(*model.AppError)
   565  		}
   566  	}
   567  
   568  	return r0, r1
   569  }
   570  
   571  // GetBotIconImage provides a mock function with given fields: botUserId
   572  func (_m *API) GetBotIconImage(botUserId string) ([]byte, *model.AppError) {
   573  	ret := _m.Called(botUserId)
   574  
   575  	var r0 []byte
   576  	if rf, ok := ret.Get(0).(func(string) []byte); ok {
   577  		r0 = rf(botUserId)
   578  	} else {
   579  		if ret.Get(0) != nil {
   580  			r0 = ret.Get(0).([]byte)
   581  		}
   582  	}
   583  
   584  	var r1 *model.AppError
   585  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
   586  		r1 = rf(botUserId)
   587  	} else {
   588  		if ret.Get(1) != nil {
   589  			r1 = ret.Get(1).(*model.AppError)
   590  		}
   591  	}
   592  
   593  	return r0, r1
   594  }
   595  
   596  // GetBots provides a mock function with given fields: options
   597  func (_m *API) GetBots(options *model.BotGetOptions) ([]*model.Bot, *model.AppError) {
   598  	ret := _m.Called(options)
   599  
   600  	var r0 []*model.Bot
   601  	if rf, ok := ret.Get(0).(func(*model.BotGetOptions) []*model.Bot); ok {
   602  		r0 = rf(options)
   603  	} else {
   604  		if ret.Get(0) != nil {
   605  			r0 = ret.Get(0).([]*model.Bot)
   606  		}
   607  	}
   608  
   609  	var r1 *model.AppError
   610  	if rf, ok := ret.Get(1).(func(*model.BotGetOptions) *model.AppError); ok {
   611  		r1 = rf(options)
   612  	} else {
   613  		if ret.Get(1) != nil {
   614  			r1 = ret.Get(1).(*model.AppError)
   615  		}
   616  	}
   617  
   618  	return r0, r1
   619  }
   620  
   621  // GetBundlePath provides a mock function with given fields:
   622  func (_m *API) GetBundlePath() (string, error) {
   623  	ret := _m.Called()
   624  
   625  	var r0 string
   626  	if rf, ok := ret.Get(0).(func() string); ok {
   627  		r0 = rf()
   628  	} else {
   629  		r0 = ret.Get(0).(string)
   630  	}
   631  
   632  	var r1 error
   633  	if rf, ok := ret.Get(1).(func() error); ok {
   634  		r1 = rf()
   635  	} else {
   636  		r1 = ret.Error(1)
   637  	}
   638  
   639  	return r0, r1
   640  }
   641  
   642  // GetChannel provides a mock function with given fields: channelId
   643  func (_m *API) GetChannel(channelId string) (*model.Channel, *model.AppError) {
   644  	ret := _m.Called(channelId)
   645  
   646  	var r0 *model.Channel
   647  	if rf, ok := ret.Get(0).(func(string) *model.Channel); ok {
   648  		r0 = rf(channelId)
   649  	} else {
   650  		if ret.Get(0) != nil {
   651  			r0 = ret.Get(0).(*model.Channel)
   652  		}
   653  	}
   654  
   655  	var r1 *model.AppError
   656  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
   657  		r1 = rf(channelId)
   658  	} else {
   659  		if ret.Get(1) != nil {
   660  			r1 = ret.Get(1).(*model.AppError)
   661  		}
   662  	}
   663  
   664  	return r0, r1
   665  }
   666  
   667  // GetChannelByName provides a mock function with given fields: teamId, name, includeDeleted
   668  func (_m *API) GetChannelByName(teamId string, name string, includeDeleted bool) (*model.Channel, *model.AppError) {
   669  	ret := _m.Called(teamId, name, includeDeleted)
   670  
   671  	var r0 *model.Channel
   672  	if rf, ok := ret.Get(0).(func(string, string, bool) *model.Channel); ok {
   673  		r0 = rf(teamId, name, includeDeleted)
   674  	} else {
   675  		if ret.Get(0) != nil {
   676  			r0 = ret.Get(0).(*model.Channel)
   677  		}
   678  	}
   679  
   680  	var r1 *model.AppError
   681  	if rf, ok := ret.Get(1).(func(string, string, bool) *model.AppError); ok {
   682  		r1 = rf(teamId, name, includeDeleted)
   683  	} else {
   684  		if ret.Get(1) != nil {
   685  			r1 = ret.Get(1).(*model.AppError)
   686  		}
   687  	}
   688  
   689  	return r0, r1
   690  }
   691  
   692  // GetChannelByNameForTeamName provides a mock function with given fields: teamName, channelName, includeDeleted
   693  func (_m *API) GetChannelByNameForTeamName(teamName string, channelName string, includeDeleted bool) (*model.Channel, *model.AppError) {
   694  	ret := _m.Called(teamName, channelName, includeDeleted)
   695  
   696  	var r0 *model.Channel
   697  	if rf, ok := ret.Get(0).(func(string, string, bool) *model.Channel); ok {
   698  		r0 = rf(teamName, channelName, includeDeleted)
   699  	} else {
   700  		if ret.Get(0) != nil {
   701  			r0 = ret.Get(0).(*model.Channel)
   702  		}
   703  	}
   704  
   705  	var r1 *model.AppError
   706  	if rf, ok := ret.Get(1).(func(string, string, bool) *model.AppError); ok {
   707  		r1 = rf(teamName, channelName, includeDeleted)
   708  	} else {
   709  		if ret.Get(1) != nil {
   710  			r1 = ret.Get(1).(*model.AppError)
   711  		}
   712  	}
   713  
   714  	return r0, r1
   715  }
   716  
   717  // GetChannelMember provides a mock function with given fields: channelId, userId
   718  func (_m *API) GetChannelMember(channelId string, userId string) (*model.ChannelMember, *model.AppError) {
   719  	ret := _m.Called(channelId, userId)
   720  
   721  	var r0 *model.ChannelMember
   722  	if rf, ok := ret.Get(0).(func(string, string) *model.ChannelMember); ok {
   723  		r0 = rf(channelId, userId)
   724  	} else {
   725  		if ret.Get(0) != nil {
   726  			r0 = ret.Get(0).(*model.ChannelMember)
   727  		}
   728  	}
   729  
   730  	var r1 *model.AppError
   731  	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
   732  		r1 = rf(channelId, userId)
   733  	} else {
   734  		if ret.Get(1) != nil {
   735  			r1 = ret.Get(1).(*model.AppError)
   736  		}
   737  	}
   738  
   739  	return r0, r1
   740  }
   741  
   742  // GetChannelMembers provides a mock function with given fields: channelId, page, perPage
   743  func (_m *API) GetChannelMembers(channelId string, page int, perPage int) (*model.ChannelMembers, *model.AppError) {
   744  	ret := _m.Called(channelId, page, perPage)
   745  
   746  	var r0 *model.ChannelMembers
   747  	if rf, ok := ret.Get(0).(func(string, int, int) *model.ChannelMembers); ok {
   748  		r0 = rf(channelId, page, perPage)
   749  	} else {
   750  		if ret.Get(0) != nil {
   751  			r0 = ret.Get(0).(*model.ChannelMembers)
   752  		}
   753  	}
   754  
   755  	var r1 *model.AppError
   756  	if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
   757  		r1 = rf(channelId, page, perPage)
   758  	} else {
   759  		if ret.Get(1) != nil {
   760  			r1 = ret.Get(1).(*model.AppError)
   761  		}
   762  	}
   763  
   764  	return r0, r1
   765  }
   766  
   767  // GetChannelMembersByIds provides a mock function with given fields: channelId, userIds
   768  func (_m *API) GetChannelMembersByIds(channelId string, userIds []string) (*model.ChannelMembers, *model.AppError) {
   769  	ret := _m.Called(channelId, userIds)
   770  
   771  	var r0 *model.ChannelMembers
   772  	if rf, ok := ret.Get(0).(func(string, []string) *model.ChannelMembers); ok {
   773  		r0 = rf(channelId, userIds)
   774  	} else {
   775  		if ret.Get(0) != nil {
   776  			r0 = ret.Get(0).(*model.ChannelMembers)
   777  		}
   778  	}
   779  
   780  	var r1 *model.AppError
   781  	if rf, ok := ret.Get(1).(func(string, []string) *model.AppError); ok {
   782  		r1 = rf(channelId, userIds)
   783  	} else {
   784  		if ret.Get(1) != nil {
   785  			r1 = ret.Get(1).(*model.AppError)
   786  		}
   787  	}
   788  
   789  	return r0, r1
   790  }
   791  
   792  // GetChannelMembersForUser provides a mock function with given fields: teamId, userId, page, perPage
   793  func (_m *API) GetChannelMembersForUser(teamId string, userId string, page int, perPage int) ([]*model.ChannelMember, *model.AppError) {
   794  	ret := _m.Called(teamId, userId, page, perPage)
   795  
   796  	var r0 []*model.ChannelMember
   797  	if rf, ok := ret.Get(0).(func(string, string, int, int) []*model.ChannelMember); ok {
   798  		r0 = rf(teamId, userId, page, perPage)
   799  	} else {
   800  		if ret.Get(0) != nil {
   801  			r0 = ret.Get(0).([]*model.ChannelMember)
   802  		}
   803  	}
   804  
   805  	var r1 *model.AppError
   806  	if rf, ok := ret.Get(1).(func(string, string, int, int) *model.AppError); ok {
   807  		r1 = rf(teamId, userId, page, perPage)
   808  	} else {
   809  		if ret.Get(1) != nil {
   810  			r1 = ret.Get(1).(*model.AppError)
   811  		}
   812  	}
   813  
   814  	return r0, r1
   815  }
   816  
   817  // GetChannelStats provides a mock function with given fields: channelId
   818  func (_m *API) GetChannelStats(channelId string) (*model.ChannelStats, *model.AppError) {
   819  	ret := _m.Called(channelId)
   820  
   821  	var r0 *model.ChannelStats
   822  	if rf, ok := ret.Get(0).(func(string) *model.ChannelStats); ok {
   823  		r0 = rf(channelId)
   824  	} else {
   825  		if ret.Get(0) != nil {
   826  			r0 = ret.Get(0).(*model.ChannelStats)
   827  		}
   828  	}
   829  
   830  	var r1 *model.AppError
   831  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
   832  		r1 = rf(channelId)
   833  	} else {
   834  		if ret.Get(1) != nil {
   835  			r1 = ret.Get(1).(*model.AppError)
   836  		}
   837  	}
   838  
   839  	return r0, r1
   840  }
   841  
   842  // GetChannelsForTeamForUser provides a mock function with given fields: teamId, userId, includeDeleted
   843  func (_m *API) GetChannelsForTeamForUser(teamId string, userId string, includeDeleted bool) ([]*model.Channel, *model.AppError) {
   844  	ret := _m.Called(teamId, userId, includeDeleted)
   845  
   846  	var r0 []*model.Channel
   847  	if rf, ok := ret.Get(0).(func(string, string, bool) []*model.Channel); ok {
   848  		r0 = rf(teamId, userId, includeDeleted)
   849  	} else {
   850  		if ret.Get(0) != nil {
   851  			r0 = ret.Get(0).([]*model.Channel)
   852  		}
   853  	}
   854  
   855  	var r1 *model.AppError
   856  	if rf, ok := ret.Get(1).(func(string, string, bool) *model.AppError); ok {
   857  		r1 = rf(teamId, userId, includeDeleted)
   858  	} else {
   859  		if ret.Get(1) != nil {
   860  			r1 = ret.Get(1).(*model.AppError)
   861  		}
   862  	}
   863  
   864  	return r0, r1
   865  }
   866  
   867  // GetCommand provides a mock function with given fields: commandID
   868  func (_m *API) GetCommand(commandID string) (*model.Command, error) {
   869  	ret := _m.Called(commandID)
   870  
   871  	var r0 *model.Command
   872  	if rf, ok := ret.Get(0).(func(string) *model.Command); ok {
   873  		r0 = rf(commandID)
   874  	} else {
   875  		if ret.Get(0) != nil {
   876  			r0 = ret.Get(0).(*model.Command)
   877  		}
   878  	}
   879  
   880  	var r1 error
   881  	if rf, ok := ret.Get(1).(func(string) error); ok {
   882  		r1 = rf(commandID)
   883  	} else {
   884  		r1 = ret.Error(1)
   885  	}
   886  
   887  	return r0, r1
   888  }
   889  
   890  // GetConfig provides a mock function with given fields:
   891  func (_m *API) GetConfig() *model.Config {
   892  	ret := _m.Called()
   893  
   894  	var r0 *model.Config
   895  	if rf, ok := ret.Get(0).(func() *model.Config); ok {
   896  		r0 = rf()
   897  	} else {
   898  		if ret.Get(0) != nil {
   899  			r0 = ret.Get(0).(*model.Config)
   900  		}
   901  	}
   902  
   903  	return r0
   904  }
   905  
   906  // GetDiagnosticId provides a mock function with given fields:
   907  func (_m *API) GetDiagnosticId() string {
   908  	ret := _m.Called()
   909  
   910  	var r0 string
   911  	if rf, ok := ret.Get(0).(func() string); ok {
   912  		r0 = rf()
   913  	} else {
   914  		r0 = ret.Get(0).(string)
   915  	}
   916  
   917  	return r0
   918  }
   919  
   920  // GetDirectChannel provides a mock function with given fields: userId1, userId2
   921  func (_m *API) GetDirectChannel(userId1 string, userId2 string) (*model.Channel, *model.AppError) {
   922  	ret := _m.Called(userId1, userId2)
   923  
   924  	var r0 *model.Channel
   925  	if rf, ok := ret.Get(0).(func(string, string) *model.Channel); ok {
   926  		r0 = rf(userId1, userId2)
   927  	} else {
   928  		if ret.Get(0) != nil {
   929  			r0 = ret.Get(0).(*model.Channel)
   930  		}
   931  	}
   932  
   933  	var r1 *model.AppError
   934  	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
   935  		r1 = rf(userId1, userId2)
   936  	} else {
   937  		if ret.Get(1) != nil {
   938  			r1 = ret.Get(1).(*model.AppError)
   939  		}
   940  	}
   941  
   942  	return r0, r1
   943  }
   944  
   945  // GetEmoji provides a mock function with given fields: emojiId
   946  func (_m *API) GetEmoji(emojiId string) (*model.Emoji, *model.AppError) {
   947  	ret := _m.Called(emojiId)
   948  
   949  	var r0 *model.Emoji
   950  	if rf, ok := ret.Get(0).(func(string) *model.Emoji); ok {
   951  		r0 = rf(emojiId)
   952  	} else {
   953  		if ret.Get(0) != nil {
   954  			r0 = ret.Get(0).(*model.Emoji)
   955  		}
   956  	}
   957  
   958  	var r1 *model.AppError
   959  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
   960  		r1 = rf(emojiId)
   961  	} else {
   962  		if ret.Get(1) != nil {
   963  			r1 = ret.Get(1).(*model.AppError)
   964  		}
   965  	}
   966  
   967  	return r0, r1
   968  }
   969  
   970  // GetEmojiByName provides a mock function with given fields: name
   971  func (_m *API) GetEmojiByName(name string) (*model.Emoji, *model.AppError) {
   972  	ret := _m.Called(name)
   973  
   974  	var r0 *model.Emoji
   975  	if rf, ok := ret.Get(0).(func(string) *model.Emoji); ok {
   976  		r0 = rf(name)
   977  	} else {
   978  		if ret.Get(0) != nil {
   979  			r0 = ret.Get(0).(*model.Emoji)
   980  		}
   981  	}
   982  
   983  	var r1 *model.AppError
   984  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
   985  		r1 = rf(name)
   986  	} else {
   987  		if ret.Get(1) != nil {
   988  			r1 = ret.Get(1).(*model.AppError)
   989  		}
   990  	}
   991  
   992  	return r0, r1
   993  }
   994  
   995  // GetEmojiImage provides a mock function with given fields: emojiId
   996  func (_m *API) GetEmojiImage(emojiId string) ([]byte, string, *model.AppError) {
   997  	ret := _m.Called(emojiId)
   998  
   999  	var r0 []byte
  1000  	if rf, ok := ret.Get(0).(func(string) []byte); ok {
  1001  		r0 = rf(emojiId)
  1002  	} else {
  1003  		if ret.Get(0) != nil {
  1004  			r0 = ret.Get(0).([]byte)
  1005  		}
  1006  	}
  1007  
  1008  	var r1 string
  1009  	if rf, ok := ret.Get(1).(func(string) string); ok {
  1010  		r1 = rf(emojiId)
  1011  	} else {
  1012  		r1 = ret.Get(1).(string)
  1013  	}
  1014  
  1015  	var r2 *model.AppError
  1016  	if rf, ok := ret.Get(2).(func(string) *model.AppError); ok {
  1017  		r2 = rf(emojiId)
  1018  	} else {
  1019  		if ret.Get(2) != nil {
  1020  			r2 = ret.Get(2).(*model.AppError)
  1021  		}
  1022  	}
  1023  
  1024  	return r0, r1, r2
  1025  }
  1026  
  1027  // GetEmojiList provides a mock function with given fields: sortBy, page, perPage
  1028  func (_m *API) GetEmojiList(sortBy string, page int, perPage int) ([]*model.Emoji, *model.AppError) {
  1029  	ret := _m.Called(sortBy, page, perPage)
  1030  
  1031  	var r0 []*model.Emoji
  1032  	if rf, ok := ret.Get(0).(func(string, int, int) []*model.Emoji); ok {
  1033  		r0 = rf(sortBy, page, perPage)
  1034  	} else {
  1035  		if ret.Get(0) != nil {
  1036  			r0 = ret.Get(0).([]*model.Emoji)
  1037  		}
  1038  	}
  1039  
  1040  	var r1 *model.AppError
  1041  	if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
  1042  		r1 = rf(sortBy, page, perPage)
  1043  	} else {
  1044  		if ret.Get(1) != nil {
  1045  			r1 = ret.Get(1).(*model.AppError)
  1046  		}
  1047  	}
  1048  
  1049  	return r0, r1
  1050  }
  1051  
  1052  // GetFile provides a mock function with given fields: fileId
  1053  func (_m *API) GetFile(fileId string) ([]byte, *model.AppError) {
  1054  	ret := _m.Called(fileId)
  1055  
  1056  	var r0 []byte
  1057  	if rf, ok := ret.Get(0).(func(string) []byte); ok {
  1058  		r0 = rf(fileId)
  1059  	} else {
  1060  		if ret.Get(0) != nil {
  1061  			r0 = ret.Get(0).([]byte)
  1062  		}
  1063  	}
  1064  
  1065  	var r1 *model.AppError
  1066  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1067  		r1 = rf(fileId)
  1068  	} else {
  1069  		if ret.Get(1) != nil {
  1070  			r1 = ret.Get(1).(*model.AppError)
  1071  		}
  1072  	}
  1073  
  1074  	return r0, r1
  1075  }
  1076  
  1077  // GetFileInfo provides a mock function with given fields: fileId
  1078  func (_m *API) GetFileInfo(fileId string) (*model.FileInfo, *model.AppError) {
  1079  	ret := _m.Called(fileId)
  1080  
  1081  	var r0 *model.FileInfo
  1082  	if rf, ok := ret.Get(0).(func(string) *model.FileInfo); ok {
  1083  		r0 = rf(fileId)
  1084  	} else {
  1085  		if ret.Get(0) != nil {
  1086  			r0 = ret.Get(0).(*model.FileInfo)
  1087  		}
  1088  	}
  1089  
  1090  	var r1 *model.AppError
  1091  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1092  		r1 = rf(fileId)
  1093  	} else {
  1094  		if ret.Get(1) != nil {
  1095  			r1 = ret.Get(1).(*model.AppError)
  1096  		}
  1097  	}
  1098  
  1099  	return r0, r1
  1100  }
  1101  
  1102  // GetFileInfos provides a mock function with given fields: page, perPage, opt
  1103  func (_m *API) GetFileInfos(page int, perPage int, opt *model.GetFileInfosOptions) ([]*model.FileInfo, *model.AppError) {
  1104  	ret := _m.Called(page, perPage, opt)
  1105  
  1106  	var r0 []*model.FileInfo
  1107  	if rf, ok := ret.Get(0).(func(int, int, *model.GetFileInfosOptions) []*model.FileInfo); ok {
  1108  		r0 = rf(page, perPage, opt)
  1109  	} else {
  1110  		if ret.Get(0) != nil {
  1111  			r0 = ret.Get(0).([]*model.FileInfo)
  1112  		}
  1113  	}
  1114  
  1115  	var r1 *model.AppError
  1116  	if rf, ok := ret.Get(1).(func(int, int, *model.GetFileInfosOptions) *model.AppError); ok {
  1117  		r1 = rf(page, perPage, opt)
  1118  	} else {
  1119  		if ret.Get(1) != nil {
  1120  			r1 = ret.Get(1).(*model.AppError)
  1121  		}
  1122  	}
  1123  
  1124  	return r0, r1
  1125  }
  1126  
  1127  // GetFileLink provides a mock function with given fields: fileId
  1128  func (_m *API) GetFileLink(fileId string) (string, *model.AppError) {
  1129  	ret := _m.Called(fileId)
  1130  
  1131  	var r0 string
  1132  	if rf, ok := ret.Get(0).(func(string) string); ok {
  1133  		r0 = rf(fileId)
  1134  	} else {
  1135  		r0 = ret.Get(0).(string)
  1136  	}
  1137  
  1138  	var r1 *model.AppError
  1139  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1140  		r1 = rf(fileId)
  1141  	} else {
  1142  		if ret.Get(1) != nil {
  1143  			r1 = ret.Get(1).(*model.AppError)
  1144  		}
  1145  	}
  1146  
  1147  	return r0, r1
  1148  }
  1149  
  1150  // GetGroup provides a mock function with given fields: groupId
  1151  func (_m *API) GetGroup(groupId string) (*model.Group, *model.AppError) {
  1152  	ret := _m.Called(groupId)
  1153  
  1154  	var r0 *model.Group
  1155  	if rf, ok := ret.Get(0).(func(string) *model.Group); ok {
  1156  		r0 = rf(groupId)
  1157  	} else {
  1158  		if ret.Get(0) != nil {
  1159  			r0 = ret.Get(0).(*model.Group)
  1160  		}
  1161  	}
  1162  
  1163  	var r1 *model.AppError
  1164  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1165  		r1 = rf(groupId)
  1166  	} else {
  1167  		if ret.Get(1) != nil {
  1168  			r1 = ret.Get(1).(*model.AppError)
  1169  		}
  1170  	}
  1171  
  1172  	return r0, r1
  1173  }
  1174  
  1175  // GetGroupByName provides a mock function with given fields: name
  1176  func (_m *API) GetGroupByName(name string) (*model.Group, *model.AppError) {
  1177  	ret := _m.Called(name)
  1178  
  1179  	var r0 *model.Group
  1180  	if rf, ok := ret.Get(0).(func(string) *model.Group); ok {
  1181  		r0 = rf(name)
  1182  	} else {
  1183  		if ret.Get(0) != nil {
  1184  			r0 = ret.Get(0).(*model.Group)
  1185  		}
  1186  	}
  1187  
  1188  	var r1 *model.AppError
  1189  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1190  		r1 = rf(name)
  1191  	} else {
  1192  		if ret.Get(1) != nil {
  1193  			r1 = ret.Get(1).(*model.AppError)
  1194  		}
  1195  	}
  1196  
  1197  	return r0, r1
  1198  }
  1199  
  1200  // GetGroupChannel provides a mock function with given fields: userIds
  1201  func (_m *API) GetGroupChannel(userIds []string) (*model.Channel, *model.AppError) {
  1202  	ret := _m.Called(userIds)
  1203  
  1204  	var r0 *model.Channel
  1205  	if rf, ok := ret.Get(0).(func([]string) *model.Channel); ok {
  1206  		r0 = rf(userIds)
  1207  	} else {
  1208  		if ret.Get(0) != nil {
  1209  			r0 = ret.Get(0).(*model.Channel)
  1210  		}
  1211  	}
  1212  
  1213  	var r1 *model.AppError
  1214  	if rf, ok := ret.Get(1).(func([]string) *model.AppError); ok {
  1215  		r1 = rf(userIds)
  1216  	} else {
  1217  		if ret.Get(1) != nil {
  1218  			r1 = ret.Get(1).(*model.AppError)
  1219  		}
  1220  	}
  1221  
  1222  	return r0, r1
  1223  }
  1224  
  1225  // GetGroupsForUser provides a mock function with given fields: userId
  1226  func (_m *API) GetGroupsForUser(userId string) ([]*model.Group, *model.AppError) {
  1227  	ret := _m.Called(userId)
  1228  
  1229  	var r0 []*model.Group
  1230  	if rf, ok := ret.Get(0).(func(string) []*model.Group); ok {
  1231  		r0 = rf(userId)
  1232  	} else {
  1233  		if ret.Get(0) != nil {
  1234  			r0 = ret.Get(0).([]*model.Group)
  1235  		}
  1236  	}
  1237  
  1238  	var r1 *model.AppError
  1239  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1240  		r1 = rf(userId)
  1241  	} else {
  1242  		if ret.Get(1) != nil {
  1243  			r1 = ret.Get(1).(*model.AppError)
  1244  		}
  1245  	}
  1246  
  1247  	return r0, r1
  1248  }
  1249  
  1250  // GetLDAPUserAttributes provides a mock function with given fields: userId, attributes
  1251  func (_m *API) GetLDAPUserAttributes(userId string, attributes []string) (map[string]string, *model.AppError) {
  1252  	ret := _m.Called(userId, attributes)
  1253  
  1254  	var r0 map[string]string
  1255  	if rf, ok := ret.Get(0).(func(string, []string) map[string]string); ok {
  1256  		r0 = rf(userId, attributes)
  1257  	} else {
  1258  		if ret.Get(0) != nil {
  1259  			r0 = ret.Get(0).(map[string]string)
  1260  		}
  1261  	}
  1262  
  1263  	var r1 *model.AppError
  1264  	if rf, ok := ret.Get(1).(func(string, []string) *model.AppError); ok {
  1265  		r1 = rf(userId, attributes)
  1266  	} else {
  1267  		if ret.Get(1) != nil {
  1268  			r1 = ret.Get(1).(*model.AppError)
  1269  		}
  1270  	}
  1271  
  1272  	return r0, r1
  1273  }
  1274  
  1275  // GetLicense provides a mock function with given fields:
  1276  func (_m *API) GetLicense() *model.License {
  1277  	ret := _m.Called()
  1278  
  1279  	var r0 *model.License
  1280  	if rf, ok := ret.Get(0).(func() *model.License); ok {
  1281  		r0 = rf()
  1282  	} else {
  1283  		if ret.Get(0) != nil {
  1284  			r0 = ret.Get(0).(*model.License)
  1285  		}
  1286  	}
  1287  
  1288  	return r0
  1289  }
  1290  
  1291  // GetPluginConfig provides a mock function with given fields:
  1292  func (_m *API) GetPluginConfig() map[string]interface{} {
  1293  	ret := _m.Called()
  1294  
  1295  	var r0 map[string]interface{}
  1296  	if rf, ok := ret.Get(0).(func() map[string]interface{}); ok {
  1297  		r0 = rf()
  1298  	} else {
  1299  		if ret.Get(0) != nil {
  1300  			r0 = ret.Get(0).(map[string]interface{})
  1301  		}
  1302  	}
  1303  
  1304  	return r0
  1305  }
  1306  
  1307  // GetPluginStatus provides a mock function with given fields: id
  1308  func (_m *API) GetPluginStatus(id string) (*model.PluginStatus, *model.AppError) {
  1309  	ret := _m.Called(id)
  1310  
  1311  	var r0 *model.PluginStatus
  1312  	if rf, ok := ret.Get(0).(func(string) *model.PluginStatus); ok {
  1313  		r0 = rf(id)
  1314  	} else {
  1315  		if ret.Get(0) != nil {
  1316  			r0 = ret.Get(0).(*model.PluginStatus)
  1317  		}
  1318  	}
  1319  
  1320  	var r1 *model.AppError
  1321  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1322  		r1 = rf(id)
  1323  	} else {
  1324  		if ret.Get(1) != nil {
  1325  			r1 = ret.Get(1).(*model.AppError)
  1326  		}
  1327  	}
  1328  
  1329  	return r0, r1
  1330  }
  1331  
  1332  // GetPlugins provides a mock function with given fields:
  1333  func (_m *API) GetPlugins() ([]*model.Manifest, *model.AppError) {
  1334  	ret := _m.Called()
  1335  
  1336  	var r0 []*model.Manifest
  1337  	if rf, ok := ret.Get(0).(func() []*model.Manifest); ok {
  1338  		r0 = rf()
  1339  	} else {
  1340  		if ret.Get(0) != nil {
  1341  			r0 = ret.Get(0).([]*model.Manifest)
  1342  		}
  1343  	}
  1344  
  1345  	var r1 *model.AppError
  1346  	if rf, ok := ret.Get(1).(func() *model.AppError); ok {
  1347  		r1 = rf()
  1348  	} else {
  1349  		if ret.Get(1) != nil {
  1350  			r1 = ret.Get(1).(*model.AppError)
  1351  		}
  1352  	}
  1353  
  1354  	return r0, r1
  1355  }
  1356  
  1357  // GetPost provides a mock function with given fields: postId
  1358  func (_m *API) GetPost(postId string) (*model.Post, *model.AppError) {
  1359  	ret := _m.Called(postId)
  1360  
  1361  	var r0 *model.Post
  1362  	if rf, ok := ret.Get(0).(func(string) *model.Post); ok {
  1363  		r0 = rf(postId)
  1364  	} else {
  1365  		if ret.Get(0) != nil {
  1366  			r0 = ret.Get(0).(*model.Post)
  1367  		}
  1368  	}
  1369  
  1370  	var r1 *model.AppError
  1371  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1372  		r1 = rf(postId)
  1373  	} else {
  1374  		if ret.Get(1) != nil {
  1375  			r1 = ret.Get(1).(*model.AppError)
  1376  		}
  1377  	}
  1378  
  1379  	return r0, r1
  1380  }
  1381  
  1382  // GetPostThread provides a mock function with given fields: postId
  1383  func (_m *API) GetPostThread(postId string) (*model.PostList, *model.AppError) {
  1384  	ret := _m.Called(postId)
  1385  
  1386  	var r0 *model.PostList
  1387  	if rf, ok := ret.Get(0).(func(string) *model.PostList); ok {
  1388  		r0 = rf(postId)
  1389  	} else {
  1390  		if ret.Get(0) != nil {
  1391  			r0 = ret.Get(0).(*model.PostList)
  1392  		}
  1393  	}
  1394  
  1395  	var r1 *model.AppError
  1396  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1397  		r1 = rf(postId)
  1398  	} else {
  1399  		if ret.Get(1) != nil {
  1400  			r1 = ret.Get(1).(*model.AppError)
  1401  		}
  1402  	}
  1403  
  1404  	return r0, r1
  1405  }
  1406  
  1407  // GetPostsAfter provides a mock function with given fields: channelId, postId, page, perPage
  1408  func (_m *API) GetPostsAfter(channelId string, postId string, page int, perPage int) (*model.PostList, *model.AppError) {
  1409  	ret := _m.Called(channelId, postId, page, perPage)
  1410  
  1411  	var r0 *model.PostList
  1412  	if rf, ok := ret.Get(0).(func(string, string, int, int) *model.PostList); ok {
  1413  		r0 = rf(channelId, postId, page, perPage)
  1414  	} else {
  1415  		if ret.Get(0) != nil {
  1416  			r0 = ret.Get(0).(*model.PostList)
  1417  		}
  1418  	}
  1419  
  1420  	var r1 *model.AppError
  1421  	if rf, ok := ret.Get(1).(func(string, string, int, int) *model.AppError); ok {
  1422  		r1 = rf(channelId, postId, page, perPage)
  1423  	} else {
  1424  		if ret.Get(1) != nil {
  1425  			r1 = ret.Get(1).(*model.AppError)
  1426  		}
  1427  	}
  1428  
  1429  	return r0, r1
  1430  }
  1431  
  1432  // GetPostsBefore provides a mock function with given fields: channelId, postId, page, perPage
  1433  func (_m *API) GetPostsBefore(channelId string, postId string, page int, perPage int) (*model.PostList, *model.AppError) {
  1434  	ret := _m.Called(channelId, postId, page, perPage)
  1435  
  1436  	var r0 *model.PostList
  1437  	if rf, ok := ret.Get(0).(func(string, string, int, int) *model.PostList); ok {
  1438  		r0 = rf(channelId, postId, page, perPage)
  1439  	} else {
  1440  		if ret.Get(0) != nil {
  1441  			r0 = ret.Get(0).(*model.PostList)
  1442  		}
  1443  	}
  1444  
  1445  	var r1 *model.AppError
  1446  	if rf, ok := ret.Get(1).(func(string, string, int, int) *model.AppError); ok {
  1447  		r1 = rf(channelId, postId, page, perPage)
  1448  	} else {
  1449  		if ret.Get(1) != nil {
  1450  			r1 = ret.Get(1).(*model.AppError)
  1451  		}
  1452  	}
  1453  
  1454  	return r0, r1
  1455  }
  1456  
  1457  // GetPostsForChannel provides a mock function with given fields: channelId, page, perPage
  1458  func (_m *API) GetPostsForChannel(channelId string, page int, perPage int) (*model.PostList, *model.AppError) {
  1459  	ret := _m.Called(channelId, page, perPage)
  1460  
  1461  	var r0 *model.PostList
  1462  	if rf, ok := ret.Get(0).(func(string, int, int) *model.PostList); ok {
  1463  		r0 = rf(channelId, page, perPage)
  1464  	} else {
  1465  		if ret.Get(0) != nil {
  1466  			r0 = ret.Get(0).(*model.PostList)
  1467  		}
  1468  	}
  1469  
  1470  	var r1 *model.AppError
  1471  	if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
  1472  		r1 = rf(channelId, page, perPage)
  1473  	} else {
  1474  		if ret.Get(1) != nil {
  1475  			r1 = ret.Get(1).(*model.AppError)
  1476  		}
  1477  	}
  1478  
  1479  	return r0, r1
  1480  }
  1481  
  1482  // GetPostsSince provides a mock function with given fields: channelId, time
  1483  func (_m *API) GetPostsSince(channelId string, time int64) (*model.PostList, *model.AppError) {
  1484  	ret := _m.Called(channelId, time)
  1485  
  1486  	var r0 *model.PostList
  1487  	if rf, ok := ret.Get(0).(func(string, int64) *model.PostList); ok {
  1488  		r0 = rf(channelId, time)
  1489  	} else {
  1490  		if ret.Get(0) != nil {
  1491  			r0 = ret.Get(0).(*model.PostList)
  1492  		}
  1493  	}
  1494  
  1495  	var r1 *model.AppError
  1496  	if rf, ok := ret.Get(1).(func(string, int64) *model.AppError); ok {
  1497  		r1 = rf(channelId, time)
  1498  	} else {
  1499  		if ret.Get(1) != nil {
  1500  			r1 = ret.Get(1).(*model.AppError)
  1501  		}
  1502  	}
  1503  
  1504  	return r0, r1
  1505  }
  1506  
  1507  // GetPreferencesForUser provides a mock function with given fields: userId
  1508  func (_m *API) GetPreferencesForUser(userId string) ([]model.Preference, *model.AppError) {
  1509  	ret := _m.Called(userId)
  1510  
  1511  	var r0 []model.Preference
  1512  	if rf, ok := ret.Get(0).(func(string) []model.Preference); ok {
  1513  		r0 = rf(userId)
  1514  	} else {
  1515  		if ret.Get(0) != nil {
  1516  			r0 = ret.Get(0).([]model.Preference)
  1517  		}
  1518  	}
  1519  
  1520  	var r1 *model.AppError
  1521  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1522  		r1 = rf(userId)
  1523  	} else {
  1524  		if ret.Get(1) != nil {
  1525  			r1 = ret.Get(1).(*model.AppError)
  1526  		}
  1527  	}
  1528  
  1529  	return r0, r1
  1530  }
  1531  
  1532  // GetProfileImage provides a mock function with given fields: userId
  1533  func (_m *API) GetProfileImage(userId string) ([]byte, *model.AppError) {
  1534  	ret := _m.Called(userId)
  1535  
  1536  	var r0 []byte
  1537  	if rf, ok := ret.Get(0).(func(string) []byte); ok {
  1538  		r0 = rf(userId)
  1539  	} else {
  1540  		if ret.Get(0) != nil {
  1541  			r0 = ret.Get(0).([]byte)
  1542  		}
  1543  	}
  1544  
  1545  	var r1 *model.AppError
  1546  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1547  		r1 = rf(userId)
  1548  	} else {
  1549  		if ret.Get(1) != nil {
  1550  			r1 = ret.Get(1).(*model.AppError)
  1551  		}
  1552  	}
  1553  
  1554  	return r0, r1
  1555  }
  1556  
  1557  // GetPublicChannelsForTeam provides a mock function with given fields: teamId, page, perPage
  1558  func (_m *API) GetPublicChannelsForTeam(teamId string, page int, perPage int) ([]*model.Channel, *model.AppError) {
  1559  	ret := _m.Called(teamId, page, perPage)
  1560  
  1561  	var r0 []*model.Channel
  1562  	if rf, ok := ret.Get(0).(func(string, int, int) []*model.Channel); ok {
  1563  		r0 = rf(teamId, page, perPage)
  1564  	} else {
  1565  		if ret.Get(0) != nil {
  1566  			r0 = ret.Get(0).([]*model.Channel)
  1567  		}
  1568  	}
  1569  
  1570  	var r1 *model.AppError
  1571  	if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
  1572  		r1 = rf(teamId, page, perPage)
  1573  	} else {
  1574  		if ret.Get(1) != nil {
  1575  			r1 = ret.Get(1).(*model.AppError)
  1576  		}
  1577  	}
  1578  
  1579  	return r0, r1
  1580  }
  1581  
  1582  // GetReactions provides a mock function with given fields: postId
  1583  func (_m *API) GetReactions(postId string) ([]*model.Reaction, *model.AppError) {
  1584  	ret := _m.Called(postId)
  1585  
  1586  	var r0 []*model.Reaction
  1587  	if rf, ok := ret.Get(0).(func(string) []*model.Reaction); ok {
  1588  		r0 = rf(postId)
  1589  	} else {
  1590  		if ret.Get(0) != nil {
  1591  			r0 = ret.Get(0).([]*model.Reaction)
  1592  		}
  1593  	}
  1594  
  1595  	var r1 *model.AppError
  1596  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1597  		r1 = rf(postId)
  1598  	} else {
  1599  		if ret.Get(1) != nil {
  1600  			r1 = ret.Get(1).(*model.AppError)
  1601  		}
  1602  	}
  1603  
  1604  	return r0, r1
  1605  }
  1606  
  1607  // GetServerVersion provides a mock function with given fields:
  1608  func (_m *API) GetServerVersion() string {
  1609  	ret := _m.Called()
  1610  
  1611  	var r0 string
  1612  	if rf, ok := ret.Get(0).(func() string); ok {
  1613  		r0 = rf()
  1614  	} else {
  1615  		r0 = ret.Get(0).(string)
  1616  	}
  1617  
  1618  	return r0
  1619  }
  1620  
  1621  // GetSession provides a mock function with given fields: sessionId
  1622  func (_m *API) GetSession(sessionId string) (*model.Session, *model.AppError) {
  1623  	ret := _m.Called(sessionId)
  1624  
  1625  	var r0 *model.Session
  1626  	if rf, ok := ret.Get(0).(func(string) *model.Session); ok {
  1627  		r0 = rf(sessionId)
  1628  	} else {
  1629  		if ret.Get(0) != nil {
  1630  			r0 = ret.Get(0).(*model.Session)
  1631  		}
  1632  	}
  1633  
  1634  	var r1 *model.AppError
  1635  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1636  		r1 = rf(sessionId)
  1637  	} else {
  1638  		if ret.Get(1) != nil {
  1639  			r1 = ret.Get(1).(*model.AppError)
  1640  		}
  1641  	}
  1642  
  1643  	return r0, r1
  1644  }
  1645  
  1646  // GetSystemInstallDate provides a mock function with given fields:
  1647  func (_m *API) GetSystemInstallDate() (int64, *model.AppError) {
  1648  	ret := _m.Called()
  1649  
  1650  	var r0 int64
  1651  	if rf, ok := ret.Get(0).(func() int64); ok {
  1652  		r0 = rf()
  1653  	} else {
  1654  		r0 = ret.Get(0).(int64)
  1655  	}
  1656  
  1657  	var r1 *model.AppError
  1658  	if rf, ok := ret.Get(1).(func() *model.AppError); ok {
  1659  		r1 = rf()
  1660  	} else {
  1661  		if ret.Get(1) != nil {
  1662  			r1 = ret.Get(1).(*model.AppError)
  1663  		}
  1664  	}
  1665  
  1666  	return r0, r1
  1667  }
  1668  
  1669  // GetTeam provides a mock function with given fields: teamId
  1670  func (_m *API) GetTeam(teamId string) (*model.Team, *model.AppError) {
  1671  	ret := _m.Called(teamId)
  1672  
  1673  	var r0 *model.Team
  1674  	if rf, ok := ret.Get(0).(func(string) *model.Team); ok {
  1675  		r0 = rf(teamId)
  1676  	} else {
  1677  		if ret.Get(0) != nil {
  1678  			r0 = ret.Get(0).(*model.Team)
  1679  		}
  1680  	}
  1681  
  1682  	var r1 *model.AppError
  1683  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1684  		r1 = rf(teamId)
  1685  	} else {
  1686  		if ret.Get(1) != nil {
  1687  			r1 = ret.Get(1).(*model.AppError)
  1688  		}
  1689  	}
  1690  
  1691  	return r0, r1
  1692  }
  1693  
  1694  // GetTeamByName provides a mock function with given fields: name
  1695  func (_m *API) GetTeamByName(name string) (*model.Team, *model.AppError) {
  1696  	ret := _m.Called(name)
  1697  
  1698  	var r0 *model.Team
  1699  	if rf, ok := ret.Get(0).(func(string) *model.Team); ok {
  1700  		r0 = rf(name)
  1701  	} else {
  1702  		if ret.Get(0) != nil {
  1703  			r0 = ret.Get(0).(*model.Team)
  1704  		}
  1705  	}
  1706  
  1707  	var r1 *model.AppError
  1708  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1709  		r1 = rf(name)
  1710  	} else {
  1711  		if ret.Get(1) != nil {
  1712  			r1 = ret.Get(1).(*model.AppError)
  1713  		}
  1714  	}
  1715  
  1716  	return r0, r1
  1717  }
  1718  
  1719  // GetTeamIcon provides a mock function with given fields: teamId
  1720  func (_m *API) GetTeamIcon(teamId string) ([]byte, *model.AppError) {
  1721  	ret := _m.Called(teamId)
  1722  
  1723  	var r0 []byte
  1724  	if rf, ok := ret.Get(0).(func(string) []byte); ok {
  1725  		r0 = rf(teamId)
  1726  	} else {
  1727  		if ret.Get(0) != nil {
  1728  			r0 = ret.Get(0).([]byte)
  1729  		}
  1730  	}
  1731  
  1732  	var r1 *model.AppError
  1733  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1734  		r1 = rf(teamId)
  1735  	} else {
  1736  		if ret.Get(1) != nil {
  1737  			r1 = ret.Get(1).(*model.AppError)
  1738  		}
  1739  	}
  1740  
  1741  	return r0, r1
  1742  }
  1743  
  1744  // GetTeamMember provides a mock function with given fields: teamId, userId
  1745  func (_m *API) GetTeamMember(teamId string, userId string) (*model.TeamMember, *model.AppError) {
  1746  	ret := _m.Called(teamId, userId)
  1747  
  1748  	var r0 *model.TeamMember
  1749  	if rf, ok := ret.Get(0).(func(string, string) *model.TeamMember); ok {
  1750  		r0 = rf(teamId, userId)
  1751  	} else {
  1752  		if ret.Get(0) != nil {
  1753  			r0 = ret.Get(0).(*model.TeamMember)
  1754  		}
  1755  	}
  1756  
  1757  	var r1 *model.AppError
  1758  	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
  1759  		r1 = rf(teamId, userId)
  1760  	} else {
  1761  		if ret.Get(1) != nil {
  1762  			r1 = ret.Get(1).(*model.AppError)
  1763  		}
  1764  	}
  1765  
  1766  	return r0, r1
  1767  }
  1768  
  1769  // GetTeamMembers provides a mock function with given fields: teamId, page, perPage
  1770  func (_m *API) GetTeamMembers(teamId string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
  1771  	ret := _m.Called(teamId, page, perPage)
  1772  
  1773  	var r0 []*model.TeamMember
  1774  	if rf, ok := ret.Get(0).(func(string, int, int) []*model.TeamMember); ok {
  1775  		r0 = rf(teamId, page, perPage)
  1776  	} else {
  1777  		if ret.Get(0) != nil {
  1778  			r0 = ret.Get(0).([]*model.TeamMember)
  1779  		}
  1780  	}
  1781  
  1782  	var r1 *model.AppError
  1783  	if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
  1784  		r1 = rf(teamId, page, perPage)
  1785  	} else {
  1786  		if ret.Get(1) != nil {
  1787  			r1 = ret.Get(1).(*model.AppError)
  1788  		}
  1789  	}
  1790  
  1791  	return r0, r1
  1792  }
  1793  
  1794  // GetTeamMembersForUser provides a mock function with given fields: userId, page, perPage
  1795  func (_m *API) GetTeamMembersForUser(userId string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
  1796  	ret := _m.Called(userId, page, perPage)
  1797  
  1798  	var r0 []*model.TeamMember
  1799  	if rf, ok := ret.Get(0).(func(string, int, int) []*model.TeamMember); ok {
  1800  		r0 = rf(userId, page, perPage)
  1801  	} else {
  1802  		if ret.Get(0) != nil {
  1803  			r0 = ret.Get(0).([]*model.TeamMember)
  1804  		}
  1805  	}
  1806  
  1807  	var r1 *model.AppError
  1808  	if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
  1809  		r1 = rf(userId, page, perPage)
  1810  	} else {
  1811  		if ret.Get(1) != nil {
  1812  			r1 = ret.Get(1).(*model.AppError)
  1813  		}
  1814  	}
  1815  
  1816  	return r0, r1
  1817  }
  1818  
  1819  // GetTeamStats provides a mock function with given fields: teamId
  1820  func (_m *API) GetTeamStats(teamId string) (*model.TeamStats, *model.AppError) {
  1821  	ret := _m.Called(teamId)
  1822  
  1823  	var r0 *model.TeamStats
  1824  	if rf, ok := ret.Get(0).(func(string) *model.TeamStats); ok {
  1825  		r0 = rf(teamId)
  1826  	} else {
  1827  		if ret.Get(0) != nil {
  1828  			r0 = ret.Get(0).(*model.TeamStats)
  1829  		}
  1830  	}
  1831  
  1832  	var r1 *model.AppError
  1833  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1834  		r1 = rf(teamId)
  1835  	} else {
  1836  		if ret.Get(1) != nil {
  1837  			r1 = ret.Get(1).(*model.AppError)
  1838  		}
  1839  	}
  1840  
  1841  	return r0, r1
  1842  }
  1843  
  1844  // GetTeams provides a mock function with given fields:
  1845  func (_m *API) GetTeams() ([]*model.Team, *model.AppError) {
  1846  	ret := _m.Called()
  1847  
  1848  	var r0 []*model.Team
  1849  	if rf, ok := ret.Get(0).(func() []*model.Team); ok {
  1850  		r0 = rf()
  1851  	} else {
  1852  		if ret.Get(0) != nil {
  1853  			r0 = ret.Get(0).([]*model.Team)
  1854  		}
  1855  	}
  1856  
  1857  	var r1 *model.AppError
  1858  	if rf, ok := ret.Get(1).(func() *model.AppError); ok {
  1859  		r1 = rf()
  1860  	} else {
  1861  		if ret.Get(1) != nil {
  1862  			r1 = ret.Get(1).(*model.AppError)
  1863  		}
  1864  	}
  1865  
  1866  	return r0, r1
  1867  }
  1868  
  1869  // GetTeamsForUser provides a mock function with given fields: userId
  1870  func (_m *API) GetTeamsForUser(userId string) ([]*model.Team, *model.AppError) {
  1871  	ret := _m.Called(userId)
  1872  
  1873  	var r0 []*model.Team
  1874  	if rf, ok := ret.Get(0).(func(string) []*model.Team); ok {
  1875  		r0 = rf(userId)
  1876  	} else {
  1877  		if ret.Get(0) != nil {
  1878  			r0 = ret.Get(0).([]*model.Team)
  1879  		}
  1880  	}
  1881  
  1882  	var r1 *model.AppError
  1883  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1884  		r1 = rf(userId)
  1885  	} else {
  1886  		if ret.Get(1) != nil {
  1887  			r1 = ret.Get(1).(*model.AppError)
  1888  		}
  1889  	}
  1890  
  1891  	return r0, r1
  1892  }
  1893  
  1894  // GetTeamsUnreadForUser provides a mock function with given fields: userId
  1895  func (_m *API) GetTeamsUnreadForUser(userId string) ([]*model.TeamUnread, *model.AppError) {
  1896  	ret := _m.Called(userId)
  1897  
  1898  	var r0 []*model.TeamUnread
  1899  	if rf, ok := ret.Get(0).(func(string) []*model.TeamUnread); ok {
  1900  		r0 = rf(userId)
  1901  	} else {
  1902  		if ret.Get(0) != nil {
  1903  			r0 = ret.Get(0).([]*model.TeamUnread)
  1904  		}
  1905  	}
  1906  
  1907  	var r1 *model.AppError
  1908  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1909  		r1 = rf(userId)
  1910  	} else {
  1911  		if ret.Get(1) != nil {
  1912  			r1 = ret.Get(1).(*model.AppError)
  1913  		}
  1914  	}
  1915  
  1916  	return r0, r1
  1917  }
  1918  
  1919  // GetTelemetryId provides a mock function with given fields:
  1920  func (_m *API) GetTelemetryId() string {
  1921  	ret := _m.Called()
  1922  
  1923  	var r0 string
  1924  	if rf, ok := ret.Get(0).(func() string); ok {
  1925  		r0 = rf()
  1926  	} else {
  1927  		r0 = ret.Get(0).(string)
  1928  	}
  1929  
  1930  	return r0
  1931  }
  1932  
  1933  // GetUnsanitizedConfig provides a mock function with given fields:
  1934  func (_m *API) GetUnsanitizedConfig() *model.Config {
  1935  	ret := _m.Called()
  1936  
  1937  	var r0 *model.Config
  1938  	if rf, ok := ret.Get(0).(func() *model.Config); ok {
  1939  		r0 = rf()
  1940  	} else {
  1941  		if ret.Get(0) != nil {
  1942  			r0 = ret.Get(0).(*model.Config)
  1943  		}
  1944  	}
  1945  
  1946  	return r0
  1947  }
  1948  
  1949  // GetUser provides a mock function with given fields: userId
  1950  func (_m *API) GetUser(userId string) (*model.User, *model.AppError) {
  1951  	ret := _m.Called(userId)
  1952  
  1953  	var r0 *model.User
  1954  	if rf, ok := ret.Get(0).(func(string) *model.User); ok {
  1955  		r0 = rf(userId)
  1956  	} else {
  1957  		if ret.Get(0) != nil {
  1958  			r0 = ret.Get(0).(*model.User)
  1959  		}
  1960  	}
  1961  
  1962  	var r1 *model.AppError
  1963  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1964  		r1 = rf(userId)
  1965  	} else {
  1966  		if ret.Get(1) != nil {
  1967  			r1 = ret.Get(1).(*model.AppError)
  1968  		}
  1969  	}
  1970  
  1971  	return r0, r1
  1972  }
  1973  
  1974  // GetUserByEmail provides a mock function with given fields: email
  1975  func (_m *API) GetUserByEmail(email string) (*model.User, *model.AppError) {
  1976  	ret := _m.Called(email)
  1977  
  1978  	var r0 *model.User
  1979  	if rf, ok := ret.Get(0).(func(string) *model.User); ok {
  1980  		r0 = rf(email)
  1981  	} else {
  1982  		if ret.Get(0) != nil {
  1983  			r0 = ret.Get(0).(*model.User)
  1984  		}
  1985  	}
  1986  
  1987  	var r1 *model.AppError
  1988  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  1989  		r1 = rf(email)
  1990  	} else {
  1991  		if ret.Get(1) != nil {
  1992  			r1 = ret.Get(1).(*model.AppError)
  1993  		}
  1994  	}
  1995  
  1996  	return r0, r1
  1997  }
  1998  
  1999  // GetUserByUsername provides a mock function with given fields: name
  2000  func (_m *API) GetUserByUsername(name string) (*model.User, *model.AppError) {
  2001  	ret := _m.Called(name)
  2002  
  2003  	var r0 *model.User
  2004  	if rf, ok := ret.Get(0).(func(string) *model.User); ok {
  2005  		r0 = rf(name)
  2006  	} else {
  2007  		if ret.Get(0) != nil {
  2008  			r0 = ret.Get(0).(*model.User)
  2009  		}
  2010  	}
  2011  
  2012  	var r1 *model.AppError
  2013  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  2014  		r1 = rf(name)
  2015  	} else {
  2016  		if ret.Get(1) != nil {
  2017  			r1 = ret.Get(1).(*model.AppError)
  2018  		}
  2019  	}
  2020  
  2021  	return r0, r1
  2022  }
  2023  
  2024  // GetUserStatus provides a mock function with given fields: userId
  2025  func (_m *API) GetUserStatus(userId string) (*model.Status, *model.AppError) {
  2026  	ret := _m.Called(userId)
  2027  
  2028  	var r0 *model.Status
  2029  	if rf, ok := ret.Get(0).(func(string) *model.Status); ok {
  2030  		r0 = rf(userId)
  2031  	} else {
  2032  		if ret.Get(0) != nil {
  2033  			r0 = ret.Get(0).(*model.Status)
  2034  		}
  2035  	}
  2036  
  2037  	var r1 *model.AppError
  2038  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  2039  		r1 = rf(userId)
  2040  	} else {
  2041  		if ret.Get(1) != nil {
  2042  			r1 = ret.Get(1).(*model.AppError)
  2043  		}
  2044  	}
  2045  
  2046  	return r0, r1
  2047  }
  2048  
  2049  // GetUserStatusesByIds provides a mock function with given fields: userIds
  2050  func (_m *API) GetUserStatusesByIds(userIds []string) ([]*model.Status, *model.AppError) {
  2051  	ret := _m.Called(userIds)
  2052  
  2053  	var r0 []*model.Status
  2054  	if rf, ok := ret.Get(0).(func([]string) []*model.Status); ok {
  2055  		r0 = rf(userIds)
  2056  	} else {
  2057  		if ret.Get(0) != nil {
  2058  			r0 = ret.Get(0).([]*model.Status)
  2059  		}
  2060  	}
  2061  
  2062  	var r1 *model.AppError
  2063  	if rf, ok := ret.Get(1).(func([]string) *model.AppError); ok {
  2064  		r1 = rf(userIds)
  2065  	} else {
  2066  		if ret.Get(1) != nil {
  2067  			r1 = ret.Get(1).(*model.AppError)
  2068  		}
  2069  	}
  2070  
  2071  	return r0, r1
  2072  }
  2073  
  2074  // GetUsers provides a mock function with given fields: options
  2075  func (_m *API) GetUsers(options *model.UserGetOptions) ([]*model.User, *model.AppError) {
  2076  	ret := _m.Called(options)
  2077  
  2078  	var r0 []*model.User
  2079  	if rf, ok := ret.Get(0).(func(*model.UserGetOptions) []*model.User); ok {
  2080  		r0 = rf(options)
  2081  	} else {
  2082  		if ret.Get(0) != nil {
  2083  			r0 = ret.Get(0).([]*model.User)
  2084  		}
  2085  	}
  2086  
  2087  	var r1 *model.AppError
  2088  	if rf, ok := ret.Get(1).(func(*model.UserGetOptions) *model.AppError); ok {
  2089  		r1 = rf(options)
  2090  	} else {
  2091  		if ret.Get(1) != nil {
  2092  			r1 = ret.Get(1).(*model.AppError)
  2093  		}
  2094  	}
  2095  
  2096  	return r0, r1
  2097  }
  2098  
  2099  // GetUsersByUsernames provides a mock function with given fields: usernames
  2100  func (_m *API) GetUsersByUsernames(usernames []string) ([]*model.User, *model.AppError) {
  2101  	ret := _m.Called(usernames)
  2102  
  2103  	var r0 []*model.User
  2104  	if rf, ok := ret.Get(0).(func([]string) []*model.User); ok {
  2105  		r0 = rf(usernames)
  2106  	} else {
  2107  		if ret.Get(0) != nil {
  2108  			r0 = ret.Get(0).([]*model.User)
  2109  		}
  2110  	}
  2111  
  2112  	var r1 *model.AppError
  2113  	if rf, ok := ret.Get(1).(func([]string) *model.AppError); ok {
  2114  		r1 = rf(usernames)
  2115  	} else {
  2116  		if ret.Get(1) != nil {
  2117  			r1 = ret.Get(1).(*model.AppError)
  2118  		}
  2119  	}
  2120  
  2121  	return r0, r1
  2122  }
  2123  
  2124  // GetUsersInChannel provides a mock function with given fields: channelId, sortBy, page, perPage
  2125  func (_m *API) GetUsersInChannel(channelId string, sortBy string, page int, perPage int) ([]*model.User, *model.AppError) {
  2126  	ret := _m.Called(channelId, sortBy, page, perPage)
  2127  
  2128  	var r0 []*model.User
  2129  	if rf, ok := ret.Get(0).(func(string, string, int, int) []*model.User); ok {
  2130  		r0 = rf(channelId, sortBy, page, perPage)
  2131  	} else {
  2132  		if ret.Get(0) != nil {
  2133  			r0 = ret.Get(0).([]*model.User)
  2134  		}
  2135  	}
  2136  
  2137  	var r1 *model.AppError
  2138  	if rf, ok := ret.Get(1).(func(string, string, int, int) *model.AppError); ok {
  2139  		r1 = rf(channelId, sortBy, page, perPage)
  2140  	} else {
  2141  		if ret.Get(1) != nil {
  2142  			r1 = ret.Get(1).(*model.AppError)
  2143  		}
  2144  	}
  2145  
  2146  	return r0, r1
  2147  }
  2148  
  2149  // GetUsersInTeam provides a mock function with given fields: teamId, page, perPage
  2150  func (_m *API) GetUsersInTeam(teamId string, page int, perPage int) ([]*model.User, *model.AppError) {
  2151  	ret := _m.Called(teamId, page, perPage)
  2152  
  2153  	var r0 []*model.User
  2154  	if rf, ok := ret.Get(0).(func(string, int, int) []*model.User); ok {
  2155  		r0 = rf(teamId, page, perPage)
  2156  	} else {
  2157  		if ret.Get(0) != nil {
  2158  			r0 = ret.Get(0).([]*model.User)
  2159  		}
  2160  	}
  2161  
  2162  	var r1 *model.AppError
  2163  	if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
  2164  		r1 = rf(teamId, page, perPage)
  2165  	} else {
  2166  		if ret.Get(1) != nil {
  2167  			r1 = ret.Get(1).(*model.AppError)
  2168  		}
  2169  	}
  2170  
  2171  	return r0, r1
  2172  }
  2173  
  2174  // HasPermissionTo provides a mock function with given fields: userId, permission
  2175  func (_m *API) HasPermissionTo(userId string, permission *model.Permission) bool {
  2176  	ret := _m.Called(userId, permission)
  2177  
  2178  	var r0 bool
  2179  	if rf, ok := ret.Get(0).(func(string, *model.Permission) bool); ok {
  2180  		r0 = rf(userId, permission)
  2181  	} else {
  2182  		r0 = ret.Get(0).(bool)
  2183  	}
  2184  
  2185  	return r0
  2186  }
  2187  
  2188  // HasPermissionToChannel provides a mock function with given fields: userId, channelId, permission
  2189  func (_m *API) HasPermissionToChannel(userId string, channelId string, permission *model.Permission) bool {
  2190  	ret := _m.Called(userId, channelId, permission)
  2191  
  2192  	var r0 bool
  2193  	if rf, ok := ret.Get(0).(func(string, string, *model.Permission) bool); ok {
  2194  		r0 = rf(userId, channelId, permission)
  2195  	} else {
  2196  		r0 = ret.Get(0).(bool)
  2197  	}
  2198  
  2199  	return r0
  2200  }
  2201  
  2202  // HasPermissionToTeam provides a mock function with given fields: userId, teamId, permission
  2203  func (_m *API) HasPermissionToTeam(userId string, teamId string, permission *model.Permission) bool {
  2204  	ret := _m.Called(userId, teamId, permission)
  2205  
  2206  	var r0 bool
  2207  	if rf, ok := ret.Get(0).(func(string, string, *model.Permission) bool); ok {
  2208  		r0 = rf(userId, teamId, permission)
  2209  	} else {
  2210  		r0 = ret.Get(0).(bool)
  2211  	}
  2212  
  2213  	return r0
  2214  }
  2215  
  2216  // InstallPlugin provides a mock function with given fields: file, replace
  2217  func (_m *API) InstallPlugin(file io.Reader, replace bool) (*model.Manifest, *model.AppError) {
  2218  	ret := _m.Called(file, replace)
  2219  
  2220  	var r0 *model.Manifest
  2221  	if rf, ok := ret.Get(0).(func(io.Reader, bool) *model.Manifest); ok {
  2222  		r0 = rf(file, replace)
  2223  	} else {
  2224  		if ret.Get(0) != nil {
  2225  			r0 = ret.Get(0).(*model.Manifest)
  2226  		}
  2227  	}
  2228  
  2229  	var r1 *model.AppError
  2230  	if rf, ok := ret.Get(1).(func(io.Reader, bool) *model.AppError); ok {
  2231  		r1 = rf(file, replace)
  2232  	} else {
  2233  		if ret.Get(1) != nil {
  2234  			r1 = ret.Get(1).(*model.AppError)
  2235  		}
  2236  	}
  2237  
  2238  	return r0, r1
  2239  }
  2240  
  2241  // KVCompareAndDelete provides a mock function with given fields: key, oldValue
  2242  func (_m *API) KVCompareAndDelete(key string, oldValue []byte) (bool, *model.AppError) {
  2243  	ret := _m.Called(key, oldValue)
  2244  
  2245  	var r0 bool
  2246  	if rf, ok := ret.Get(0).(func(string, []byte) bool); ok {
  2247  		r0 = rf(key, oldValue)
  2248  	} else {
  2249  		r0 = ret.Get(0).(bool)
  2250  	}
  2251  
  2252  	var r1 *model.AppError
  2253  	if rf, ok := ret.Get(1).(func(string, []byte) *model.AppError); ok {
  2254  		r1 = rf(key, oldValue)
  2255  	} else {
  2256  		if ret.Get(1) != nil {
  2257  			r1 = ret.Get(1).(*model.AppError)
  2258  		}
  2259  	}
  2260  
  2261  	return r0, r1
  2262  }
  2263  
  2264  // KVCompareAndSet provides a mock function with given fields: key, oldValue, newValue
  2265  func (_m *API) KVCompareAndSet(key string, oldValue []byte, newValue []byte) (bool, *model.AppError) {
  2266  	ret := _m.Called(key, oldValue, newValue)
  2267  
  2268  	var r0 bool
  2269  	if rf, ok := ret.Get(0).(func(string, []byte, []byte) bool); ok {
  2270  		r0 = rf(key, oldValue, newValue)
  2271  	} else {
  2272  		r0 = ret.Get(0).(bool)
  2273  	}
  2274  
  2275  	var r1 *model.AppError
  2276  	if rf, ok := ret.Get(1).(func(string, []byte, []byte) *model.AppError); ok {
  2277  		r1 = rf(key, oldValue, newValue)
  2278  	} else {
  2279  		if ret.Get(1) != nil {
  2280  			r1 = ret.Get(1).(*model.AppError)
  2281  		}
  2282  	}
  2283  
  2284  	return r0, r1
  2285  }
  2286  
  2287  // KVDelete provides a mock function with given fields: key
  2288  func (_m *API) KVDelete(key string) *model.AppError {
  2289  	ret := _m.Called(key)
  2290  
  2291  	var r0 *model.AppError
  2292  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
  2293  		r0 = rf(key)
  2294  	} else {
  2295  		if ret.Get(0) != nil {
  2296  			r0 = ret.Get(0).(*model.AppError)
  2297  		}
  2298  	}
  2299  
  2300  	return r0
  2301  }
  2302  
  2303  // KVDeleteAll provides a mock function with given fields:
  2304  func (_m *API) KVDeleteAll() *model.AppError {
  2305  	ret := _m.Called()
  2306  
  2307  	var r0 *model.AppError
  2308  	if rf, ok := ret.Get(0).(func() *model.AppError); ok {
  2309  		r0 = rf()
  2310  	} else {
  2311  		if ret.Get(0) != nil {
  2312  			r0 = ret.Get(0).(*model.AppError)
  2313  		}
  2314  	}
  2315  
  2316  	return r0
  2317  }
  2318  
  2319  // KVGet provides a mock function with given fields: key
  2320  func (_m *API) KVGet(key string) ([]byte, *model.AppError) {
  2321  	ret := _m.Called(key)
  2322  
  2323  	var r0 []byte
  2324  	if rf, ok := ret.Get(0).(func(string) []byte); ok {
  2325  		r0 = rf(key)
  2326  	} else {
  2327  		if ret.Get(0) != nil {
  2328  			r0 = ret.Get(0).([]byte)
  2329  		}
  2330  	}
  2331  
  2332  	var r1 *model.AppError
  2333  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  2334  		r1 = rf(key)
  2335  	} else {
  2336  		if ret.Get(1) != nil {
  2337  			r1 = ret.Get(1).(*model.AppError)
  2338  		}
  2339  	}
  2340  
  2341  	return r0, r1
  2342  }
  2343  
  2344  // KVList provides a mock function with given fields: page, perPage
  2345  func (_m *API) KVList(page int, perPage int) ([]string, *model.AppError) {
  2346  	ret := _m.Called(page, perPage)
  2347  
  2348  	var r0 []string
  2349  	if rf, ok := ret.Get(0).(func(int, int) []string); ok {
  2350  		r0 = rf(page, perPage)
  2351  	} else {
  2352  		if ret.Get(0) != nil {
  2353  			r0 = ret.Get(0).([]string)
  2354  		}
  2355  	}
  2356  
  2357  	var r1 *model.AppError
  2358  	if rf, ok := ret.Get(1).(func(int, int) *model.AppError); ok {
  2359  		r1 = rf(page, perPage)
  2360  	} else {
  2361  		if ret.Get(1) != nil {
  2362  			r1 = ret.Get(1).(*model.AppError)
  2363  		}
  2364  	}
  2365  
  2366  	return r0, r1
  2367  }
  2368  
  2369  // KVSet provides a mock function with given fields: key, value
  2370  func (_m *API) KVSet(key string, value []byte) *model.AppError {
  2371  	ret := _m.Called(key, value)
  2372  
  2373  	var r0 *model.AppError
  2374  	if rf, ok := ret.Get(0).(func(string, []byte) *model.AppError); ok {
  2375  		r0 = rf(key, value)
  2376  	} else {
  2377  		if ret.Get(0) != nil {
  2378  			r0 = ret.Get(0).(*model.AppError)
  2379  		}
  2380  	}
  2381  
  2382  	return r0
  2383  }
  2384  
  2385  // KVSetWithExpiry provides a mock function with given fields: key, value, expireInSeconds
  2386  func (_m *API) KVSetWithExpiry(key string, value []byte, expireInSeconds int64) *model.AppError {
  2387  	ret := _m.Called(key, value, expireInSeconds)
  2388  
  2389  	var r0 *model.AppError
  2390  	if rf, ok := ret.Get(0).(func(string, []byte, int64) *model.AppError); ok {
  2391  		r0 = rf(key, value, expireInSeconds)
  2392  	} else {
  2393  		if ret.Get(0) != nil {
  2394  			r0 = ret.Get(0).(*model.AppError)
  2395  		}
  2396  	}
  2397  
  2398  	return r0
  2399  }
  2400  
  2401  // KVSetWithOptions provides a mock function with given fields: key, value, options
  2402  func (_m *API) KVSetWithOptions(key string, value []byte, options model.PluginKVSetOptions) (bool, *model.AppError) {
  2403  	ret := _m.Called(key, value, options)
  2404  
  2405  	var r0 bool
  2406  	if rf, ok := ret.Get(0).(func(string, []byte, model.PluginKVSetOptions) bool); ok {
  2407  		r0 = rf(key, value, options)
  2408  	} else {
  2409  		r0 = ret.Get(0).(bool)
  2410  	}
  2411  
  2412  	var r1 *model.AppError
  2413  	if rf, ok := ret.Get(1).(func(string, []byte, model.PluginKVSetOptions) *model.AppError); ok {
  2414  		r1 = rf(key, value, options)
  2415  	} else {
  2416  		if ret.Get(1) != nil {
  2417  			r1 = ret.Get(1).(*model.AppError)
  2418  		}
  2419  	}
  2420  
  2421  	return r0, r1
  2422  }
  2423  
  2424  // ListBuiltInCommands provides a mock function with given fields:
  2425  func (_m *API) ListBuiltInCommands() ([]*model.Command, error) {
  2426  	ret := _m.Called()
  2427  
  2428  	var r0 []*model.Command
  2429  	if rf, ok := ret.Get(0).(func() []*model.Command); ok {
  2430  		r0 = rf()
  2431  	} else {
  2432  		if ret.Get(0) != nil {
  2433  			r0 = ret.Get(0).([]*model.Command)
  2434  		}
  2435  	}
  2436  
  2437  	var r1 error
  2438  	if rf, ok := ret.Get(1).(func() error); ok {
  2439  		r1 = rf()
  2440  	} else {
  2441  		r1 = ret.Error(1)
  2442  	}
  2443  
  2444  	return r0, r1
  2445  }
  2446  
  2447  // ListCommands provides a mock function with given fields: teamID
  2448  func (_m *API) ListCommands(teamID string) ([]*model.Command, error) {
  2449  	ret := _m.Called(teamID)
  2450  
  2451  	var r0 []*model.Command
  2452  	if rf, ok := ret.Get(0).(func(string) []*model.Command); ok {
  2453  		r0 = rf(teamID)
  2454  	} else {
  2455  		if ret.Get(0) != nil {
  2456  			r0 = ret.Get(0).([]*model.Command)
  2457  		}
  2458  	}
  2459  
  2460  	var r1 error
  2461  	if rf, ok := ret.Get(1).(func(string) error); ok {
  2462  		r1 = rf(teamID)
  2463  	} else {
  2464  		r1 = ret.Error(1)
  2465  	}
  2466  
  2467  	return r0, r1
  2468  }
  2469  
  2470  // ListCustomCommands provides a mock function with given fields: teamID
  2471  func (_m *API) ListCustomCommands(teamID string) ([]*model.Command, error) {
  2472  	ret := _m.Called(teamID)
  2473  
  2474  	var r0 []*model.Command
  2475  	if rf, ok := ret.Get(0).(func(string) []*model.Command); ok {
  2476  		r0 = rf(teamID)
  2477  	} else {
  2478  		if ret.Get(0) != nil {
  2479  			r0 = ret.Get(0).([]*model.Command)
  2480  		}
  2481  	}
  2482  
  2483  	var r1 error
  2484  	if rf, ok := ret.Get(1).(func(string) error); ok {
  2485  		r1 = rf(teamID)
  2486  	} else {
  2487  		r1 = ret.Error(1)
  2488  	}
  2489  
  2490  	return r0, r1
  2491  }
  2492  
  2493  // ListPluginCommands provides a mock function with given fields: teamID
  2494  func (_m *API) ListPluginCommands(teamID string) ([]*model.Command, error) {
  2495  	ret := _m.Called(teamID)
  2496  
  2497  	var r0 []*model.Command
  2498  	if rf, ok := ret.Get(0).(func(string) []*model.Command); ok {
  2499  		r0 = rf(teamID)
  2500  	} else {
  2501  		if ret.Get(0) != nil {
  2502  			r0 = ret.Get(0).([]*model.Command)
  2503  		}
  2504  	}
  2505  
  2506  	var r1 error
  2507  	if rf, ok := ret.Get(1).(func(string) error); ok {
  2508  		r1 = rf(teamID)
  2509  	} else {
  2510  		r1 = ret.Error(1)
  2511  	}
  2512  
  2513  	return r0, r1
  2514  }
  2515  
  2516  // LoadPluginConfiguration provides a mock function with given fields: dest
  2517  func (_m *API) LoadPluginConfiguration(dest interface{}) error {
  2518  	ret := _m.Called(dest)
  2519  
  2520  	var r0 error
  2521  	if rf, ok := ret.Get(0).(func(interface{}) error); ok {
  2522  		r0 = rf(dest)
  2523  	} else {
  2524  		r0 = ret.Error(0)
  2525  	}
  2526  
  2527  	return r0
  2528  }
  2529  
  2530  // LogDebug provides a mock function with given fields: msg, keyValuePairs
  2531  func (_m *API) LogDebug(msg string, keyValuePairs ...interface{}) {
  2532  	var _ca []interface{}
  2533  	_ca = append(_ca, msg)
  2534  	_ca = append(_ca, keyValuePairs...)
  2535  	_m.Called(_ca...)
  2536  }
  2537  
  2538  // LogError provides a mock function with given fields: msg, keyValuePairs
  2539  func (_m *API) LogError(msg string, keyValuePairs ...interface{}) {
  2540  	var _ca []interface{}
  2541  	_ca = append(_ca, msg)
  2542  	_ca = append(_ca, keyValuePairs...)
  2543  	_m.Called(_ca...)
  2544  }
  2545  
  2546  // LogInfo provides a mock function with given fields: msg, keyValuePairs
  2547  func (_m *API) LogInfo(msg string, keyValuePairs ...interface{}) {
  2548  	var _ca []interface{}
  2549  	_ca = append(_ca, msg)
  2550  	_ca = append(_ca, keyValuePairs...)
  2551  	_m.Called(_ca...)
  2552  }
  2553  
  2554  // LogWarn provides a mock function with given fields: msg, keyValuePairs
  2555  func (_m *API) LogWarn(msg string, keyValuePairs ...interface{}) {
  2556  	var _ca []interface{}
  2557  	_ca = append(_ca, msg)
  2558  	_ca = append(_ca, keyValuePairs...)
  2559  	_m.Called(_ca...)
  2560  }
  2561  
  2562  // OpenInteractiveDialog provides a mock function with given fields: dialog
  2563  func (_m *API) OpenInteractiveDialog(dialog model.OpenDialogRequest) *model.AppError {
  2564  	ret := _m.Called(dialog)
  2565  
  2566  	var r0 *model.AppError
  2567  	if rf, ok := ret.Get(0).(func(model.OpenDialogRequest) *model.AppError); ok {
  2568  		r0 = rf(dialog)
  2569  	} else {
  2570  		if ret.Get(0) != nil {
  2571  			r0 = ret.Get(0).(*model.AppError)
  2572  		}
  2573  	}
  2574  
  2575  	return r0
  2576  }
  2577  
  2578  // PatchBot provides a mock function with given fields: botUserId, botPatch
  2579  func (_m *API) PatchBot(botUserId string, botPatch *model.BotPatch) (*model.Bot, *model.AppError) {
  2580  	ret := _m.Called(botUserId, botPatch)
  2581  
  2582  	var r0 *model.Bot
  2583  	if rf, ok := ret.Get(0).(func(string, *model.BotPatch) *model.Bot); ok {
  2584  		r0 = rf(botUserId, botPatch)
  2585  	} else {
  2586  		if ret.Get(0) != nil {
  2587  			r0 = ret.Get(0).(*model.Bot)
  2588  		}
  2589  	}
  2590  
  2591  	var r1 *model.AppError
  2592  	if rf, ok := ret.Get(1).(func(string, *model.BotPatch) *model.AppError); ok {
  2593  		r1 = rf(botUserId, botPatch)
  2594  	} else {
  2595  		if ret.Get(1) != nil {
  2596  			r1 = ret.Get(1).(*model.AppError)
  2597  		}
  2598  	}
  2599  
  2600  	return r0, r1
  2601  }
  2602  
  2603  // PermanentDeleteBot provides a mock function with given fields: botUserId
  2604  func (_m *API) PermanentDeleteBot(botUserId string) *model.AppError {
  2605  	ret := _m.Called(botUserId)
  2606  
  2607  	var r0 *model.AppError
  2608  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
  2609  		r0 = rf(botUserId)
  2610  	} else {
  2611  		if ret.Get(0) != nil {
  2612  			r0 = ret.Get(0).(*model.AppError)
  2613  		}
  2614  	}
  2615  
  2616  	return r0
  2617  }
  2618  
  2619  // PluginHTTP provides a mock function with given fields: request
  2620  func (_m *API) PluginHTTP(request *http.Request) *http.Response {
  2621  	ret := _m.Called(request)
  2622  
  2623  	var r0 *http.Response
  2624  	if rf, ok := ret.Get(0).(func(*http.Request) *http.Response); ok {
  2625  		r0 = rf(request)
  2626  	} else {
  2627  		if ret.Get(0) != nil {
  2628  			r0 = ret.Get(0).(*http.Response)
  2629  		}
  2630  	}
  2631  
  2632  	return r0
  2633  }
  2634  
  2635  // PublishUserTyping provides a mock function with given fields: userId, channelId, parentId
  2636  func (_m *API) PublishUserTyping(userId string, channelId string, parentId string) *model.AppError {
  2637  	ret := _m.Called(userId, channelId, parentId)
  2638  
  2639  	var r0 *model.AppError
  2640  	if rf, ok := ret.Get(0).(func(string, string, string) *model.AppError); ok {
  2641  		r0 = rf(userId, channelId, parentId)
  2642  	} else {
  2643  		if ret.Get(0) != nil {
  2644  			r0 = ret.Get(0).(*model.AppError)
  2645  		}
  2646  	}
  2647  
  2648  	return r0
  2649  }
  2650  
  2651  // PublishWebSocketEvent provides a mock function with given fields: event, payload, broadcast
  2652  func (_m *API) PublishWebSocketEvent(event string, payload map[string]interface{}, broadcast *model.WebsocketBroadcast) {
  2653  	_m.Called(event, payload, broadcast)
  2654  }
  2655  
  2656  // ReadFile provides a mock function with given fields: path
  2657  func (_m *API) ReadFile(path string) ([]byte, *model.AppError) {
  2658  	ret := _m.Called(path)
  2659  
  2660  	var r0 []byte
  2661  	if rf, ok := ret.Get(0).(func(string) []byte); ok {
  2662  		r0 = rf(path)
  2663  	} else {
  2664  		if ret.Get(0) != nil {
  2665  			r0 = ret.Get(0).([]byte)
  2666  		}
  2667  	}
  2668  
  2669  	var r1 *model.AppError
  2670  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  2671  		r1 = rf(path)
  2672  	} else {
  2673  		if ret.Get(1) != nil {
  2674  			r1 = ret.Get(1).(*model.AppError)
  2675  		}
  2676  	}
  2677  
  2678  	return r0, r1
  2679  }
  2680  
  2681  // RegisterCommand provides a mock function with given fields: command
  2682  func (_m *API) RegisterCommand(command *model.Command) error {
  2683  	ret := _m.Called(command)
  2684  
  2685  	var r0 error
  2686  	if rf, ok := ret.Get(0).(func(*model.Command) error); ok {
  2687  		r0 = rf(command)
  2688  	} else {
  2689  		r0 = ret.Error(0)
  2690  	}
  2691  
  2692  	return r0
  2693  }
  2694  
  2695  // RemovePlugin provides a mock function with given fields: id
  2696  func (_m *API) RemovePlugin(id string) *model.AppError {
  2697  	ret := _m.Called(id)
  2698  
  2699  	var r0 *model.AppError
  2700  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
  2701  		r0 = rf(id)
  2702  	} else {
  2703  		if ret.Get(0) != nil {
  2704  			r0 = ret.Get(0).(*model.AppError)
  2705  		}
  2706  	}
  2707  
  2708  	return r0
  2709  }
  2710  
  2711  // RemoveReaction provides a mock function with given fields: reaction
  2712  func (_m *API) RemoveReaction(reaction *model.Reaction) *model.AppError {
  2713  	ret := _m.Called(reaction)
  2714  
  2715  	var r0 *model.AppError
  2716  	if rf, ok := ret.Get(0).(func(*model.Reaction) *model.AppError); ok {
  2717  		r0 = rf(reaction)
  2718  	} else {
  2719  		if ret.Get(0) != nil {
  2720  			r0 = ret.Get(0).(*model.AppError)
  2721  		}
  2722  	}
  2723  
  2724  	return r0
  2725  }
  2726  
  2727  // RemoveTeamIcon provides a mock function with given fields: teamId
  2728  func (_m *API) RemoveTeamIcon(teamId string) *model.AppError {
  2729  	ret := _m.Called(teamId)
  2730  
  2731  	var r0 *model.AppError
  2732  	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
  2733  		r0 = rf(teamId)
  2734  	} else {
  2735  		if ret.Get(0) != nil {
  2736  			r0 = ret.Get(0).(*model.AppError)
  2737  		}
  2738  	}
  2739  
  2740  	return r0
  2741  }
  2742  
  2743  // SaveConfig provides a mock function with given fields: config
  2744  func (_m *API) SaveConfig(config *model.Config) *model.AppError {
  2745  	ret := _m.Called(config)
  2746  
  2747  	var r0 *model.AppError
  2748  	if rf, ok := ret.Get(0).(func(*model.Config) *model.AppError); ok {
  2749  		r0 = rf(config)
  2750  	} else {
  2751  		if ret.Get(0) != nil {
  2752  			r0 = ret.Get(0).(*model.AppError)
  2753  		}
  2754  	}
  2755  
  2756  	return r0
  2757  }
  2758  
  2759  // SavePluginConfig provides a mock function with given fields: config
  2760  func (_m *API) SavePluginConfig(config map[string]interface{}) *model.AppError {
  2761  	ret := _m.Called(config)
  2762  
  2763  	var r0 *model.AppError
  2764  	if rf, ok := ret.Get(0).(func(map[string]interface{}) *model.AppError); ok {
  2765  		r0 = rf(config)
  2766  	} else {
  2767  		if ret.Get(0) != nil {
  2768  			r0 = ret.Get(0).(*model.AppError)
  2769  		}
  2770  	}
  2771  
  2772  	return r0
  2773  }
  2774  
  2775  // SearchChannels provides a mock function with given fields: teamId, term
  2776  func (_m *API) SearchChannels(teamId string, term string) ([]*model.Channel, *model.AppError) {
  2777  	ret := _m.Called(teamId, term)
  2778  
  2779  	var r0 []*model.Channel
  2780  	if rf, ok := ret.Get(0).(func(string, string) []*model.Channel); ok {
  2781  		r0 = rf(teamId, term)
  2782  	} else {
  2783  		if ret.Get(0) != nil {
  2784  			r0 = ret.Get(0).([]*model.Channel)
  2785  		}
  2786  	}
  2787  
  2788  	var r1 *model.AppError
  2789  	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
  2790  		r1 = rf(teamId, term)
  2791  	} else {
  2792  		if ret.Get(1) != nil {
  2793  			r1 = ret.Get(1).(*model.AppError)
  2794  		}
  2795  	}
  2796  
  2797  	return r0, r1
  2798  }
  2799  
  2800  // SearchPostsInTeam provides a mock function with given fields: teamId, paramsList
  2801  func (_m *API) SearchPostsInTeam(teamId string, paramsList []*model.SearchParams) ([]*model.Post, *model.AppError) {
  2802  	ret := _m.Called(teamId, paramsList)
  2803  
  2804  	var r0 []*model.Post
  2805  	if rf, ok := ret.Get(0).(func(string, []*model.SearchParams) []*model.Post); ok {
  2806  		r0 = rf(teamId, paramsList)
  2807  	} else {
  2808  		if ret.Get(0) != nil {
  2809  			r0 = ret.Get(0).([]*model.Post)
  2810  		}
  2811  	}
  2812  
  2813  	var r1 *model.AppError
  2814  	if rf, ok := ret.Get(1).(func(string, []*model.SearchParams) *model.AppError); ok {
  2815  		r1 = rf(teamId, paramsList)
  2816  	} else {
  2817  		if ret.Get(1) != nil {
  2818  			r1 = ret.Get(1).(*model.AppError)
  2819  		}
  2820  	}
  2821  
  2822  	return r0, r1
  2823  }
  2824  
  2825  // SearchPostsInTeamForUser provides a mock function with given fields: teamId, userId, searchParams
  2826  func (_m *API) SearchPostsInTeamForUser(teamId string, userId string, searchParams model.SearchParameter) (*model.PostSearchResults, *model.AppError) {
  2827  	ret := _m.Called(teamId, userId, searchParams)
  2828  
  2829  	var r0 *model.PostSearchResults
  2830  	if rf, ok := ret.Get(0).(func(string, string, model.SearchParameter) *model.PostSearchResults); ok {
  2831  		r0 = rf(teamId, userId, searchParams)
  2832  	} else {
  2833  		if ret.Get(0) != nil {
  2834  			r0 = ret.Get(0).(*model.PostSearchResults)
  2835  		}
  2836  	}
  2837  
  2838  	var r1 *model.AppError
  2839  	if rf, ok := ret.Get(1).(func(string, string, model.SearchParameter) *model.AppError); ok {
  2840  		r1 = rf(teamId, userId, searchParams)
  2841  	} else {
  2842  		if ret.Get(1) != nil {
  2843  			r1 = ret.Get(1).(*model.AppError)
  2844  		}
  2845  	}
  2846  
  2847  	return r0, r1
  2848  }
  2849  
  2850  // SearchTeams provides a mock function with given fields: term
  2851  func (_m *API) SearchTeams(term string) ([]*model.Team, *model.AppError) {
  2852  	ret := _m.Called(term)
  2853  
  2854  	var r0 []*model.Team
  2855  	if rf, ok := ret.Get(0).(func(string) []*model.Team); ok {
  2856  		r0 = rf(term)
  2857  	} else {
  2858  		if ret.Get(0) != nil {
  2859  			r0 = ret.Get(0).([]*model.Team)
  2860  		}
  2861  	}
  2862  
  2863  	var r1 *model.AppError
  2864  	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
  2865  		r1 = rf(term)
  2866  	} else {
  2867  		if ret.Get(1) != nil {
  2868  			r1 = ret.Get(1).(*model.AppError)
  2869  		}
  2870  	}
  2871  
  2872  	return r0, r1
  2873  }
  2874  
  2875  // SearchUsers provides a mock function with given fields: search
  2876  func (_m *API) SearchUsers(search *model.UserSearch) ([]*model.User, *model.AppError) {
  2877  	ret := _m.Called(search)
  2878  
  2879  	var r0 []*model.User
  2880  	if rf, ok := ret.Get(0).(func(*model.UserSearch) []*model.User); ok {
  2881  		r0 = rf(search)
  2882  	} else {
  2883  		if ret.Get(0) != nil {
  2884  			r0 = ret.Get(0).([]*model.User)
  2885  		}
  2886  	}
  2887  
  2888  	var r1 *model.AppError
  2889  	if rf, ok := ret.Get(1).(func(*model.UserSearch) *model.AppError); ok {
  2890  		r1 = rf(search)
  2891  	} else {
  2892  		if ret.Get(1) != nil {
  2893  			r1 = ret.Get(1).(*model.AppError)
  2894  		}
  2895  	}
  2896  
  2897  	return r0, r1
  2898  }
  2899  
  2900  // SendEphemeralPost provides a mock function with given fields: userId, post
  2901  func (_m *API) SendEphemeralPost(userId string, post *model.Post) *model.Post {
  2902  	ret := _m.Called(userId, post)
  2903  
  2904  	var r0 *model.Post
  2905  	if rf, ok := ret.Get(0).(func(string, *model.Post) *model.Post); ok {
  2906  		r0 = rf(userId, post)
  2907  	} else {
  2908  		if ret.Get(0) != nil {
  2909  			r0 = ret.Get(0).(*model.Post)
  2910  		}
  2911  	}
  2912  
  2913  	return r0
  2914  }
  2915  
  2916  // SendMail provides a mock function with given fields: to, subject, htmlBody
  2917  func (_m *API) SendMail(to string, subject string, htmlBody string) *model.AppError {
  2918  	ret := _m.Called(to, subject, htmlBody)
  2919  
  2920  	var r0 *model.AppError
  2921  	if rf, ok := ret.Get(0).(func(string, string, string) *model.AppError); ok {
  2922  		r0 = rf(to, subject, htmlBody)
  2923  	} else {
  2924  		if ret.Get(0) != nil {
  2925  			r0 = ret.Get(0).(*model.AppError)
  2926  		}
  2927  	}
  2928  
  2929  	return r0
  2930  }
  2931  
  2932  // SetBotIconImage provides a mock function with given fields: botUserId, data
  2933  func (_m *API) SetBotIconImage(botUserId string, data []byte) *model.AppError {
  2934  	ret := _m.Called(botUserId, data)
  2935  
  2936  	var r0 *model.AppError
  2937  	if rf, ok := ret.Get(0).(func(string, []byte) *model.AppError); ok {
  2938  		r0 = rf(botUserId, data)
  2939  	} else {
  2940  		if ret.Get(0) != nil {
  2941  			r0 = ret.Get(0).(*model.AppError)
  2942  		}
  2943  	}
  2944  
  2945  	return r0
  2946  }
  2947  
  2948  // SetProfileImage provides a mock function with given fields: userId, data
  2949  func (_m *API) SetProfileImage(userId string, data []byte) *model.AppError {
  2950  	ret := _m.Called(userId, data)
  2951  
  2952  	var r0 *model.AppError
  2953  	if rf, ok := ret.Get(0).(func(string, []byte) *model.AppError); ok {
  2954  		r0 = rf(userId, data)
  2955  	} else {
  2956  		if ret.Get(0) != nil {
  2957  			r0 = ret.Get(0).(*model.AppError)
  2958  		}
  2959  	}
  2960  
  2961  	return r0
  2962  }
  2963  
  2964  // SetTeamIcon provides a mock function with given fields: teamId, data
  2965  func (_m *API) SetTeamIcon(teamId string, data []byte) *model.AppError {
  2966  	ret := _m.Called(teamId, data)
  2967  
  2968  	var r0 *model.AppError
  2969  	if rf, ok := ret.Get(0).(func(string, []byte) *model.AppError); ok {
  2970  		r0 = rf(teamId, data)
  2971  	} else {
  2972  		if ret.Get(0) != nil {
  2973  			r0 = ret.Get(0).(*model.AppError)
  2974  		}
  2975  	}
  2976  
  2977  	return r0
  2978  }
  2979  
  2980  // UnregisterCommand provides a mock function with given fields: teamId, trigger
  2981  func (_m *API) UnregisterCommand(teamId string, trigger string) error {
  2982  	ret := _m.Called(teamId, trigger)
  2983  
  2984  	var r0 error
  2985  	if rf, ok := ret.Get(0).(func(string, string) error); ok {
  2986  		r0 = rf(teamId, trigger)
  2987  	} else {
  2988  		r0 = ret.Error(0)
  2989  	}
  2990  
  2991  	return r0
  2992  }
  2993  
  2994  // UpdateBotActive provides a mock function with given fields: botUserId, active
  2995  func (_m *API) UpdateBotActive(botUserId string, active bool) (*model.Bot, *model.AppError) {
  2996  	ret := _m.Called(botUserId, active)
  2997  
  2998  	var r0 *model.Bot
  2999  	if rf, ok := ret.Get(0).(func(string, bool) *model.Bot); ok {
  3000  		r0 = rf(botUserId, active)
  3001  	} else {
  3002  		if ret.Get(0) != nil {
  3003  			r0 = ret.Get(0).(*model.Bot)
  3004  		}
  3005  	}
  3006  
  3007  	var r1 *model.AppError
  3008  	if rf, ok := ret.Get(1).(func(string, bool) *model.AppError); ok {
  3009  		r1 = rf(botUserId, active)
  3010  	} else {
  3011  		if ret.Get(1) != nil {
  3012  			r1 = ret.Get(1).(*model.AppError)
  3013  		}
  3014  	}
  3015  
  3016  	return r0, r1
  3017  }
  3018  
  3019  // UpdateChannel provides a mock function with given fields: channel
  3020  func (_m *API) UpdateChannel(channel *model.Channel) (*model.Channel, *model.AppError) {
  3021  	ret := _m.Called(channel)
  3022  
  3023  	var r0 *model.Channel
  3024  	if rf, ok := ret.Get(0).(func(*model.Channel) *model.Channel); ok {
  3025  		r0 = rf(channel)
  3026  	} else {
  3027  		if ret.Get(0) != nil {
  3028  			r0 = ret.Get(0).(*model.Channel)
  3029  		}
  3030  	}
  3031  
  3032  	var r1 *model.AppError
  3033  	if rf, ok := ret.Get(1).(func(*model.Channel) *model.AppError); ok {
  3034  		r1 = rf(channel)
  3035  	} else {
  3036  		if ret.Get(1) != nil {
  3037  			r1 = ret.Get(1).(*model.AppError)
  3038  		}
  3039  	}
  3040  
  3041  	return r0, r1
  3042  }
  3043  
  3044  // UpdateChannelMemberNotifications provides a mock function with given fields: channelId, userId, notifications
  3045  func (_m *API) UpdateChannelMemberNotifications(channelId string, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError) {
  3046  	ret := _m.Called(channelId, userId, notifications)
  3047  
  3048  	var r0 *model.ChannelMember
  3049  	if rf, ok := ret.Get(0).(func(string, string, map[string]string) *model.ChannelMember); ok {
  3050  		r0 = rf(channelId, userId, notifications)
  3051  	} else {
  3052  		if ret.Get(0) != nil {
  3053  			r0 = ret.Get(0).(*model.ChannelMember)
  3054  		}
  3055  	}
  3056  
  3057  	var r1 *model.AppError
  3058  	if rf, ok := ret.Get(1).(func(string, string, map[string]string) *model.AppError); ok {
  3059  		r1 = rf(channelId, userId, notifications)
  3060  	} else {
  3061  		if ret.Get(1) != nil {
  3062  			r1 = ret.Get(1).(*model.AppError)
  3063  		}
  3064  	}
  3065  
  3066  	return r0, r1
  3067  }
  3068  
  3069  // UpdateChannelMemberRoles provides a mock function with given fields: channelId, userId, newRoles
  3070  func (_m *API) UpdateChannelMemberRoles(channelId string, userId string, newRoles string) (*model.ChannelMember, *model.AppError) {
  3071  	ret := _m.Called(channelId, userId, newRoles)
  3072  
  3073  	var r0 *model.ChannelMember
  3074  	if rf, ok := ret.Get(0).(func(string, string, string) *model.ChannelMember); ok {
  3075  		r0 = rf(channelId, userId, newRoles)
  3076  	} else {
  3077  		if ret.Get(0) != nil {
  3078  			r0 = ret.Get(0).(*model.ChannelMember)
  3079  		}
  3080  	}
  3081  
  3082  	var r1 *model.AppError
  3083  	if rf, ok := ret.Get(1).(func(string, string, string) *model.AppError); ok {
  3084  		r1 = rf(channelId, userId, newRoles)
  3085  	} else {
  3086  		if ret.Get(1) != nil {
  3087  			r1 = ret.Get(1).(*model.AppError)
  3088  		}
  3089  	}
  3090  
  3091  	return r0, r1
  3092  }
  3093  
  3094  // UpdateCommand provides a mock function with given fields: commandID, updatedCmd
  3095  func (_m *API) UpdateCommand(commandID string, updatedCmd *model.Command) (*model.Command, error) {
  3096  	ret := _m.Called(commandID, updatedCmd)
  3097  
  3098  	var r0 *model.Command
  3099  	if rf, ok := ret.Get(0).(func(string, *model.Command) *model.Command); ok {
  3100  		r0 = rf(commandID, updatedCmd)
  3101  	} else {
  3102  		if ret.Get(0) != nil {
  3103  			r0 = ret.Get(0).(*model.Command)
  3104  		}
  3105  	}
  3106  
  3107  	var r1 error
  3108  	if rf, ok := ret.Get(1).(func(string, *model.Command) error); ok {
  3109  		r1 = rf(commandID, updatedCmd)
  3110  	} else {
  3111  		r1 = ret.Error(1)
  3112  	}
  3113  
  3114  	return r0, r1
  3115  }
  3116  
  3117  // UpdateEphemeralPost provides a mock function with given fields: userId, post
  3118  func (_m *API) UpdateEphemeralPost(userId string, post *model.Post) *model.Post {
  3119  	ret := _m.Called(userId, post)
  3120  
  3121  	var r0 *model.Post
  3122  	if rf, ok := ret.Get(0).(func(string, *model.Post) *model.Post); ok {
  3123  		r0 = rf(userId, post)
  3124  	} else {
  3125  		if ret.Get(0) != nil {
  3126  			r0 = ret.Get(0).(*model.Post)
  3127  		}
  3128  	}
  3129  
  3130  	return r0
  3131  }
  3132  
  3133  // UpdatePost provides a mock function with given fields: post
  3134  func (_m *API) UpdatePost(post *model.Post) (*model.Post, *model.AppError) {
  3135  	ret := _m.Called(post)
  3136  
  3137  	var r0 *model.Post
  3138  	if rf, ok := ret.Get(0).(func(*model.Post) *model.Post); ok {
  3139  		r0 = rf(post)
  3140  	} else {
  3141  		if ret.Get(0) != nil {
  3142  			r0 = ret.Get(0).(*model.Post)
  3143  		}
  3144  	}
  3145  
  3146  	var r1 *model.AppError
  3147  	if rf, ok := ret.Get(1).(func(*model.Post) *model.AppError); ok {
  3148  		r1 = rf(post)
  3149  	} else {
  3150  		if ret.Get(1) != nil {
  3151  			r1 = ret.Get(1).(*model.AppError)
  3152  		}
  3153  	}
  3154  
  3155  	return r0, r1
  3156  }
  3157  
  3158  // UpdatePreferencesForUser provides a mock function with given fields: userId, preferences
  3159  func (_m *API) UpdatePreferencesForUser(userId string, preferences []model.Preference) *model.AppError {
  3160  	ret := _m.Called(userId, preferences)
  3161  
  3162  	var r0 *model.AppError
  3163  	if rf, ok := ret.Get(0).(func(string, []model.Preference) *model.AppError); ok {
  3164  		r0 = rf(userId, preferences)
  3165  	} else {
  3166  		if ret.Get(0) != nil {
  3167  			r0 = ret.Get(0).(*model.AppError)
  3168  		}
  3169  	}
  3170  
  3171  	return r0
  3172  }
  3173  
  3174  // UpdateTeam provides a mock function with given fields: team
  3175  func (_m *API) UpdateTeam(team *model.Team) (*model.Team, *model.AppError) {
  3176  	ret := _m.Called(team)
  3177  
  3178  	var r0 *model.Team
  3179  	if rf, ok := ret.Get(0).(func(*model.Team) *model.Team); ok {
  3180  		r0 = rf(team)
  3181  	} else {
  3182  		if ret.Get(0) != nil {
  3183  			r0 = ret.Get(0).(*model.Team)
  3184  		}
  3185  	}
  3186  
  3187  	var r1 *model.AppError
  3188  	if rf, ok := ret.Get(1).(func(*model.Team) *model.AppError); ok {
  3189  		r1 = rf(team)
  3190  	} else {
  3191  		if ret.Get(1) != nil {
  3192  			r1 = ret.Get(1).(*model.AppError)
  3193  		}
  3194  	}
  3195  
  3196  	return r0, r1
  3197  }
  3198  
  3199  // UpdateTeamMemberRoles provides a mock function with given fields: teamId, userId, newRoles
  3200  func (_m *API) UpdateTeamMemberRoles(teamId string, userId string, newRoles string) (*model.TeamMember, *model.AppError) {
  3201  	ret := _m.Called(teamId, userId, newRoles)
  3202  
  3203  	var r0 *model.TeamMember
  3204  	if rf, ok := ret.Get(0).(func(string, string, string) *model.TeamMember); ok {
  3205  		r0 = rf(teamId, userId, newRoles)
  3206  	} else {
  3207  		if ret.Get(0) != nil {
  3208  			r0 = ret.Get(0).(*model.TeamMember)
  3209  		}
  3210  	}
  3211  
  3212  	var r1 *model.AppError
  3213  	if rf, ok := ret.Get(1).(func(string, string, string) *model.AppError); ok {
  3214  		r1 = rf(teamId, userId, newRoles)
  3215  	} else {
  3216  		if ret.Get(1) != nil {
  3217  			r1 = ret.Get(1).(*model.AppError)
  3218  		}
  3219  	}
  3220  
  3221  	return r0, r1
  3222  }
  3223  
  3224  // UpdateUser provides a mock function with given fields: user
  3225  func (_m *API) UpdateUser(user *model.User) (*model.User, *model.AppError) {
  3226  	ret := _m.Called(user)
  3227  
  3228  	var r0 *model.User
  3229  	if rf, ok := ret.Get(0).(func(*model.User) *model.User); ok {
  3230  		r0 = rf(user)
  3231  	} else {
  3232  		if ret.Get(0) != nil {
  3233  			r0 = ret.Get(0).(*model.User)
  3234  		}
  3235  	}
  3236  
  3237  	var r1 *model.AppError
  3238  	if rf, ok := ret.Get(1).(func(*model.User) *model.AppError); ok {
  3239  		r1 = rf(user)
  3240  	} else {
  3241  		if ret.Get(1) != nil {
  3242  			r1 = ret.Get(1).(*model.AppError)
  3243  		}
  3244  	}
  3245  
  3246  	return r0, r1
  3247  }
  3248  
  3249  // UpdateUserActive provides a mock function with given fields: userId, active
  3250  func (_m *API) UpdateUserActive(userId string, active bool) *model.AppError {
  3251  	ret := _m.Called(userId, active)
  3252  
  3253  	var r0 *model.AppError
  3254  	if rf, ok := ret.Get(0).(func(string, bool) *model.AppError); ok {
  3255  		r0 = rf(userId, active)
  3256  	} else {
  3257  		if ret.Get(0) != nil {
  3258  			r0 = ret.Get(0).(*model.AppError)
  3259  		}
  3260  	}
  3261  
  3262  	return r0
  3263  }
  3264  
  3265  // UpdateUserStatus provides a mock function with given fields: userId, status
  3266  func (_m *API) UpdateUserStatus(userId string, status string) (*model.Status, *model.AppError) {
  3267  	ret := _m.Called(userId, status)
  3268  
  3269  	var r0 *model.Status
  3270  	if rf, ok := ret.Get(0).(func(string, string) *model.Status); ok {
  3271  		r0 = rf(userId, status)
  3272  	} else {
  3273  		if ret.Get(0) != nil {
  3274  			r0 = ret.Get(0).(*model.Status)
  3275  		}
  3276  	}
  3277  
  3278  	var r1 *model.AppError
  3279  	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
  3280  		r1 = rf(userId, status)
  3281  	} else {
  3282  		if ret.Get(1) != nil {
  3283  			r1 = ret.Get(1).(*model.AppError)
  3284  		}
  3285  	}
  3286  
  3287  	return r0, r1
  3288  }
  3289  
  3290  // UploadFile provides a mock function with given fields: data, channelId, filename
  3291  func (_m *API) UploadFile(data []byte, channelId string, filename string) (*model.FileInfo, *model.AppError) {
  3292  	ret := _m.Called(data, channelId, filename)
  3293  
  3294  	var r0 *model.FileInfo
  3295  	if rf, ok := ret.Get(0).(func([]byte, string, string) *model.FileInfo); ok {
  3296  		r0 = rf(data, channelId, filename)
  3297  	} else {
  3298  		if ret.Get(0) != nil {
  3299  			r0 = ret.Get(0).(*model.FileInfo)
  3300  		}
  3301  	}
  3302  
  3303  	var r1 *model.AppError
  3304  	if rf, ok := ret.Get(1).(func([]byte, string, string) *model.AppError); ok {
  3305  		r1 = rf(data, channelId, filename)
  3306  	} else {
  3307  		if ret.Get(1) != nil {
  3308  			r1 = ret.Get(1).(*model.AppError)
  3309  		}
  3310  	}
  3311  
  3312  	return r0, r1
  3313  }