api_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/Scalingo/go-scalingo/v4 (interfaces: API)

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

import (
	http0 "net/http"
	reflect "reflect"

	scalingo "github.com/Scalingo/go-scalingo/v4"
	http "github.com/Scalingo/go-scalingo/v4/http"
	gomock "github.com/golang/mock/gomock"
	websocket "golang.org/x/net/websocket"
)

// MockAPI is a mock of API interface.
type MockAPI struct {
	ctrl     *gomock.Controller
	recorder *MockAPIMockRecorder
}

// MockAPIMockRecorder is the mock recorder for MockAPI.
type MockAPIMockRecorder struct {
	mock *MockAPI
}

// NewMockAPI creates a new mock instance.
func NewMockAPI(ctrl *gomock.Controller) *MockAPI {
	mock := &MockAPI{ctrl: ctrl}
	mock.recorder = &MockAPIMockRecorder{mock}
	return mock
}

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

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

// AddonDestroy indicates an expected call of AddonDestroy.
func (mr *MockAPIMockRecorder) AddonDestroy(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddonDestroy", reflect.TypeOf((*MockAPI)(nil).AddonDestroy), arg0, arg1)
}

// AddonLogsArchives mocks base method.
func (m *MockAPI) AddonLogsArchives(arg0, arg1 string, arg2 int) (*scalingo.LogsArchivesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddonLogsArchives", arg0, arg1, arg2)
	ret0, _ := ret[0].(*scalingo.LogsArchivesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddonLogsArchives indicates an expected call of AddonLogsArchives.
func (mr *MockAPIMockRecorder) AddonLogsArchives(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddonLogsArchives", reflect.TypeOf((*MockAPI)(nil).AddonLogsArchives), arg0, arg1, arg2)
}

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

// AddonLogsURL indicates an expected call of AddonLogsURL.
func (mr *MockAPIMockRecorder) AddonLogsURL(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddonLogsURL", reflect.TypeOf((*MockAPI)(nil).AddonLogsURL), arg0, arg1)
}

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

// AddonProviderPlansList indicates an expected call of AddonProviderPlansList.
func (mr *MockAPIMockRecorder) AddonProviderPlansList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddonProviderPlansList", reflect.TypeOf((*MockAPI)(nil).AddonProviderPlansList), arg0)
}

// AddonProvidersList mocks base method.
func (m *MockAPI) AddonProvidersList() ([]*scalingo.AddonProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddonProvidersList")
	ret0, _ := ret[0].([]*scalingo.AddonProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddonProvision mocks base method.
func (m *MockAPI) AddonProvision(arg0 string, arg1 scalingo.AddonProvisionParams) (scalingo.AddonRes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddonProvision", arg0, arg1)
	ret0, _ := ret[0].(scalingo.AddonRes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddonProvision indicates an expected call of AddonProvision.
func (mr *MockAPIMockRecorder) AddonProvision(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddonProvision", reflect.TypeOf((*MockAPI)(nil).AddonProvision), arg0, arg1)
}

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

// AddonToken indicates an expected call of AddonToken.
func (mr *MockAPIMockRecorder) AddonToken(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddonToken", reflect.TypeOf((*MockAPI)(nil).AddonToken), arg0, arg1)
}

// AddonUpgrade mocks base method.
func (m *MockAPI) AddonUpgrade(arg0, arg1 string, arg2 scalingo.AddonUpgradeParams) (scalingo.AddonRes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddonUpgrade", arg0, arg1, arg2)
	ret0, _ := ret[0].(scalingo.AddonRes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddonUpgrade indicates an expected call of AddonUpgrade.
func (mr *MockAPIMockRecorder) AddonUpgrade(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddonUpgrade", reflect.TypeOf((*MockAPI)(nil).AddonUpgrade), arg0, arg1, arg2)
}

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

// AddonsList indicates an expected call of AddonsList.
func (mr *MockAPIMockRecorder) AddonsList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddonsList", reflect.TypeOf((*MockAPI)(nil).AddonsList), arg0)
}

// AlertAdd mocks base method.
func (m *MockAPI) AlertAdd(arg0 string, arg1 scalingo.AlertAddParams) (*scalingo.Alert, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AlertAdd", arg0, arg1)
	ret0, _ := ret[0].(*scalingo.Alert)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AlertAdd indicates an expected call of AlertAdd.
func (mr *MockAPIMockRecorder) AlertAdd(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlertAdd", reflect.TypeOf((*MockAPI)(nil).AlertAdd), arg0, arg1)
}

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

// AlertRemove indicates an expected call of AlertRemove.
func (mr *MockAPIMockRecorder) AlertRemove(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlertRemove", reflect.TypeOf((*MockAPI)(nil).AlertRemove), arg0, arg1)
}

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

// AlertShow indicates an expected call of AlertShow.
func (mr *MockAPIMockRecorder) AlertShow(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlertShow", reflect.TypeOf((*MockAPI)(nil).AlertShow), arg0, arg1)
}

// AlertUpdate mocks base method.
func (m *MockAPI) AlertUpdate(arg0, arg1 string, arg2 scalingo.AlertUpdateParams) (*scalingo.Alert, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AlertUpdate", arg0, arg1, arg2)
	ret0, _ := ret[0].(*scalingo.Alert)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AlertUpdate indicates an expected call of AlertUpdate.
func (mr *MockAPIMockRecorder) AlertUpdate(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlertUpdate", reflect.TypeOf((*MockAPI)(nil).AlertUpdate), arg0, arg1, arg2)
}

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

// AlertsList indicates an expected call of AlertsList.
func (mr *MockAPIMockRecorder) AlertsList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlertsList", reflect.TypeOf((*MockAPI)(nil).AlertsList), arg0)
}

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

// AppsContainerTypes indicates an expected call of AppsContainerTypes.
func (mr *MockAPIMockRecorder) AppsContainerTypes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsContainerTypes", reflect.TypeOf((*MockAPI)(nil).AppsContainerTypes), arg0)
}

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

// AppsContainersPs indicates an expected call of AppsContainersPs.
func (mr *MockAPIMockRecorder) AppsContainersPs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsContainersPs", reflect.TypeOf((*MockAPI)(nil).AppsContainersPs), arg0)
}

// AppsCreate mocks base method.
func (m *MockAPI) AppsCreate(arg0 scalingo.AppsCreateOpts) (*scalingo.App, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppsCreate", arg0)
	ret0, _ := ret[0].(*scalingo.App)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppsCreate indicates an expected call of AppsCreate.
func (mr *MockAPIMockRecorder) AppsCreate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsCreate", reflect.TypeOf((*MockAPI)(nil).AppsCreate), arg0)
}

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

// AppsDestroy indicates an expected call of AppsDestroy.
func (mr *MockAPIMockRecorder) AppsDestroy(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsDestroy", reflect.TypeOf((*MockAPI)(nil).AppsDestroy), arg0, arg1)
}

// AppsForceHTTPS mocks base method.
func (m *MockAPI) AppsForceHTTPS(arg0 string, arg1 bool) (*scalingo.App, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppsForceHTTPS", arg0, arg1)
	ret0, _ := ret[0].(*scalingo.App)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppsForceHTTPS indicates an expected call of AppsForceHTTPS.
func (mr *MockAPIMockRecorder) AppsForceHTTPS(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsForceHTTPS", reflect.TypeOf((*MockAPI)(nil).AppsForceHTTPS), arg0, arg1)
}

// AppsList mocks base method.
func (m *MockAPI) AppsList() ([]*scalingo.App, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppsList")
	ret0, _ := ret[0].([]*scalingo.App)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// AppsPs indicates an expected call of AppsPs.
func (mr *MockAPIMockRecorder) AppsPs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsPs", reflect.TypeOf((*MockAPI)(nil).AppsPs), arg0)
}

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

// AppsRename indicates an expected call of AppsRename.
func (mr *MockAPIMockRecorder) AppsRename(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsRename", reflect.TypeOf((*MockAPI)(nil).AppsRename), arg0, arg1)
}

// AppsRestart mocks base method.
func (m *MockAPI) AppsRestart(arg0 string, arg1 *scalingo.AppsRestartParams) (*http0.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppsRestart", arg0, arg1)
	ret0, _ := ret[0].(*http0.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppsRestart indicates an expected call of AppsRestart.
func (mr *MockAPIMockRecorder) AppsRestart(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsRestart", reflect.TypeOf((*MockAPI)(nil).AppsRestart), arg0, arg1)
}

// AppsRouterLogs mocks base method.
func (m *MockAPI) AppsRouterLogs(arg0 string, arg1 bool) (*scalingo.App, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppsRouterLogs", arg0, arg1)
	ret0, _ := ret[0].(*scalingo.App)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppsRouterLogs indicates an expected call of AppsRouterLogs.
func (mr *MockAPIMockRecorder) AppsRouterLogs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsRouterLogs", reflect.TypeOf((*MockAPI)(nil).AppsRouterLogs), arg0, arg1)
}

// AppsScale mocks base method.
func (m *MockAPI) AppsScale(arg0 string, arg1 *scalingo.AppsScaleParams) (*http0.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppsScale", arg0, arg1)
	ret0, _ := ret[0].(*http0.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppsScale indicates an expected call of AppsScale.
func (mr *MockAPIMockRecorder) AppsScale(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsScale", reflect.TypeOf((*MockAPI)(nil).AppsScale), arg0, arg1)
}

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

// AppsSetStack indicates an expected call of AppsSetStack.
func (mr *MockAPIMockRecorder) AppsSetStack(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsSetStack", reflect.TypeOf((*MockAPI)(nil).AppsSetStack), arg0, arg1)
}

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

// AppsShow indicates an expected call of AppsShow.
func (mr *MockAPIMockRecorder) AppsShow(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsShow", reflect.TypeOf((*MockAPI)(nil).AppsShow), arg0)
}

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

// AppsStats indicates an expected call of AppsStats.
func (mr *MockAPIMockRecorder) AppsStats(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsStats", reflect.TypeOf((*MockAPI)(nil).AppsStats), arg0)
}

// AppsStickySession mocks base method.
func (m *MockAPI) AppsStickySession(arg0 string, arg1 bool) (*scalingo.App, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppsStickySession", arg0, arg1)
	ret0, _ := ret[0].(*scalingo.App)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppsStickySession indicates an expected call of AppsStickySession.
func (mr *MockAPIMockRecorder) AppsStickySession(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsStickySession", reflect.TypeOf((*MockAPI)(nil).AppsStickySession), arg0, arg1)
}

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

// AppsTransfer indicates an expected call of AppsTransfer.
func (mr *MockAPIMockRecorder) AppsTransfer(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsTransfer", reflect.TypeOf((*MockAPI)(nil).AppsTransfer), arg0, arg1)
}

// AuthAPI mocks base method.
func (m *MockAPI) AuthAPI() http.Client {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthAPI")
	ret0, _ := ret[0].(http.Client)
	return ret0
}

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

// AutoscalerAdd mocks base method.
func (m *MockAPI) AutoscalerAdd(arg0 string, arg1 scalingo.AutoscalerAddParams) (*scalingo.Autoscaler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AutoscalerAdd", arg0, arg1)
	ret0, _ := ret[0].(*scalingo.Autoscaler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AutoscalerAdd indicates an expected call of AutoscalerAdd.
func (mr *MockAPIMockRecorder) AutoscalerAdd(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoscalerAdd", reflect.TypeOf((*MockAPI)(nil).AutoscalerAdd), arg0, arg1)
}

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

// AutoscalerRemove indicates an expected call of AutoscalerRemove.
func (mr *MockAPIMockRecorder) AutoscalerRemove(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoscalerRemove", reflect.TypeOf((*MockAPI)(nil).AutoscalerRemove), arg0, arg1)
}

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

// AutoscalersList indicates an expected call of AutoscalersList.
func (mr *MockAPIMockRecorder) AutoscalersList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoscalersList", reflect.TypeOf((*MockAPI)(nil).AutoscalersList), arg0)
}

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

// BackupCreate indicates an expected call of BackupCreate.
func (mr *MockAPIMockRecorder) BackupCreate(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackupCreate", reflect.TypeOf((*MockAPI)(nil).BackupCreate), arg0, arg1)
}

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

// BackupDownloadURL indicates an expected call of BackupDownloadURL.
func (mr *MockAPIMockRecorder) BackupDownloadURL(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackupDownloadURL", reflect.TypeOf((*MockAPI)(nil).BackupDownloadURL), arg0, arg1, arg2)
}

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

// BackupList indicates an expected call of BackupList.
func (mr *MockAPIMockRecorder) BackupList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackupList", reflect.TypeOf((*MockAPI)(nil).BackupList), arg0, arg1)
}

// BackupShow mocks base method.
func (m *MockAPI) BackupShow(arg0, arg1, arg2 string) (*scalingo.Backup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BackupShow", arg0, arg1, arg2)
	ret0, _ := ret[0].(*scalingo.Backup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BackupShow indicates an expected call of BackupShow.
func (mr *MockAPIMockRecorder) BackupShow(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackupShow", reflect.TypeOf((*MockAPI)(nil).BackupShow), arg0, arg1, arg2)
}

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

// CollaboratorAdd indicates an expected call of CollaboratorAdd.
func (mr *MockAPIMockRecorder) CollaboratorAdd(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollaboratorAdd", reflect.TypeOf((*MockAPI)(nil).CollaboratorAdd), arg0, arg1)
}

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

// CollaboratorRemove indicates an expected call of CollaboratorRemove.
func (mr *MockAPIMockRecorder) CollaboratorRemove(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollaboratorRemove", reflect.TypeOf((*MockAPI)(nil).CollaboratorRemove), arg0, arg1)
}

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

// CollaboratorsList indicates an expected call of CollaboratorsList.
func (mr *MockAPIMockRecorder) CollaboratorsList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollaboratorsList", reflect.TypeOf((*MockAPI)(nil).CollaboratorsList), arg0)
}

// ContainerSizesList mocks base method.
func (m *MockAPI) ContainerSizesList() ([]scalingo.ContainerSize, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerSizesList")
	ret0, _ := ret[0].([]scalingo.ContainerSize)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// ContainersStop indicates an expected call of ContainersStop.
func (mr *MockAPIMockRecorder) ContainersStop(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainersStop", reflect.TypeOf((*MockAPI)(nil).ContainersStop), arg0, arg1)
}

// CreateRegionMigration mocks base method.
func (m *MockAPI) CreateRegionMigration(arg0 string, arg1 scalingo.RegionMigrationParams) (scalingo.RegionMigration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRegionMigration", arg0, arg1)
	ret0, _ := ret[0].(scalingo.RegionMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRegionMigration indicates an expected call of CreateRegionMigration.
func (mr *MockAPIMockRecorder) CreateRegionMigration(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegionMigration", reflect.TypeOf((*MockAPI)(nil).CreateRegionMigration), arg0, arg1)
}

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

// CronTasksGet indicates an expected call of CronTasksGet.
func (mr *MockAPIMockRecorder) CronTasksGet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CronTasksGet", reflect.TypeOf((*MockAPI)(nil).CronTasksGet), arg0)
}

// DBAPI mocks base method.
func (m *MockAPI) DBAPI(arg0, arg1 string) http.Client {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DBAPI", arg0, arg1)
	ret0, _ := ret[0].(http.Client)
	return ret0
}

// DBAPI indicates an expected call of DBAPI.
func (mr *MockAPIMockRecorder) DBAPI(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBAPI", reflect.TypeOf((*MockAPI)(nil).DBAPI), arg0, arg1)
}

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

// Deployment indicates an expected call of Deployment.
func (mr *MockAPIMockRecorder) Deployment(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deployment", reflect.TypeOf((*MockAPI)(nil).Deployment), arg0, arg1)
}

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

// DeploymentList indicates an expected call of DeploymentList.
func (mr *MockAPIMockRecorder) DeploymentList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeploymentList", reflect.TypeOf((*MockAPI)(nil).DeploymentList), arg0)
}

// DeploymentListWithPagination mocks base method.
func (m *MockAPI) DeploymentListWithPagination(arg0 string, arg1 scalingo.PaginationOpts) ([]*scalingo.Deployment, scalingo.PaginationMeta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeploymentListWithPagination", arg0, arg1)
	ret0, _ := ret[0].([]*scalingo.Deployment)
	ret1, _ := ret[1].(scalingo.PaginationMeta)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeploymentListWithPagination indicates an expected call of DeploymentListWithPagination.
func (mr *MockAPIMockRecorder) DeploymentListWithPagination(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeploymentListWithPagination", reflect.TypeOf((*MockAPI)(nil).DeploymentListWithPagination), arg0, arg1)
}

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

// DeploymentLogs indicates an expected call of DeploymentLogs.
func (mr *MockAPIMockRecorder) DeploymentLogs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeploymentLogs", reflect.TypeOf((*MockAPI)(nil).DeploymentLogs), arg0)
}

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

// DeploymentStream indicates an expected call of DeploymentStream.
func (mr *MockAPIMockRecorder) DeploymentStream(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeploymentStream", reflect.TypeOf((*MockAPI)(nil).DeploymentStream), arg0)
}

// DeploymentsCreate mocks base method.
func (m *MockAPI) DeploymentsCreate(arg0 string, arg1 *scalingo.DeploymentsCreateParams) (*scalingo.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeploymentsCreate", arg0, arg1)
	ret0, _ := ret[0].(*scalingo.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeploymentsCreate indicates an expected call of DeploymentsCreate.
func (mr *MockAPIMockRecorder) DeploymentsCreate(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeploymentsCreate", reflect.TypeOf((*MockAPI)(nil).DeploymentsCreate), arg0, arg1)
}

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

// DomainSetCanonical indicates an expected call of DomainSetCanonical.
func (mr *MockAPIMockRecorder) DomainSetCanonical(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainSetCanonical", reflect.TypeOf((*MockAPI)(nil).DomainSetCanonical), arg0, arg1)
}

// DomainSetCertificate mocks base method.
func (m *MockAPI) DomainSetCertificate(arg0, arg1, arg2, arg3 string) (scalingo.Domain, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DomainSetCertificate", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(scalingo.Domain)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DomainSetCertificate indicates an expected call of DomainSetCertificate.
func (mr *MockAPIMockRecorder) DomainSetCertificate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainSetCertificate", reflect.TypeOf((*MockAPI)(nil).DomainSetCertificate), arg0, arg1, arg2, arg3)
}

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

// DomainUnsetCanonical indicates an expected call of DomainUnsetCanonical.
func (mr *MockAPIMockRecorder) DomainUnsetCanonical(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainUnsetCanonical", reflect.TypeOf((*MockAPI)(nil).DomainUnsetCanonical), arg0)
}

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

// DomainUnsetCertificate indicates an expected call of DomainUnsetCertificate.
func (mr *MockAPIMockRecorder) DomainUnsetCertificate(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainUnsetCertificate", reflect.TypeOf((*MockAPI)(nil).DomainUnsetCertificate), arg0, arg1)
}

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

// DomainsAdd indicates an expected call of DomainsAdd.
func (mr *MockAPIMockRecorder) DomainsAdd(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainsAdd", reflect.TypeOf((*MockAPI)(nil).DomainsAdd), arg0, arg1)
}

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

// DomainsList indicates an expected call of DomainsList.
func (mr *MockAPIMockRecorder) DomainsList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainsList", reflect.TypeOf((*MockAPI)(nil).DomainsList), arg0)
}

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

// DomainsRemove indicates an expected call of DomainsRemove.
func (mr *MockAPIMockRecorder) DomainsRemove(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainsRemove", reflect.TypeOf((*MockAPI)(nil).DomainsRemove), arg0, arg1)
}

// DomainsUpdate mocks base method.
func (m *MockAPI) DomainsUpdate(arg0, arg1, arg2, arg3 string) (scalingo.Domain, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DomainsUpdate", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(scalingo.Domain)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DomainsUpdate indicates an expected call of DomainsUpdate.
func (mr *MockAPIMockRecorder) DomainsUpdate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainsUpdate", reflect.TypeOf((*MockAPI)(nil).DomainsUpdate), arg0, arg1, arg2, arg3)
}

// EventCategoriesList mocks base method.
func (m *MockAPI) EventCategoriesList() ([]scalingo.EventCategory, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EventCategoriesList")
	ret0, _ := ret[0].([]scalingo.EventCategory)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EventTypesList mocks base method.
func (m *MockAPI) EventTypesList() ([]scalingo.EventType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EventTypesList")
	ret0, _ := ret[0].([]scalingo.EventType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EventsList mocks base method.
func (m *MockAPI) EventsList(arg0 string, arg1 scalingo.PaginationOpts) (scalingo.Events, scalingo.PaginationMeta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EventsList", arg0, arg1)
	ret0, _ := ret[0].(scalingo.Events)
	ret1, _ := ret[1].(scalingo.PaginationMeta)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EventsList indicates an expected call of EventsList.
func (mr *MockAPIMockRecorder) EventsList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsList", reflect.TypeOf((*MockAPI)(nil).EventsList), arg0, arg1)
}

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

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

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

// KeysAdd indicates an expected call of KeysAdd.
func (mr *MockAPIMockRecorder) KeysAdd(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeysAdd", reflect.TypeOf((*MockAPI)(nil).KeysAdd), arg0, arg1)
}

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

// KeysDelete indicates an expected call of KeysDelete.
func (mr *MockAPIMockRecorder) KeysDelete(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeysDelete", reflect.TypeOf((*MockAPI)(nil).KeysDelete), arg0)
}

// KeysList mocks base method.
func (m *MockAPI) KeysList() ([]scalingo.Key, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KeysList")
	ret0, _ := ret[0].([]scalingo.Key)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// ListRegionMigrations indicates an expected call of ListRegionMigrations.
func (mr *MockAPIMockRecorder) ListRegionMigrations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegionMigrations", reflect.TypeOf((*MockAPI)(nil).ListRegionMigrations), arg0)
}

// LogDrainAdd mocks base method.
func (m *MockAPI) LogDrainAdd(arg0 string, arg1 scalingo.LogDrainAddParams) (*scalingo.LogDrainRes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogDrainAdd", arg0, arg1)
	ret0, _ := ret[0].(*scalingo.LogDrainRes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogDrainAdd indicates an expected call of LogDrainAdd.
func (mr *MockAPIMockRecorder) LogDrainAdd(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogDrainAdd", reflect.TypeOf((*MockAPI)(nil).LogDrainAdd), arg0, arg1)
}

// LogDrainAddonAdd mocks base method.
func (m *MockAPI) LogDrainAddonAdd(arg0, arg1 string, arg2 scalingo.LogDrainAddParams) (*scalingo.LogDrainRes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogDrainAddonAdd", arg0, arg1, arg2)
	ret0, _ := ret[0].(*scalingo.LogDrainRes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogDrainAddonAdd indicates an expected call of LogDrainAddonAdd.
func (mr *MockAPIMockRecorder) LogDrainAddonAdd(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogDrainAddonAdd", reflect.TypeOf((*MockAPI)(nil).LogDrainAddonAdd), arg0, arg1, arg2)
}

// LogDrainAddonRemove mocks base method.
func (m *MockAPI) LogDrainAddonRemove(arg0, arg1, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogDrainAddonRemove", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// LogDrainAddonRemove indicates an expected call of LogDrainAddonRemove.
func (mr *MockAPIMockRecorder) LogDrainAddonRemove(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogDrainAddonRemove", reflect.TypeOf((*MockAPI)(nil).LogDrainAddonRemove), arg0, arg1, arg2)
}

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

// LogDrainRemove indicates an expected call of LogDrainRemove.
func (mr *MockAPIMockRecorder) LogDrainRemove(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogDrainRemove", reflect.TypeOf((*MockAPI)(nil).LogDrainRemove), arg0, arg1)
}

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

// LogDrainsAddonList indicates an expected call of LogDrainsAddonList.
func (mr *MockAPIMockRecorder) LogDrainsAddonList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogDrainsAddonList", reflect.TypeOf((*MockAPI)(nil).LogDrainsAddonList), arg0, arg1)
}

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

// LogDrainsList indicates an expected call of LogDrainsList.
func (mr *MockAPIMockRecorder) LogDrainsList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogDrainsList", reflect.TypeOf((*MockAPI)(nil).LogDrainsList), arg0)
}

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

// Login indicates an expected call of Login.
func (mr *MockAPIMockRecorder) Login(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Login", reflect.TypeOf((*MockAPI)(nil).Login), arg0, arg1)
}

// Logs mocks base method.
func (m *MockAPI) Logs(arg0 string, arg1 int, arg2 string) (*http0.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Logs", arg0, arg1, arg2)
	ret0, _ := ret[0].(*http0.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Logs indicates an expected call of Logs.
func (mr *MockAPIMockRecorder) Logs(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logs", reflect.TypeOf((*MockAPI)(nil).Logs), arg0, arg1, arg2)
}

// LogsArchives mocks base method.
func (m *MockAPI) LogsArchives(arg0 string, arg1 int) (*scalingo.LogsArchivesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogsArchives", arg0, arg1)
	ret0, _ := ret[0].(*scalingo.LogsArchivesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogsArchives indicates an expected call of LogsArchives.
func (mr *MockAPIMockRecorder) LogsArchives(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogsArchives", reflect.TypeOf((*MockAPI)(nil).LogsArchives), arg0, arg1)
}

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

// LogsArchivesByCursor indicates an expected call of LogsArchivesByCursor.
func (mr *MockAPIMockRecorder) LogsArchivesByCursor(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogsArchivesByCursor", reflect.TypeOf((*MockAPI)(nil).LogsArchivesByCursor), arg0, arg1)
}

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

// LogsURL indicates an expected call of LogsURL.
func (mr *MockAPIMockRecorder) LogsURL(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogsURL", reflect.TypeOf((*MockAPI)(nil).LogsURL), arg0)
}

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

// NotificationPlatformByName indicates an expected call of NotificationPlatformByName.
func (mr *MockAPIMockRecorder) NotificationPlatformByName(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotificationPlatformByName", reflect.TypeOf((*MockAPI)(nil).NotificationPlatformByName), arg0)
}

// NotificationPlatformsList mocks base method.
func (m *MockAPI) NotificationPlatformsList() ([]*scalingo.NotificationPlatform, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotificationPlatformsList")
	ret0, _ := ret[0].([]*scalingo.NotificationPlatform)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// NotifierByID indicates an expected call of NotifierByID.
func (mr *MockAPIMockRecorder) NotifierByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifierByID", reflect.TypeOf((*MockAPI)(nil).NotifierByID), arg0, arg1)
}

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

// NotifierDestroy indicates an expected call of NotifierDestroy.
func (mr *MockAPIMockRecorder) NotifierDestroy(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifierDestroy", reflect.TypeOf((*MockAPI)(nil).NotifierDestroy), arg0, arg1)
}

// NotifierProvision mocks base method.
func (m *MockAPI) NotifierProvision(arg0 string, arg1 scalingo.NotifierParams) (*scalingo.Notifier, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifierProvision", arg0, arg1)
	ret0, _ := ret[0].(*scalingo.Notifier)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NotifierProvision indicates an expected call of NotifierProvision.
func (mr *MockAPIMockRecorder) NotifierProvision(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifierProvision", reflect.TypeOf((*MockAPI)(nil).NotifierProvision), arg0, arg1)
}

// NotifierUpdate mocks base method.
func (m *MockAPI) NotifierUpdate(arg0, arg1 string, arg2 scalingo.NotifierParams) (*scalingo.Notifier, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifierUpdate", arg0, arg1, arg2)
	ret0, _ := ret[0].(*scalingo.Notifier)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NotifierUpdate indicates an expected call of NotifierUpdate.
func (mr *MockAPIMockRecorder) NotifierUpdate(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifierUpdate", reflect.TypeOf((*MockAPI)(nil).NotifierUpdate), arg0, arg1, arg2)
}

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

// NotifiersList indicates an expected call of NotifiersList.
func (mr *MockAPIMockRecorder) NotifiersList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifiersList", reflect.TypeOf((*MockAPI)(nil).NotifiersList), arg0)
}

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

// OperationsShow indicates an expected call of OperationsShow.
func (mr *MockAPIMockRecorder) OperationsShow(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperationsShow", reflect.TypeOf((*MockAPI)(nil).OperationsShow), arg0, arg1)
}

// RegionsList mocks base method.
func (m *MockAPI) RegionsList() ([]scalingo.Region, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegionsList")
	ret0, _ := ret[0].([]scalingo.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Run mocks base method.
func (m *MockAPI) Run(arg0 scalingo.RunOpts) (*scalingo.RunRes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", arg0)
	ret0, _ := ret[0].(*scalingo.RunRes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Run indicates an expected call of Run.
func (mr *MockAPIMockRecorder) Run(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockAPI)(nil).Run), arg0)
}

// RunRegionMigrationStep mocks base method.
func (m *MockAPI) RunRegionMigrationStep(arg0, arg1 string, arg2 scalingo.RegionMigrationStep) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunRegionMigrationStep", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunRegionMigrationStep indicates an expected call of RunRegionMigrationStep.
func (mr *MockAPIMockRecorder) RunRegionMigrationStep(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunRegionMigrationStep", reflect.TypeOf((*MockAPI)(nil).RunRegionMigrationStep), arg0, arg1, arg2)
}

// ScalingoAPI mocks base method.
func (m *MockAPI) ScalingoAPI() http.Client {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScalingoAPI")
	ret0, _ := ret[0].(http.Client)
	return ret0
}

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

// Self mocks base method.
func (m *MockAPI) Self() (*scalingo.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Self")
	ret0, _ := ret[0].(*scalingo.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// ShowRegionMigration indicates an expected call of ShowRegionMigration.
func (mr *MockAPIMockRecorder) ShowRegionMigration(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShowRegionMigration", reflect.TypeOf((*MockAPI)(nil).ShowRegionMigration), arg0, arg1)
}

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

// SignUp indicates an expected call of SignUp.
func (mr *MockAPIMockRecorder) SignUp(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignUp", reflect.TypeOf((*MockAPI)(nil).SignUp), arg0, arg1)
}

// SourcesCreate mocks base method.
func (m *MockAPI) SourcesCreate() (*scalingo.Source, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SourcesCreate")
	ret0, _ := ret[0].(*scalingo.Source)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StacksList mocks base method.
func (m *MockAPI) StacksList() ([]scalingo.Stack, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StacksList")
	ret0, _ := ret[0].([]scalingo.Stack)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TokenCreate mocks base method.
func (m *MockAPI) TokenCreate(arg0 scalingo.TokenCreateParams) (scalingo.Token, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TokenCreate", arg0)
	ret0, _ := ret[0].(scalingo.Token)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TokenCreate indicates an expected call of TokenCreate.
func (mr *MockAPIMockRecorder) TokenCreate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenCreate", reflect.TypeOf((*MockAPI)(nil).TokenCreate), arg0)
}

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

// TokenExchange indicates an expected call of TokenExchange.
func (mr *MockAPIMockRecorder) TokenExchange(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenExchange", reflect.TypeOf((*MockAPI)(nil).TokenExchange), arg0)
}

// TokenShow mocks base method.
func (m *MockAPI) TokenShow(arg0 int) (scalingo.Token, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TokenShow", arg0)
	ret0, _ := ret[0].(scalingo.Token)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TokenShow indicates an expected call of TokenShow.
func (mr *MockAPIMockRecorder) TokenShow(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenShow", reflect.TypeOf((*MockAPI)(nil).TokenShow), arg0)
}

// TokensList mocks base method.
func (m *MockAPI) TokensList() (scalingo.Tokens, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TokensList")
	ret0, _ := ret[0].(scalingo.Tokens)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateUser mocks base method.
func (m *MockAPI) UpdateUser(arg0 scalingo.UpdateUserParams) (*scalingo.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUser", arg0)
	ret0, _ := ret[0].(*scalingo.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUser indicates an expected call of UpdateUser.
func (mr *MockAPIMockRecorder) UpdateUser(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockAPI)(nil).UpdateUser), arg0)
}

// UserEventsList mocks base method.
func (m *MockAPI) UserEventsList(arg0 scalingo.PaginationOpts) (scalingo.Events, scalingo.PaginationMeta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserEventsList", arg0)
	ret0, _ := ret[0].(scalingo.Events)
	ret1, _ := ret[1].(scalingo.PaginationMeta)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UserEventsList indicates an expected call of UserEventsList.
func (mr *MockAPIMockRecorder) UserEventsList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserEventsList", reflect.TypeOf((*MockAPI)(nil).UserEventsList), arg0)
}

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

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

// VariableMultipleSet mocks base method.
func (m *MockAPI) VariableMultipleSet(arg0 string, arg1 scalingo.Variables) (scalingo.Variables, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VariableMultipleSet", arg0, arg1)
	ret0, _ := ret[0].(scalingo.Variables)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// VariableMultipleSet indicates an expected call of VariableMultipleSet.
func (mr *MockAPIMockRecorder) VariableMultipleSet(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VariableMultipleSet", reflect.TypeOf((*MockAPI)(nil).VariableMultipleSet), arg0, arg1)
}

// VariableSet mocks base method.
func (m *MockAPI) VariableSet(arg0, arg1, arg2 string) (*scalingo.Variable, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VariableSet", arg0, arg1, arg2)
	ret0, _ := ret[0].(*scalingo.Variable)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// VariableSet indicates an expected call of VariableSet.
func (mr *MockAPIMockRecorder) VariableSet(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VariableSet", reflect.TypeOf((*MockAPI)(nil).VariableSet), arg0, arg1, arg2)
}

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

// VariableUnset indicates an expected call of VariableUnset.
func (mr *MockAPIMockRecorder) VariableUnset(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VariableUnset", reflect.TypeOf((*MockAPI)(nil).VariableUnset), arg0, arg1)
}

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

// VariablesList indicates an expected call of VariablesList.
func (mr *MockAPIMockRecorder) VariablesList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VariablesList", reflect.TypeOf((*MockAPI)(nil).VariablesList), arg0)
}

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

// VariablesListWithoutAlias indicates an expected call of VariablesListWithoutAlias.
func (mr *MockAPIMockRecorder) VariablesListWithoutAlias(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VariablesListWithoutAlias", reflect.TypeOf((*MockAPI)(nil).VariablesListWithoutAlias), arg0)
}