// Code generated by MockGen. DO NOT EDIT.
// Source: /home/runner/go/pkg/mod/github.com/aws/aws-sdk-go@v1.55.5/service/gamelift/gameliftiface/interface.go

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

import (
	reflect "reflect"

	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	gamelift "github.com/aws/aws-sdk-go/service/gamelift"
	gomock "github.com/golang/mock/gomock"
)

// MockGameLiftAPI is a mock of GameLiftAPI interface.
type MockGameLiftAPI struct {
	ctrl     *gomock.Controller
	recorder *MockGameLiftAPIMockRecorder
}

// MockGameLiftAPIMockRecorder is the mock recorder for MockGameLiftAPI.
type MockGameLiftAPIMockRecorder struct {
	mock *MockGameLiftAPI
}

// NewMockGameLiftAPI creates a new mock instance.
func NewMockGameLiftAPI(ctrl *gomock.Controller) *MockGameLiftAPI {
	mock := &MockGameLiftAPI{ctrl: ctrl}
	mock.recorder = &MockGameLiftAPIMockRecorder{mock}
	return mock
}

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

// AcceptMatch mocks base method.
func (m *MockGameLiftAPI) AcceptMatch(arg0 *gamelift.AcceptMatchInput) (*gamelift.AcceptMatchOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptMatch", arg0)
	ret0, _ := ret[0].(*gamelift.AcceptMatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcceptMatchRequest mocks base method.
func (m *MockGameLiftAPI) AcceptMatchRequest(arg0 *gamelift.AcceptMatchInput) (*request.Request, *gamelift.AcceptMatchOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptMatchRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.AcceptMatchOutput)
	return ret0, ret1
}

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

// AcceptMatchWithContext mocks base method.
func (m *MockGameLiftAPI) AcceptMatchWithContext(arg0 aws.Context, arg1 *gamelift.AcceptMatchInput, arg2 ...request.Option) (*gamelift.AcceptMatchOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AcceptMatchWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.AcceptMatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ClaimGameServer mocks base method.
func (m *MockGameLiftAPI) ClaimGameServer(arg0 *gamelift.ClaimGameServerInput) (*gamelift.ClaimGameServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClaimGameServer", arg0)
	ret0, _ := ret[0].(*gamelift.ClaimGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ClaimGameServerRequest mocks base method.
func (m *MockGameLiftAPI) ClaimGameServerRequest(arg0 *gamelift.ClaimGameServerInput) (*request.Request, *gamelift.ClaimGameServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClaimGameServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ClaimGameServerOutput)
	return ret0, ret1
}

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

// ClaimGameServerWithContext mocks base method.
func (m *MockGameLiftAPI) ClaimGameServerWithContext(arg0 aws.Context, arg1 *gamelift.ClaimGameServerInput, arg2 ...request.Option) (*gamelift.ClaimGameServerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClaimGameServerWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ClaimGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAlias mocks base method.
func (m *MockGameLiftAPI) CreateAlias(arg0 *gamelift.CreateAliasInput) (*gamelift.CreateAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAlias", arg0)
	ret0, _ := ret[0].(*gamelift.CreateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAliasRequest mocks base method.
func (m *MockGameLiftAPI) CreateAliasRequest(arg0 *gamelift.CreateAliasInput) (*request.Request, *gamelift.CreateAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateAliasOutput)
	return ret0, ret1
}

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

// CreateAliasWithContext mocks base method.
func (m *MockGameLiftAPI) CreateAliasWithContext(arg0 aws.Context, arg1 *gamelift.CreateAliasInput, arg2 ...request.Option) (*gamelift.CreateAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAliasWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateBuild mocks base method.
func (m *MockGameLiftAPI) CreateBuild(arg0 *gamelift.CreateBuildInput) (*gamelift.CreateBuildOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBuild", arg0)
	ret0, _ := ret[0].(*gamelift.CreateBuildOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateBuildRequest mocks base method.
func (m *MockGameLiftAPI) CreateBuildRequest(arg0 *gamelift.CreateBuildInput) (*request.Request, *gamelift.CreateBuildOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBuildRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateBuildOutput)
	return ret0, ret1
}

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

// CreateBuildWithContext mocks base method.
func (m *MockGameLiftAPI) CreateBuildWithContext(arg0 aws.Context, arg1 *gamelift.CreateBuildInput, arg2 ...request.Option) (*gamelift.CreateBuildOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateBuildWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateBuildOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateContainerGroupDefinition mocks base method.
func (m *MockGameLiftAPI) CreateContainerGroupDefinition(arg0 *gamelift.CreateContainerGroupDefinitionInput) (*gamelift.CreateContainerGroupDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContainerGroupDefinition", arg0)
	ret0, _ := ret[0].(*gamelift.CreateContainerGroupDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateContainerGroupDefinitionRequest mocks base method.
func (m *MockGameLiftAPI) CreateContainerGroupDefinitionRequest(arg0 *gamelift.CreateContainerGroupDefinitionInput) (*request.Request, *gamelift.CreateContainerGroupDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContainerGroupDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateContainerGroupDefinitionOutput)
	return ret0, ret1
}

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

// CreateContainerGroupDefinitionWithContext mocks base method.
func (m *MockGameLiftAPI) CreateContainerGroupDefinitionWithContext(arg0 aws.Context, arg1 *gamelift.CreateContainerGroupDefinitionInput, arg2 ...request.Option) (*gamelift.CreateContainerGroupDefinitionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateContainerGroupDefinitionWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateContainerGroupDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFleet mocks base method.
func (m *MockGameLiftAPI) CreateFleet(arg0 *gamelift.CreateFleetInput) (*gamelift.CreateFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFleet", arg0)
	ret0, _ := ret[0].(*gamelift.CreateFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFleetLocations mocks base method.
func (m *MockGameLiftAPI) CreateFleetLocations(arg0 *gamelift.CreateFleetLocationsInput) (*gamelift.CreateFleetLocationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFleetLocations", arg0)
	ret0, _ := ret[0].(*gamelift.CreateFleetLocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFleetLocationsRequest mocks base method.
func (m *MockGameLiftAPI) CreateFleetLocationsRequest(arg0 *gamelift.CreateFleetLocationsInput) (*request.Request, *gamelift.CreateFleetLocationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFleetLocationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateFleetLocationsOutput)
	return ret0, ret1
}

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

// CreateFleetLocationsWithContext mocks base method.
func (m *MockGameLiftAPI) CreateFleetLocationsWithContext(arg0 aws.Context, arg1 *gamelift.CreateFleetLocationsInput, arg2 ...request.Option) (*gamelift.CreateFleetLocationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFleetLocationsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateFleetLocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFleetRequest mocks base method.
func (m *MockGameLiftAPI) CreateFleetRequest(arg0 *gamelift.CreateFleetInput) (*request.Request, *gamelift.CreateFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateFleetOutput)
	return ret0, ret1
}

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

// CreateFleetWithContext mocks base method.
func (m *MockGameLiftAPI) CreateFleetWithContext(arg0 aws.Context, arg1 *gamelift.CreateFleetInput, arg2 ...request.Option) (*gamelift.CreateFleetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFleetWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGameServerGroup mocks base method.
func (m *MockGameLiftAPI) CreateGameServerGroup(arg0 *gamelift.CreateGameServerGroupInput) (*gamelift.CreateGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGameServerGroup", arg0)
	ret0, _ := ret[0].(*gamelift.CreateGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGameServerGroupRequest mocks base method.
func (m *MockGameLiftAPI) CreateGameServerGroupRequest(arg0 *gamelift.CreateGameServerGroupInput) (*request.Request, *gamelift.CreateGameServerGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGameServerGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateGameServerGroupOutput)
	return ret0, ret1
}

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

// CreateGameServerGroupWithContext mocks base method.
func (m *MockGameLiftAPI) CreateGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.CreateGameServerGroupInput, arg2 ...request.Option) (*gamelift.CreateGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGameServerGroupWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGameSession mocks base method.
func (m *MockGameLiftAPI) CreateGameSession(arg0 *gamelift.CreateGameSessionInput) (*gamelift.CreateGameSessionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGameSession", arg0)
	ret0, _ := ret[0].(*gamelift.CreateGameSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGameSessionQueue mocks base method.
func (m *MockGameLiftAPI) CreateGameSessionQueue(arg0 *gamelift.CreateGameSessionQueueInput) (*gamelift.CreateGameSessionQueueOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGameSessionQueue", arg0)
	ret0, _ := ret[0].(*gamelift.CreateGameSessionQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGameSessionQueueRequest mocks base method.
func (m *MockGameLiftAPI) CreateGameSessionQueueRequest(arg0 *gamelift.CreateGameSessionQueueInput) (*request.Request, *gamelift.CreateGameSessionQueueOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGameSessionQueueRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateGameSessionQueueOutput)
	return ret0, ret1
}

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

// CreateGameSessionQueueWithContext mocks base method.
func (m *MockGameLiftAPI) CreateGameSessionQueueWithContext(arg0 aws.Context, arg1 *gamelift.CreateGameSessionQueueInput, arg2 ...request.Option) (*gamelift.CreateGameSessionQueueOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGameSessionQueueWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateGameSessionQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGameSessionRequest mocks base method.
func (m *MockGameLiftAPI) CreateGameSessionRequest(arg0 *gamelift.CreateGameSessionInput) (*request.Request, *gamelift.CreateGameSessionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGameSessionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateGameSessionOutput)
	return ret0, ret1
}

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

// CreateGameSessionWithContext mocks base method.
func (m *MockGameLiftAPI) CreateGameSessionWithContext(arg0 aws.Context, arg1 *gamelift.CreateGameSessionInput, arg2 ...request.Option) (*gamelift.CreateGameSessionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGameSessionWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateGameSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLocation mocks base method.
func (m *MockGameLiftAPI) CreateLocation(arg0 *gamelift.CreateLocationInput) (*gamelift.CreateLocationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocation", arg0)
	ret0, _ := ret[0].(*gamelift.CreateLocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLocationRequest mocks base method.
func (m *MockGameLiftAPI) CreateLocationRequest(arg0 *gamelift.CreateLocationInput) (*request.Request, *gamelift.CreateLocationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateLocationOutput)
	return ret0, ret1
}

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

// CreateLocationWithContext mocks base method.
func (m *MockGameLiftAPI) CreateLocationWithContext(arg0 aws.Context, arg1 *gamelift.CreateLocationInput, arg2 ...request.Option) (*gamelift.CreateLocationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateLocationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateLocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateMatchmakingConfiguration mocks base method.
func (m *MockGameLiftAPI) CreateMatchmakingConfiguration(arg0 *gamelift.CreateMatchmakingConfigurationInput) (*gamelift.CreateMatchmakingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMatchmakingConfiguration", arg0)
	ret0, _ := ret[0].(*gamelift.CreateMatchmakingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateMatchmakingConfigurationRequest mocks base method.
func (m *MockGameLiftAPI) CreateMatchmakingConfigurationRequest(arg0 *gamelift.CreateMatchmakingConfigurationInput) (*request.Request, *gamelift.CreateMatchmakingConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMatchmakingConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateMatchmakingConfigurationOutput)
	return ret0, ret1
}

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

// CreateMatchmakingConfigurationWithContext mocks base method.
func (m *MockGameLiftAPI) CreateMatchmakingConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.CreateMatchmakingConfigurationInput, arg2 ...request.Option) (*gamelift.CreateMatchmakingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateMatchmakingConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateMatchmakingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateMatchmakingRuleSet mocks base method.
func (m *MockGameLiftAPI) CreateMatchmakingRuleSet(arg0 *gamelift.CreateMatchmakingRuleSetInput) (*gamelift.CreateMatchmakingRuleSetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMatchmakingRuleSet", arg0)
	ret0, _ := ret[0].(*gamelift.CreateMatchmakingRuleSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateMatchmakingRuleSetRequest mocks base method.
func (m *MockGameLiftAPI) CreateMatchmakingRuleSetRequest(arg0 *gamelift.CreateMatchmakingRuleSetInput) (*request.Request, *gamelift.CreateMatchmakingRuleSetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMatchmakingRuleSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateMatchmakingRuleSetOutput)
	return ret0, ret1
}

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

// CreateMatchmakingRuleSetWithContext mocks base method.
func (m *MockGameLiftAPI) CreateMatchmakingRuleSetWithContext(arg0 aws.Context, arg1 *gamelift.CreateMatchmakingRuleSetInput, arg2 ...request.Option) (*gamelift.CreateMatchmakingRuleSetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateMatchmakingRuleSetWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateMatchmakingRuleSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePlayerSession mocks base method.
func (m *MockGameLiftAPI) CreatePlayerSession(arg0 *gamelift.CreatePlayerSessionInput) (*gamelift.CreatePlayerSessionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePlayerSession", arg0)
	ret0, _ := ret[0].(*gamelift.CreatePlayerSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePlayerSessionRequest mocks base method.
func (m *MockGameLiftAPI) CreatePlayerSessionRequest(arg0 *gamelift.CreatePlayerSessionInput) (*request.Request, *gamelift.CreatePlayerSessionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePlayerSessionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreatePlayerSessionOutput)
	return ret0, ret1
}

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

// CreatePlayerSessionWithContext mocks base method.
func (m *MockGameLiftAPI) CreatePlayerSessionWithContext(arg0 aws.Context, arg1 *gamelift.CreatePlayerSessionInput, arg2 ...request.Option) (*gamelift.CreatePlayerSessionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePlayerSessionWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreatePlayerSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePlayerSessions mocks base method.
func (m *MockGameLiftAPI) CreatePlayerSessions(arg0 *gamelift.CreatePlayerSessionsInput) (*gamelift.CreatePlayerSessionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePlayerSessions", arg0)
	ret0, _ := ret[0].(*gamelift.CreatePlayerSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePlayerSessionsRequest mocks base method.
func (m *MockGameLiftAPI) CreatePlayerSessionsRequest(arg0 *gamelift.CreatePlayerSessionsInput) (*request.Request, *gamelift.CreatePlayerSessionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePlayerSessionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreatePlayerSessionsOutput)
	return ret0, ret1
}

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

// CreatePlayerSessionsWithContext mocks base method.
func (m *MockGameLiftAPI) CreatePlayerSessionsWithContext(arg0 aws.Context, arg1 *gamelift.CreatePlayerSessionsInput, arg2 ...request.Option) (*gamelift.CreatePlayerSessionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePlayerSessionsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreatePlayerSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateScript mocks base method.
func (m *MockGameLiftAPI) CreateScript(arg0 *gamelift.CreateScriptInput) (*gamelift.CreateScriptOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateScript", arg0)
	ret0, _ := ret[0].(*gamelift.CreateScriptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateScriptRequest mocks base method.
func (m *MockGameLiftAPI) CreateScriptRequest(arg0 *gamelift.CreateScriptInput) (*request.Request, *gamelift.CreateScriptOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateScriptRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateScriptOutput)
	return ret0, ret1
}

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

// CreateScriptWithContext mocks base method.
func (m *MockGameLiftAPI) CreateScriptWithContext(arg0 aws.Context, arg1 *gamelift.CreateScriptInput, arg2 ...request.Option) (*gamelift.CreateScriptOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateScriptWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateScriptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpcPeeringAuthorization mocks base method.
func (m *MockGameLiftAPI) CreateVpcPeeringAuthorization(arg0 *gamelift.CreateVpcPeeringAuthorizationInput) (*gamelift.CreateVpcPeeringAuthorizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcPeeringAuthorization", arg0)
	ret0, _ := ret[0].(*gamelift.CreateVpcPeeringAuthorizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpcPeeringAuthorizationRequest mocks base method.
func (m *MockGameLiftAPI) CreateVpcPeeringAuthorizationRequest(arg0 *gamelift.CreateVpcPeeringAuthorizationInput) (*request.Request, *gamelift.CreateVpcPeeringAuthorizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcPeeringAuthorizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateVpcPeeringAuthorizationOutput)
	return ret0, ret1
}

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

// CreateVpcPeeringAuthorizationWithContext mocks base method.
func (m *MockGameLiftAPI) CreateVpcPeeringAuthorizationWithContext(arg0 aws.Context, arg1 *gamelift.CreateVpcPeeringAuthorizationInput, arg2 ...request.Option) (*gamelift.CreateVpcPeeringAuthorizationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpcPeeringAuthorizationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateVpcPeeringAuthorizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpcPeeringConnection mocks base method.
func (m *MockGameLiftAPI) CreateVpcPeeringConnection(arg0 *gamelift.CreateVpcPeeringConnectionInput) (*gamelift.CreateVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcPeeringConnection", arg0)
	ret0, _ := ret[0].(*gamelift.CreateVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpcPeeringConnectionRequest mocks base method.
func (m *MockGameLiftAPI) CreateVpcPeeringConnectionRequest(arg0 *gamelift.CreateVpcPeeringConnectionInput) (*request.Request, *gamelift.CreateVpcPeeringConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.CreateVpcPeeringConnectionOutput)
	return ret0, ret1
}

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

// CreateVpcPeeringConnectionWithContext mocks base method.
func (m *MockGameLiftAPI) CreateVpcPeeringConnectionWithContext(arg0 aws.Context, arg1 *gamelift.CreateVpcPeeringConnectionInput, arg2 ...request.Option) (*gamelift.CreateVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.CreateVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAlias mocks base method.
func (m *MockGameLiftAPI) DeleteAlias(arg0 *gamelift.DeleteAliasInput) (*gamelift.DeleteAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAlias", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAliasRequest mocks base method.
func (m *MockGameLiftAPI) DeleteAliasRequest(arg0 *gamelift.DeleteAliasInput) (*request.Request, *gamelift.DeleteAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteAliasOutput)
	return ret0, ret1
}

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

// DeleteAliasWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteAliasWithContext(arg0 aws.Context, arg1 *gamelift.DeleteAliasInput, arg2 ...request.Option) (*gamelift.DeleteAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAliasWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteBuild mocks base method.
func (m *MockGameLiftAPI) DeleteBuild(arg0 *gamelift.DeleteBuildInput) (*gamelift.DeleteBuildOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBuild", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteBuildOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteBuildRequest mocks base method.
func (m *MockGameLiftAPI) DeleteBuildRequest(arg0 *gamelift.DeleteBuildInput) (*request.Request, *gamelift.DeleteBuildOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBuildRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteBuildOutput)
	return ret0, ret1
}

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

// DeleteBuildWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteBuildWithContext(arg0 aws.Context, arg1 *gamelift.DeleteBuildInput, arg2 ...request.Option) (*gamelift.DeleteBuildOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBuildWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteBuildOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteContainerGroupDefinition mocks base method.
func (m *MockGameLiftAPI) DeleteContainerGroupDefinition(arg0 *gamelift.DeleteContainerGroupDefinitionInput) (*gamelift.DeleteContainerGroupDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteContainerGroupDefinition", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteContainerGroupDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteContainerGroupDefinitionRequest mocks base method.
func (m *MockGameLiftAPI) DeleteContainerGroupDefinitionRequest(arg0 *gamelift.DeleteContainerGroupDefinitionInput) (*request.Request, *gamelift.DeleteContainerGroupDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteContainerGroupDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteContainerGroupDefinitionOutput)
	return ret0, ret1
}

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

// DeleteContainerGroupDefinitionWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteContainerGroupDefinitionWithContext(arg0 aws.Context, arg1 *gamelift.DeleteContainerGroupDefinitionInput, arg2 ...request.Option) (*gamelift.DeleteContainerGroupDefinitionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteContainerGroupDefinitionWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteContainerGroupDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFleet mocks base method.
func (m *MockGameLiftAPI) DeleteFleet(arg0 *gamelift.DeleteFleetInput) (*gamelift.DeleteFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFleet", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFleetLocations mocks base method.
func (m *MockGameLiftAPI) DeleteFleetLocations(arg0 *gamelift.DeleteFleetLocationsInput) (*gamelift.DeleteFleetLocationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFleetLocations", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteFleetLocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFleetLocationsRequest mocks base method.
func (m *MockGameLiftAPI) DeleteFleetLocationsRequest(arg0 *gamelift.DeleteFleetLocationsInput) (*request.Request, *gamelift.DeleteFleetLocationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFleetLocationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteFleetLocationsOutput)
	return ret0, ret1
}

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

// DeleteFleetLocationsWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteFleetLocationsWithContext(arg0 aws.Context, arg1 *gamelift.DeleteFleetLocationsInput, arg2 ...request.Option) (*gamelift.DeleteFleetLocationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteFleetLocationsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteFleetLocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFleetRequest mocks base method.
func (m *MockGameLiftAPI) DeleteFleetRequest(arg0 *gamelift.DeleteFleetInput) (*request.Request, *gamelift.DeleteFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteFleetOutput)
	return ret0, ret1
}

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

// DeleteFleetWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteFleetWithContext(arg0 aws.Context, arg1 *gamelift.DeleteFleetInput, arg2 ...request.Option) (*gamelift.DeleteFleetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteFleetWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGameServerGroup mocks base method.
func (m *MockGameLiftAPI) DeleteGameServerGroup(arg0 *gamelift.DeleteGameServerGroupInput) (*gamelift.DeleteGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGameServerGroup", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGameServerGroupRequest mocks base method.
func (m *MockGameLiftAPI) DeleteGameServerGroupRequest(arg0 *gamelift.DeleteGameServerGroupInput) (*request.Request, *gamelift.DeleteGameServerGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGameServerGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteGameServerGroupOutput)
	return ret0, ret1
}

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

// DeleteGameServerGroupWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.DeleteGameServerGroupInput, arg2 ...request.Option) (*gamelift.DeleteGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteGameServerGroupWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGameSessionQueue mocks base method.
func (m *MockGameLiftAPI) DeleteGameSessionQueue(arg0 *gamelift.DeleteGameSessionQueueInput) (*gamelift.DeleteGameSessionQueueOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGameSessionQueue", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteGameSessionQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGameSessionQueueRequest mocks base method.
func (m *MockGameLiftAPI) DeleteGameSessionQueueRequest(arg0 *gamelift.DeleteGameSessionQueueInput) (*request.Request, *gamelift.DeleteGameSessionQueueOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGameSessionQueueRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteGameSessionQueueOutput)
	return ret0, ret1
}

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

// DeleteGameSessionQueueWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteGameSessionQueueWithContext(arg0 aws.Context, arg1 *gamelift.DeleteGameSessionQueueInput, arg2 ...request.Option) (*gamelift.DeleteGameSessionQueueOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteGameSessionQueueWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteGameSessionQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteLocation mocks base method.
func (m *MockGameLiftAPI) DeleteLocation(arg0 *gamelift.DeleteLocationInput) (*gamelift.DeleteLocationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocation", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteLocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteLocationRequest mocks base method.
func (m *MockGameLiftAPI) DeleteLocationRequest(arg0 *gamelift.DeleteLocationInput) (*request.Request, *gamelift.DeleteLocationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteLocationOutput)
	return ret0, ret1
}

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

// DeleteLocationWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteLocationWithContext(arg0 aws.Context, arg1 *gamelift.DeleteLocationInput, arg2 ...request.Option) (*gamelift.DeleteLocationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteLocationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteLocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteMatchmakingConfiguration mocks base method.
func (m *MockGameLiftAPI) DeleteMatchmakingConfiguration(arg0 *gamelift.DeleteMatchmakingConfigurationInput) (*gamelift.DeleteMatchmakingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMatchmakingConfiguration", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteMatchmakingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteMatchmakingConfigurationRequest mocks base method.
func (m *MockGameLiftAPI) DeleteMatchmakingConfigurationRequest(arg0 *gamelift.DeleteMatchmakingConfigurationInput) (*request.Request, *gamelift.DeleteMatchmakingConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMatchmakingConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteMatchmakingConfigurationOutput)
	return ret0, ret1
}

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

// DeleteMatchmakingConfigurationWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteMatchmakingConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.DeleteMatchmakingConfigurationInput, arg2 ...request.Option) (*gamelift.DeleteMatchmakingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMatchmakingConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteMatchmakingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteMatchmakingRuleSet mocks base method.
func (m *MockGameLiftAPI) DeleteMatchmakingRuleSet(arg0 *gamelift.DeleteMatchmakingRuleSetInput) (*gamelift.DeleteMatchmakingRuleSetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMatchmakingRuleSet", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteMatchmakingRuleSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteMatchmakingRuleSetRequest mocks base method.
func (m *MockGameLiftAPI) DeleteMatchmakingRuleSetRequest(arg0 *gamelift.DeleteMatchmakingRuleSetInput) (*request.Request, *gamelift.DeleteMatchmakingRuleSetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMatchmakingRuleSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteMatchmakingRuleSetOutput)
	return ret0, ret1
}

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

// DeleteMatchmakingRuleSetWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteMatchmakingRuleSetWithContext(arg0 aws.Context, arg1 *gamelift.DeleteMatchmakingRuleSetInput, arg2 ...request.Option) (*gamelift.DeleteMatchmakingRuleSetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMatchmakingRuleSetWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteMatchmakingRuleSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteScalingPolicy mocks base method.
func (m *MockGameLiftAPI) DeleteScalingPolicy(arg0 *gamelift.DeleteScalingPolicyInput) (*gamelift.DeleteScalingPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteScalingPolicy", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteScalingPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteScalingPolicyRequest mocks base method.
func (m *MockGameLiftAPI) DeleteScalingPolicyRequest(arg0 *gamelift.DeleteScalingPolicyInput) (*request.Request, *gamelift.DeleteScalingPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteScalingPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteScalingPolicyOutput)
	return ret0, ret1
}

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

// DeleteScalingPolicyWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteScalingPolicyWithContext(arg0 aws.Context, arg1 *gamelift.DeleteScalingPolicyInput, arg2 ...request.Option) (*gamelift.DeleteScalingPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteScalingPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteScalingPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteScript mocks base method.
func (m *MockGameLiftAPI) DeleteScript(arg0 *gamelift.DeleteScriptInput) (*gamelift.DeleteScriptOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteScript", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteScriptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteScriptRequest mocks base method.
func (m *MockGameLiftAPI) DeleteScriptRequest(arg0 *gamelift.DeleteScriptInput) (*request.Request, *gamelift.DeleteScriptOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteScriptRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteScriptOutput)
	return ret0, ret1
}

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

// DeleteScriptWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteScriptWithContext(arg0 aws.Context, arg1 *gamelift.DeleteScriptInput, arg2 ...request.Option) (*gamelift.DeleteScriptOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteScriptWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteScriptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpcPeeringAuthorization mocks base method.
func (m *MockGameLiftAPI) DeleteVpcPeeringAuthorization(arg0 *gamelift.DeleteVpcPeeringAuthorizationInput) (*gamelift.DeleteVpcPeeringAuthorizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcPeeringAuthorization", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteVpcPeeringAuthorizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpcPeeringAuthorizationRequest mocks base method.
func (m *MockGameLiftAPI) DeleteVpcPeeringAuthorizationRequest(arg0 *gamelift.DeleteVpcPeeringAuthorizationInput) (*request.Request, *gamelift.DeleteVpcPeeringAuthorizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcPeeringAuthorizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteVpcPeeringAuthorizationOutput)
	return ret0, ret1
}

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

// DeleteVpcPeeringAuthorizationWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteVpcPeeringAuthorizationWithContext(arg0 aws.Context, arg1 *gamelift.DeleteVpcPeeringAuthorizationInput, arg2 ...request.Option) (*gamelift.DeleteVpcPeeringAuthorizationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpcPeeringAuthorizationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteVpcPeeringAuthorizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpcPeeringConnection mocks base method.
func (m *MockGameLiftAPI) DeleteVpcPeeringConnection(arg0 *gamelift.DeleteVpcPeeringConnectionInput) (*gamelift.DeleteVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcPeeringConnection", arg0)
	ret0, _ := ret[0].(*gamelift.DeleteVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpcPeeringConnectionRequest mocks base method.
func (m *MockGameLiftAPI) DeleteVpcPeeringConnectionRequest(arg0 *gamelift.DeleteVpcPeeringConnectionInput) (*request.Request, *gamelift.DeleteVpcPeeringConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeleteVpcPeeringConnectionOutput)
	return ret0, ret1
}

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

// DeleteVpcPeeringConnectionWithContext mocks base method.
func (m *MockGameLiftAPI) DeleteVpcPeeringConnectionWithContext(arg0 aws.Context, arg1 *gamelift.DeleteVpcPeeringConnectionInput, arg2 ...request.Option) (*gamelift.DeleteVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeleteVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterCompute mocks base method.
func (m *MockGameLiftAPI) DeregisterCompute(arg0 *gamelift.DeregisterComputeInput) (*gamelift.DeregisterComputeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterCompute", arg0)
	ret0, _ := ret[0].(*gamelift.DeregisterComputeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterComputeRequest mocks base method.
func (m *MockGameLiftAPI) DeregisterComputeRequest(arg0 *gamelift.DeregisterComputeInput) (*request.Request, *gamelift.DeregisterComputeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterComputeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeregisterComputeOutput)
	return ret0, ret1
}

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

// DeregisterComputeWithContext mocks base method.
func (m *MockGameLiftAPI) DeregisterComputeWithContext(arg0 aws.Context, arg1 *gamelift.DeregisterComputeInput, arg2 ...request.Option) (*gamelift.DeregisterComputeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeregisterComputeWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeregisterComputeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterGameServer mocks base method.
func (m *MockGameLiftAPI) DeregisterGameServer(arg0 *gamelift.DeregisterGameServerInput) (*gamelift.DeregisterGameServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterGameServer", arg0)
	ret0, _ := ret[0].(*gamelift.DeregisterGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterGameServerRequest mocks base method.
func (m *MockGameLiftAPI) DeregisterGameServerRequest(arg0 *gamelift.DeregisterGameServerInput) (*request.Request, *gamelift.DeregisterGameServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterGameServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DeregisterGameServerOutput)
	return ret0, ret1
}

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

// DeregisterGameServerWithContext mocks base method.
func (m *MockGameLiftAPI) DeregisterGameServerWithContext(arg0 aws.Context, arg1 *gamelift.DeregisterGameServerInput, arg2 ...request.Option) (*gamelift.DeregisterGameServerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeregisterGameServerWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DeregisterGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAlias mocks base method.
func (m *MockGameLiftAPI) DescribeAlias(arg0 *gamelift.DescribeAliasInput) (*gamelift.DescribeAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAlias", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAliasRequest mocks base method.
func (m *MockGameLiftAPI) DescribeAliasRequest(arg0 *gamelift.DescribeAliasInput) (*request.Request, *gamelift.DescribeAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeAliasOutput)
	return ret0, ret1
}

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

// DescribeAliasWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeAliasWithContext(arg0 aws.Context, arg1 *gamelift.DescribeAliasInput, arg2 ...request.Option) (*gamelift.DescribeAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAliasWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBuild mocks base method.
func (m *MockGameLiftAPI) DescribeBuild(arg0 *gamelift.DescribeBuildInput) (*gamelift.DescribeBuildOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBuild", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeBuildOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBuildRequest mocks base method.
func (m *MockGameLiftAPI) DescribeBuildRequest(arg0 *gamelift.DescribeBuildInput) (*request.Request, *gamelift.DescribeBuildOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBuildRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeBuildOutput)
	return ret0, ret1
}

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

// DescribeBuildWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeBuildWithContext(arg0 aws.Context, arg1 *gamelift.DescribeBuildInput, arg2 ...request.Option) (*gamelift.DescribeBuildOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBuildWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeBuildOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCompute mocks base method.
func (m *MockGameLiftAPI) DescribeCompute(arg0 *gamelift.DescribeComputeInput) (*gamelift.DescribeComputeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCompute", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeComputeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeComputeRequest mocks base method.
func (m *MockGameLiftAPI) DescribeComputeRequest(arg0 *gamelift.DescribeComputeInput) (*request.Request, *gamelift.DescribeComputeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeComputeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeComputeOutput)
	return ret0, ret1
}

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

// DescribeComputeWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeComputeWithContext(arg0 aws.Context, arg1 *gamelift.DescribeComputeInput, arg2 ...request.Option) (*gamelift.DescribeComputeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeComputeWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeComputeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeContainerGroupDefinition mocks base method.
func (m *MockGameLiftAPI) DescribeContainerGroupDefinition(arg0 *gamelift.DescribeContainerGroupDefinitionInput) (*gamelift.DescribeContainerGroupDefinitionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeContainerGroupDefinition", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeContainerGroupDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeContainerGroupDefinitionRequest mocks base method.
func (m *MockGameLiftAPI) DescribeContainerGroupDefinitionRequest(arg0 *gamelift.DescribeContainerGroupDefinitionInput) (*request.Request, *gamelift.DescribeContainerGroupDefinitionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeContainerGroupDefinitionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeContainerGroupDefinitionOutput)
	return ret0, ret1
}

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

// DescribeContainerGroupDefinitionWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeContainerGroupDefinitionWithContext(arg0 aws.Context, arg1 *gamelift.DescribeContainerGroupDefinitionInput, arg2 ...request.Option) (*gamelift.DescribeContainerGroupDefinitionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeContainerGroupDefinitionWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeContainerGroupDefinitionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEC2InstanceLimits mocks base method.
func (m *MockGameLiftAPI) DescribeEC2InstanceLimits(arg0 *gamelift.DescribeEC2InstanceLimitsInput) (*gamelift.DescribeEC2InstanceLimitsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEC2InstanceLimits", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeEC2InstanceLimitsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEC2InstanceLimitsRequest mocks base method.
func (m *MockGameLiftAPI) DescribeEC2InstanceLimitsRequest(arg0 *gamelift.DescribeEC2InstanceLimitsInput) (*request.Request, *gamelift.DescribeEC2InstanceLimitsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEC2InstanceLimitsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeEC2InstanceLimitsOutput)
	return ret0, ret1
}

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

// DescribeEC2InstanceLimitsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeEC2InstanceLimitsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeEC2InstanceLimitsInput, arg2 ...request.Option) (*gamelift.DescribeEC2InstanceLimitsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeEC2InstanceLimitsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeEC2InstanceLimitsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetAttributes mocks base method.
func (m *MockGameLiftAPI) DescribeFleetAttributes(arg0 *gamelift.DescribeFleetAttributesInput) (*gamelift.DescribeFleetAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetAttributes", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeFleetAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetAttributesPages mocks base method.
func (m *MockGameLiftAPI) DescribeFleetAttributesPages(arg0 *gamelift.DescribeFleetAttributesInput, arg1 func(*gamelift.DescribeFleetAttributesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetAttributesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetAttributesPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetAttributesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetAttributesInput, arg2 func(*gamelift.DescribeFleetAttributesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetAttributesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetAttributesRequest mocks base method.
func (m *MockGameLiftAPI) DescribeFleetAttributesRequest(arg0 *gamelift.DescribeFleetAttributesInput) (*request.Request, *gamelift.DescribeFleetAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeFleetAttributesOutput)
	return ret0, ret1
}

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

// DescribeFleetAttributesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetAttributesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetAttributesInput, arg2 ...request.Option) (*gamelift.DescribeFleetAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeFleetAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetCapacity mocks base method.
func (m *MockGameLiftAPI) DescribeFleetCapacity(arg0 *gamelift.DescribeFleetCapacityInput) (*gamelift.DescribeFleetCapacityOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetCapacity", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeFleetCapacityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetCapacityPages mocks base method.
func (m *MockGameLiftAPI) DescribeFleetCapacityPages(arg0 *gamelift.DescribeFleetCapacityInput, arg1 func(*gamelift.DescribeFleetCapacityOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetCapacityPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetCapacityPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetCapacityPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetCapacityInput, arg2 func(*gamelift.DescribeFleetCapacityOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetCapacityPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetCapacityRequest mocks base method.
func (m *MockGameLiftAPI) DescribeFleetCapacityRequest(arg0 *gamelift.DescribeFleetCapacityInput) (*request.Request, *gamelift.DescribeFleetCapacityOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetCapacityRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeFleetCapacityOutput)
	return ret0, ret1
}

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

// DescribeFleetCapacityWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetCapacityWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetCapacityInput, arg2 ...request.Option) (*gamelift.DescribeFleetCapacityOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetCapacityWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeFleetCapacityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetEvents mocks base method.
func (m *MockGameLiftAPI) DescribeFleetEvents(arg0 *gamelift.DescribeFleetEventsInput) (*gamelift.DescribeFleetEventsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetEvents", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeFleetEventsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetEventsPages mocks base method.
func (m *MockGameLiftAPI) DescribeFleetEventsPages(arg0 *gamelift.DescribeFleetEventsInput, arg1 func(*gamelift.DescribeFleetEventsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetEventsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetEventsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetEventsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetEventsInput, arg2 func(*gamelift.DescribeFleetEventsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetEventsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetEventsRequest mocks base method.
func (m *MockGameLiftAPI) DescribeFleetEventsRequest(arg0 *gamelift.DescribeFleetEventsInput) (*request.Request, *gamelift.DescribeFleetEventsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetEventsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeFleetEventsOutput)
	return ret0, ret1
}

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

// DescribeFleetEventsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetEventsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetEventsInput, arg2 ...request.Option) (*gamelift.DescribeFleetEventsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetEventsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeFleetEventsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetLocationAttributes mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationAttributes(arg0 *gamelift.DescribeFleetLocationAttributesInput) (*gamelift.DescribeFleetLocationAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetLocationAttributes", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeFleetLocationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetLocationAttributesPages mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationAttributesPages(arg0 *gamelift.DescribeFleetLocationAttributesInput, arg1 func(*gamelift.DescribeFleetLocationAttributesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetLocationAttributesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetLocationAttributesPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationAttributesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetLocationAttributesInput, arg2 func(*gamelift.DescribeFleetLocationAttributesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetLocationAttributesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetLocationAttributesRequest mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationAttributesRequest(arg0 *gamelift.DescribeFleetLocationAttributesInput) (*request.Request, *gamelift.DescribeFleetLocationAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetLocationAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeFleetLocationAttributesOutput)
	return ret0, ret1
}

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

// DescribeFleetLocationAttributesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationAttributesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetLocationAttributesInput, arg2 ...request.Option) (*gamelift.DescribeFleetLocationAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetLocationAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeFleetLocationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetLocationCapacity mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationCapacity(arg0 *gamelift.DescribeFleetLocationCapacityInput) (*gamelift.DescribeFleetLocationCapacityOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetLocationCapacity", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeFleetLocationCapacityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetLocationCapacityRequest mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationCapacityRequest(arg0 *gamelift.DescribeFleetLocationCapacityInput) (*request.Request, *gamelift.DescribeFleetLocationCapacityOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetLocationCapacityRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeFleetLocationCapacityOutput)
	return ret0, ret1
}

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

// DescribeFleetLocationCapacityWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationCapacityWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetLocationCapacityInput, arg2 ...request.Option) (*gamelift.DescribeFleetLocationCapacityOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetLocationCapacityWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeFleetLocationCapacityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetLocationUtilization mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationUtilization(arg0 *gamelift.DescribeFleetLocationUtilizationInput) (*gamelift.DescribeFleetLocationUtilizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetLocationUtilization", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeFleetLocationUtilizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetLocationUtilizationRequest mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationUtilizationRequest(arg0 *gamelift.DescribeFleetLocationUtilizationInput) (*request.Request, *gamelift.DescribeFleetLocationUtilizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetLocationUtilizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeFleetLocationUtilizationOutput)
	return ret0, ret1
}

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

// DescribeFleetLocationUtilizationWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetLocationUtilizationWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetLocationUtilizationInput, arg2 ...request.Option) (*gamelift.DescribeFleetLocationUtilizationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetLocationUtilizationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeFleetLocationUtilizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetPortSettings mocks base method.
func (m *MockGameLiftAPI) DescribeFleetPortSettings(arg0 *gamelift.DescribeFleetPortSettingsInput) (*gamelift.DescribeFleetPortSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetPortSettings", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeFleetPortSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetPortSettingsRequest mocks base method.
func (m *MockGameLiftAPI) DescribeFleetPortSettingsRequest(arg0 *gamelift.DescribeFleetPortSettingsInput) (*request.Request, *gamelift.DescribeFleetPortSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetPortSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeFleetPortSettingsOutput)
	return ret0, ret1
}

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

// DescribeFleetPortSettingsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetPortSettingsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetPortSettingsInput, arg2 ...request.Option) (*gamelift.DescribeFleetPortSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetPortSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeFleetPortSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetUtilization mocks base method.
func (m *MockGameLiftAPI) DescribeFleetUtilization(arg0 *gamelift.DescribeFleetUtilizationInput) (*gamelift.DescribeFleetUtilizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetUtilization", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeFleetUtilizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetUtilizationPages mocks base method.
func (m *MockGameLiftAPI) DescribeFleetUtilizationPages(arg0 *gamelift.DescribeFleetUtilizationInput, arg1 func(*gamelift.DescribeFleetUtilizationOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetUtilizationPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetUtilizationPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetUtilizationPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetUtilizationInput, arg2 func(*gamelift.DescribeFleetUtilizationOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetUtilizationPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetUtilizationRequest mocks base method.
func (m *MockGameLiftAPI) DescribeFleetUtilizationRequest(arg0 *gamelift.DescribeFleetUtilizationInput) (*request.Request, *gamelift.DescribeFleetUtilizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetUtilizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeFleetUtilizationOutput)
	return ret0, ret1
}

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

// DescribeFleetUtilizationWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeFleetUtilizationWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetUtilizationInput, arg2 ...request.Option) (*gamelift.DescribeFleetUtilizationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetUtilizationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeFleetUtilizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameServer mocks base method.
func (m *MockGameLiftAPI) DescribeGameServer(arg0 *gamelift.DescribeGameServerInput) (*gamelift.DescribeGameServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameServer", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameServerGroup mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerGroup(arg0 *gamelift.DescribeGameServerGroupInput) (*gamelift.DescribeGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameServerGroup", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameServerGroupRequest mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerGroupRequest(arg0 *gamelift.DescribeGameServerGroupInput) (*request.Request, *gamelift.DescribeGameServerGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameServerGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeGameServerGroupOutput)
	return ret0, ret1
}

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

// DescribeGameServerGroupWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameServerGroupInput, arg2 ...request.Option) (*gamelift.DescribeGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameServerGroupWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameServerInstances mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerInstances(arg0 *gamelift.DescribeGameServerInstancesInput) (*gamelift.DescribeGameServerInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameServerInstances", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeGameServerInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameServerInstancesPages mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerInstancesPages(arg0 *gamelift.DescribeGameServerInstancesInput, arg1 func(*gamelift.DescribeGameServerInstancesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameServerInstancesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeGameServerInstancesPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerInstancesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameServerInstancesInput, arg2 func(*gamelift.DescribeGameServerInstancesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameServerInstancesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeGameServerInstancesRequest mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerInstancesRequest(arg0 *gamelift.DescribeGameServerInstancesInput) (*request.Request, *gamelift.DescribeGameServerInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameServerInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeGameServerInstancesOutput)
	return ret0, ret1
}

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

// DescribeGameServerInstancesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerInstancesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameServerInstancesInput, arg2 ...request.Option) (*gamelift.DescribeGameServerInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameServerInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeGameServerInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameServerRequest mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerRequest(arg0 *gamelift.DescribeGameServerInput) (*request.Request, *gamelift.DescribeGameServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeGameServerOutput)
	return ret0, ret1
}

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

// DescribeGameServerWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameServerWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameServerInput, arg2 ...request.Option) (*gamelift.DescribeGameServerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameServerWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameSessionDetails mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionDetails(arg0 *gamelift.DescribeGameSessionDetailsInput) (*gamelift.DescribeGameSessionDetailsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionDetails", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeGameSessionDetailsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameSessionDetailsPages mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionDetailsPages(arg0 *gamelift.DescribeGameSessionDetailsInput, arg1 func(*gamelift.DescribeGameSessionDetailsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionDetailsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeGameSessionDetailsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionDetailsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionDetailsInput, arg2 func(*gamelift.DescribeGameSessionDetailsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameSessionDetailsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeGameSessionDetailsRequest mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionDetailsRequest(arg0 *gamelift.DescribeGameSessionDetailsInput) (*request.Request, *gamelift.DescribeGameSessionDetailsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionDetailsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeGameSessionDetailsOutput)
	return ret0, ret1
}

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

// DescribeGameSessionDetailsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionDetailsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionDetailsInput, arg2 ...request.Option) (*gamelift.DescribeGameSessionDetailsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameSessionDetailsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeGameSessionDetailsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameSessionPlacement mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionPlacement(arg0 *gamelift.DescribeGameSessionPlacementInput) (*gamelift.DescribeGameSessionPlacementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionPlacement", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeGameSessionPlacementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameSessionPlacementRequest mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionPlacementRequest(arg0 *gamelift.DescribeGameSessionPlacementInput) (*request.Request, *gamelift.DescribeGameSessionPlacementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionPlacementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeGameSessionPlacementOutput)
	return ret0, ret1
}

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

// DescribeGameSessionPlacementWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionPlacementWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionPlacementInput, arg2 ...request.Option) (*gamelift.DescribeGameSessionPlacementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameSessionPlacementWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeGameSessionPlacementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameSessionQueues mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionQueues(arg0 *gamelift.DescribeGameSessionQueuesInput) (*gamelift.DescribeGameSessionQueuesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionQueues", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeGameSessionQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameSessionQueuesPages mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionQueuesPages(arg0 *gamelift.DescribeGameSessionQueuesInput, arg1 func(*gamelift.DescribeGameSessionQueuesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionQueuesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeGameSessionQueuesPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionQueuesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionQueuesInput, arg2 func(*gamelift.DescribeGameSessionQueuesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameSessionQueuesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeGameSessionQueuesRequest mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionQueuesRequest(arg0 *gamelift.DescribeGameSessionQueuesInput) (*request.Request, *gamelift.DescribeGameSessionQueuesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionQueuesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeGameSessionQueuesOutput)
	return ret0, ret1
}

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

// DescribeGameSessionQueuesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionQueuesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionQueuesInput, arg2 ...request.Option) (*gamelift.DescribeGameSessionQueuesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameSessionQueuesWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeGameSessionQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameSessions mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessions(arg0 *gamelift.DescribeGameSessionsInput) (*gamelift.DescribeGameSessionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessions", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeGameSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGameSessionsPages mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionsPages(arg0 *gamelift.DescribeGameSessionsInput, arg1 func(*gamelift.DescribeGameSessionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeGameSessionsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionsInput, arg2 func(*gamelift.DescribeGameSessionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameSessionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeGameSessionsRequest mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionsRequest(arg0 *gamelift.DescribeGameSessionsInput) (*request.Request, *gamelift.DescribeGameSessionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGameSessionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeGameSessionsOutput)
	return ret0, ret1
}

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

// DescribeGameSessionsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeGameSessionsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionsInput, arg2 ...request.Option) (*gamelift.DescribeGameSessionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGameSessionsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeGameSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstances mocks base method.
func (m *MockGameLiftAPI) DescribeInstances(arg0 *gamelift.DescribeInstancesInput) (*gamelift.DescribeInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstances", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstancesPages mocks base method.
func (m *MockGameLiftAPI) DescribeInstancesPages(arg0 *gamelift.DescribeInstancesInput, arg1 func(*gamelift.DescribeInstancesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstancesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstancesPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeInstancesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeInstancesInput, arg2 func(*gamelift.DescribeInstancesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstancesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstancesRequest mocks base method.
func (m *MockGameLiftAPI) DescribeInstancesRequest(arg0 *gamelift.DescribeInstancesInput) (*request.Request, *gamelift.DescribeInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeInstancesOutput)
	return ret0, ret1
}

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

// DescribeInstancesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeInstancesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeInstancesInput, arg2 ...request.Option) (*gamelift.DescribeInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMatchmaking mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmaking(arg0 *gamelift.DescribeMatchmakingInput) (*gamelift.DescribeMatchmakingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMatchmaking", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeMatchmakingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMatchmakingConfigurations mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingConfigurations(arg0 *gamelift.DescribeMatchmakingConfigurationsInput) (*gamelift.DescribeMatchmakingConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurations", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeMatchmakingConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMatchmakingConfigurationsPages mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingConfigurationsPages(arg0 *gamelift.DescribeMatchmakingConfigurationsInput, arg1 func(*gamelift.DescribeMatchmakingConfigurationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeMatchmakingConfigurationsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingConfigurationsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingConfigurationsInput, arg2 func(*gamelift.DescribeMatchmakingConfigurationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeMatchmakingConfigurationsRequest mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingConfigurationsRequest(arg0 *gamelift.DescribeMatchmakingConfigurationsInput) (*request.Request, *gamelift.DescribeMatchmakingConfigurationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeMatchmakingConfigurationsOutput)
	return ret0, ret1
}

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

// DescribeMatchmakingConfigurationsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingConfigurationsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingConfigurationsInput, arg2 ...request.Option) (*gamelift.DescribeMatchmakingConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurationsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeMatchmakingConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMatchmakingRequest mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingRequest(arg0 *gamelift.DescribeMatchmakingInput) (*request.Request, *gamelift.DescribeMatchmakingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMatchmakingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeMatchmakingOutput)
	return ret0, ret1
}

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

// DescribeMatchmakingRuleSets mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingRuleSets(arg0 *gamelift.DescribeMatchmakingRuleSetsInput) (*gamelift.DescribeMatchmakingRuleSetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSets", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeMatchmakingRuleSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMatchmakingRuleSetsPages mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingRuleSetsPages(arg0 *gamelift.DescribeMatchmakingRuleSetsInput, arg1 func(*gamelift.DescribeMatchmakingRuleSetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeMatchmakingRuleSetsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingRuleSetsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingRuleSetsInput, arg2 func(*gamelift.DescribeMatchmakingRuleSetsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeMatchmakingRuleSetsRequest mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingRuleSetsRequest(arg0 *gamelift.DescribeMatchmakingRuleSetsInput) (*request.Request, *gamelift.DescribeMatchmakingRuleSetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeMatchmakingRuleSetsOutput)
	return ret0, ret1
}

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

// DescribeMatchmakingRuleSetsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingRuleSetsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingRuleSetsInput, arg2 ...request.Option) (*gamelift.DescribeMatchmakingRuleSetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSetsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeMatchmakingRuleSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMatchmakingWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeMatchmakingWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingInput, arg2 ...request.Option) (*gamelift.DescribeMatchmakingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMatchmakingWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeMatchmakingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePlayerSessions mocks base method.
func (m *MockGameLiftAPI) DescribePlayerSessions(arg0 *gamelift.DescribePlayerSessionsInput) (*gamelift.DescribePlayerSessionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePlayerSessions", arg0)
	ret0, _ := ret[0].(*gamelift.DescribePlayerSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePlayerSessionsPages mocks base method.
func (m *MockGameLiftAPI) DescribePlayerSessionsPages(arg0 *gamelift.DescribePlayerSessionsInput, arg1 func(*gamelift.DescribePlayerSessionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePlayerSessionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribePlayerSessionsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribePlayerSessionsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribePlayerSessionsInput, arg2 func(*gamelift.DescribePlayerSessionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribePlayerSessionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribePlayerSessionsRequest mocks base method.
func (m *MockGameLiftAPI) DescribePlayerSessionsRequest(arg0 *gamelift.DescribePlayerSessionsInput) (*request.Request, *gamelift.DescribePlayerSessionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePlayerSessionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribePlayerSessionsOutput)
	return ret0, ret1
}

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

// DescribePlayerSessionsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribePlayerSessionsWithContext(arg0 aws.Context, arg1 *gamelift.DescribePlayerSessionsInput, arg2 ...request.Option) (*gamelift.DescribePlayerSessionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribePlayerSessionsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribePlayerSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeRuntimeConfiguration mocks base method.
func (m *MockGameLiftAPI) DescribeRuntimeConfiguration(arg0 *gamelift.DescribeRuntimeConfigurationInput) (*gamelift.DescribeRuntimeConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRuntimeConfiguration", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeRuntimeConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeRuntimeConfigurationRequest mocks base method.
func (m *MockGameLiftAPI) DescribeRuntimeConfigurationRequest(arg0 *gamelift.DescribeRuntimeConfigurationInput) (*request.Request, *gamelift.DescribeRuntimeConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRuntimeConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeRuntimeConfigurationOutput)
	return ret0, ret1
}

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

// DescribeRuntimeConfigurationWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeRuntimeConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.DescribeRuntimeConfigurationInput, arg2 ...request.Option) (*gamelift.DescribeRuntimeConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeRuntimeConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeRuntimeConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeScalingPolicies mocks base method.
func (m *MockGameLiftAPI) DescribeScalingPolicies(arg0 *gamelift.DescribeScalingPoliciesInput) (*gamelift.DescribeScalingPoliciesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScalingPolicies", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeScalingPoliciesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeScalingPoliciesPages mocks base method.
func (m *MockGameLiftAPI) DescribeScalingPoliciesPages(arg0 *gamelift.DescribeScalingPoliciesInput, arg1 func(*gamelift.DescribeScalingPoliciesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScalingPoliciesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeScalingPoliciesPagesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeScalingPoliciesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeScalingPoliciesInput, arg2 func(*gamelift.DescribeScalingPoliciesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeScalingPoliciesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeScalingPoliciesRequest mocks base method.
func (m *MockGameLiftAPI) DescribeScalingPoliciesRequest(arg0 *gamelift.DescribeScalingPoliciesInput) (*request.Request, *gamelift.DescribeScalingPoliciesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScalingPoliciesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeScalingPoliciesOutput)
	return ret0, ret1
}

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

// DescribeScalingPoliciesWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeScalingPoliciesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeScalingPoliciesInput, arg2 ...request.Option) (*gamelift.DescribeScalingPoliciesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeScalingPoliciesWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeScalingPoliciesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeScript mocks base method.
func (m *MockGameLiftAPI) DescribeScript(arg0 *gamelift.DescribeScriptInput) (*gamelift.DescribeScriptOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScript", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeScriptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeScriptRequest mocks base method.
func (m *MockGameLiftAPI) DescribeScriptRequest(arg0 *gamelift.DescribeScriptInput) (*request.Request, *gamelift.DescribeScriptOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScriptRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeScriptOutput)
	return ret0, ret1
}

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

// DescribeScriptWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeScriptWithContext(arg0 aws.Context, arg1 *gamelift.DescribeScriptInput, arg2 ...request.Option) (*gamelift.DescribeScriptOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeScriptWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeScriptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcPeeringAuthorizations mocks base method.
func (m *MockGameLiftAPI) DescribeVpcPeeringAuthorizations(arg0 *gamelift.DescribeVpcPeeringAuthorizationsInput) (*gamelift.DescribeVpcPeeringAuthorizationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcPeeringAuthorizations", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeVpcPeeringAuthorizationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcPeeringAuthorizationsRequest mocks base method.
func (m *MockGameLiftAPI) DescribeVpcPeeringAuthorizationsRequest(arg0 *gamelift.DescribeVpcPeeringAuthorizationsInput) (*request.Request, *gamelift.DescribeVpcPeeringAuthorizationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcPeeringAuthorizationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeVpcPeeringAuthorizationsOutput)
	return ret0, ret1
}

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

// DescribeVpcPeeringAuthorizationsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeVpcPeeringAuthorizationsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeVpcPeeringAuthorizationsInput, arg2 ...request.Option) (*gamelift.DescribeVpcPeeringAuthorizationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcPeeringAuthorizationsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeVpcPeeringAuthorizationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcPeeringConnections mocks base method.
func (m *MockGameLiftAPI) DescribeVpcPeeringConnections(arg0 *gamelift.DescribeVpcPeeringConnectionsInput) (*gamelift.DescribeVpcPeeringConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnections", arg0)
	ret0, _ := ret[0].(*gamelift.DescribeVpcPeeringConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcPeeringConnectionsRequest mocks base method.
func (m *MockGameLiftAPI) DescribeVpcPeeringConnectionsRequest(arg0 *gamelift.DescribeVpcPeeringConnectionsInput) (*request.Request, *gamelift.DescribeVpcPeeringConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.DescribeVpcPeeringConnectionsOutput)
	return ret0, ret1
}

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

// DescribeVpcPeeringConnectionsWithContext mocks base method.
func (m *MockGameLiftAPI) DescribeVpcPeeringConnectionsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeVpcPeeringConnectionsInput, arg2 ...request.Option) (*gamelift.DescribeVpcPeeringConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.DescribeVpcPeeringConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetComputeAccess mocks base method.
func (m *MockGameLiftAPI) GetComputeAccess(arg0 *gamelift.GetComputeAccessInput) (*gamelift.GetComputeAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputeAccess", arg0)
	ret0, _ := ret[0].(*gamelift.GetComputeAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetComputeAccessRequest mocks base method.
func (m *MockGameLiftAPI) GetComputeAccessRequest(arg0 *gamelift.GetComputeAccessInput) (*request.Request, *gamelift.GetComputeAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputeAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.GetComputeAccessOutput)
	return ret0, ret1
}

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

// GetComputeAccessWithContext mocks base method.
func (m *MockGameLiftAPI) GetComputeAccessWithContext(arg0 aws.Context, arg1 *gamelift.GetComputeAccessInput, arg2 ...request.Option) (*gamelift.GetComputeAccessOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetComputeAccessWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.GetComputeAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetComputeAuthToken mocks base method.
func (m *MockGameLiftAPI) GetComputeAuthToken(arg0 *gamelift.GetComputeAuthTokenInput) (*gamelift.GetComputeAuthTokenOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputeAuthToken", arg0)
	ret0, _ := ret[0].(*gamelift.GetComputeAuthTokenOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetComputeAuthTokenRequest mocks base method.
func (m *MockGameLiftAPI) GetComputeAuthTokenRequest(arg0 *gamelift.GetComputeAuthTokenInput) (*request.Request, *gamelift.GetComputeAuthTokenOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputeAuthTokenRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.GetComputeAuthTokenOutput)
	return ret0, ret1
}

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

// GetComputeAuthTokenWithContext mocks base method.
func (m *MockGameLiftAPI) GetComputeAuthTokenWithContext(arg0 aws.Context, arg1 *gamelift.GetComputeAuthTokenInput, arg2 ...request.Option) (*gamelift.GetComputeAuthTokenOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetComputeAuthTokenWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.GetComputeAuthTokenOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGameSessionLogUrl mocks base method.
func (m *MockGameLiftAPI) GetGameSessionLogUrl(arg0 *gamelift.GetGameSessionLogUrlInput) (*gamelift.GetGameSessionLogUrlOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGameSessionLogUrl", arg0)
	ret0, _ := ret[0].(*gamelift.GetGameSessionLogUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGameSessionLogUrlRequest mocks base method.
func (m *MockGameLiftAPI) GetGameSessionLogUrlRequest(arg0 *gamelift.GetGameSessionLogUrlInput) (*request.Request, *gamelift.GetGameSessionLogUrlOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGameSessionLogUrlRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.GetGameSessionLogUrlOutput)
	return ret0, ret1
}

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

// GetGameSessionLogUrlWithContext mocks base method.
func (m *MockGameLiftAPI) GetGameSessionLogUrlWithContext(arg0 aws.Context, arg1 *gamelift.GetGameSessionLogUrlInput, arg2 ...request.Option) (*gamelift.GetGameSessionLogUrlOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGameSessionLogUrlWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.GetGameSessionLogUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInstanceAccess mocks base method.
func (m *MockGameLiftAPI) GetInstanceAccess(arg0 *gamelift.GetInstanceAccessInput) (*gamelift.GetInstanceAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceAccess", arg0)
	ret0, _ := ret[0].(*gamelift.GetInstanceAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInstanceAccessRequest mocks base method.
func (m *MockGameLiftAPI) GetInstanceAccessRequest(arg0 *gamelift.GetInstanceAccessInput) (*request.Request, *gamelift.GetInstanceAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.GetInstanceAccessOutput)
	return ret0, ret1
}

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

// GetInstanceAccessWithContext mocks base method.
func (m *MockGameLiftAPI) GetInstanceAccessWithContext(arg0 aws.Context, arg1 *gamelift.GetInstanceAccessInput, arg2 ...request.Option) (*gamelift.GetInstanceAccessOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInstanceAccessWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.GetInstanceAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAliases mocks base method.
func (m *MockGameLiftAPI) ListAliases(arg0 *gamelift.ListAliasesInput) (*gamelift.ListAliasesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliases", arg0)
	ret0, _ := ret[0].(*gamelift.ListAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAliasesPages mocks base method.
func (m *MockGameLiftAPI) ListAliasesPages(arg0 *gamelift.ListAliasesInput, arg1 func(*gamelift.ListAliasesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliasesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAliasesPagesWithContext mocks base method.
func (m *MockGameLiftAPI) ListAliasesPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListAliasesInput, arg2 func(*gamelift.ListAliasesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAliasesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAliasesRequest mocks base method.
func (m *MockGameLiftAPI) ListAliasesRequest(arg0 *gamelift.ListAliasesInput) (*request.Request, *gamelift.ListAliasesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliasesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListAliasesOutput)
	return ret0, ret1
}

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

// ListAliasesWithContext mocks base method.
func (m *MockGameLiftAPI) ListAliasesWithContext(arg0 aws.Context, arg1 *gamelift.ListAliasesInput, arg2 ...request.Option) (*gamelift.ListAliasesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAliasesWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListAliasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBuilds mocks base method.
func (m *MockGameLiftAPI) ListBuilds(arg0 *gamelift.ListBuildsInput) (*gamelift.ListBuildsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBuilds", arg0)
	ret0, _ := ret[0].(*gamelift.ListBuildsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBuildsPages mocks base method.
func (m *MockGameLiftAPI) ListBuildsPages(arg0 *gamelift.ListBuildsInput, arg1 func(*gamelift.ListBuildsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBuildsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListBuildsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) ListBuildsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListBuildsInput, arg2 func(*gamelift.ListBuildsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBuildsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListBuildsRequest mocks base method.
func (m *MockGameLiftAPI) ListBuildsRequest(arg0 *gamelift.ListBuildsInput) (*request.Request, *gamelift.ListBuildsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBuildsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListBuildsOutput)
	return ret0, ret1
}

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

// ListBuildsWithContext mocks base method.
func (m *MockGameLiftAPI) ListBuildsWithContext(arg0 aws.Context, arg1 *gamelift.ListBuildsInput, arg2 ...request.Option) (*gamelift.ListBuildsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBuildsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListBuildsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCompute mocks base method.
func (m *MockGameLiftAPI) ListCompute(arg0 *gamelift.ListComputeInput) (*gamelift.ListComputeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCompute", arg0)
	ret0, _ := ret[0].(*gamelift.ListComputeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListComputePages mocks base method.
func (m *MockGameLiftAPI) ListComputePages(arg0 *gamelift.ListComputeInput, arg1 func(*gamelift.ListComputeOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListComputePages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListComputePagesWithContext mocks base method.
func (m *MockGameLiftAPI) ListComputePagesWithContext(arg0 aws.Context, arg1 *gamelift.ListComputeInput, arg2 func(*gamelift.ListComputeOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListComputePagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListComputeRequest mocks base method.
func (m *MockGameLiftAPI) ListComputeRequest(arg0 *gamelift.ListComputeInput) (*request.Request, *gamelift.ListComputeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListComputeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListComputeOutput)
	return ret0, ret1
}

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

// ListComputeWithContext mocks base method.
func (m *MockGameLiftAPI) ListComputeWithContext(arg0 aws.Context, arg1 *gamelift.ListComputeInput, arg2 ...request.Option) (*gamelift.ListComputeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListComputeWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListComputeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListContainerGroupDefinitions mocks base method.
func (m *MockGameLiftAPI) ListContainerGroupDefinitions(arg0 *gamelift.ListContainerGroupDefinitionsInput) (*gamelift.ListContainerGroupDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContainerGroupDefinitions", arg0)
	ret0, _ := ret[0].(*gamelift.ListContainerGroupDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListContainerGroupDefinitionsPages mocks base method.
func (m *MockGameLiftAPI) ListContainerGroupDefinitionsPages(arg0 *gamelift.ListContainerGroupDefinitionsInput, arg1 func(*gamelift.ListContainerGroupDefinitionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContainerGroupDefinitionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListContainerGroupDefinitionsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) ListContainerGroupDefinitionsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListContainerGroupDefinitionsInput, arg2 func(*gamelift.ListContainerGroupDefinitionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContainerGroupDefinitionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListContainerGroupDefinitionsRequest mocks base method.
func (m *MockGameLiftAPI) ListContainerGroupDefinitionsRequest(arg0 *gamelift.ListContainerGroupDefinitionsInput) (*request.Request, *gamelift.ListContainerGroupDefinitionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContainerGroupDefinitionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListContainerGroupDefinitionsOutput)
	return ret0, ret1
}

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

// ListContainerGroupDefinitionsWithContext mocks base method.
func (m *MockGameLiftAPI) ListContainerGroupDefinitionsWithContext(arg0 aws.Context, arg1 *gamelift.ListContainerGroupDefinitionsInput, arg2 ...request.Option) (*gamelift.ListContainerGroupDefinitionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContainerGroupDefinitionsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListContainerGroupDefinitionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFleets mocks base method.
func (m *MockGameLiftAPI) ListFleets(arg0 *gamelift.ListFleetsInput) (*gamelift.ListFleetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFleets", arg0)
	ret0, _ := ret[0].(*gamelift.ListFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFleetsPages mocks base method.
func (m *MockGameLiftAPI) ListFleetsPages(arg0 *gamelift.ListFleetsInput, arg1 func(*gamelift.ListFleetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFleetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListFleetsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) ListFleetsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListFleetsInput, arg2 func(*gamelift.ListFleetsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFleetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListFleetsRequest mocks base method.
func (m *MockGameLiftAPI) ListFleetsRequest(arg0 *gamelift.ListFleetsInput) (*request.Request, *gamelift.ListFleetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFleetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListFleetsOutput)
	return ret0, ret1
}

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

// ListFleetsWithContext mocks base method.
func (m *MockGameLiftAPI) ListFleetsWithContext(arg0 aws.Context, arg1 *gamelift.ListFleetsInput, arg2 ...request.Option) (*gamelift.ListFleetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFleetsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGameServerGroups mocks base method.
func (m *MockGameLiftAPI) ListGameServerGroups(arg0 *gamelift.ListGameServerGroupsInput) (*gamelift.ListGameServerGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGameServerGroups", arg0)
	ret0, _ := ret[0].(*gamelift.ListGameServerGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGameServerGroupsPages mocks base method.
func (m *MockGameLiftAPI) ListGameServerGroupsPages(arg0 *gamelift.ListGameServerGroupsInput, arg1 func(*gamelift.ListGameServerGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGameServerGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListGameServerGroupsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) ListGameServerGroupsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListGameServerGroupsInput, arg2 func(*gamelift.ListGameServerGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGameServerGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListGameServerGroupsRequest mocks base method.
func (m *MockGameLiftAPI) ListGameServerGroupsRequest(arg0 *gamelift.ListGameServerGroupsInput) (*request.Request, *gamelift.ListGameServerGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGameServerGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListGameServerGroupsOutput)
	return ret0, ret1
}

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

// ListGameServerGroupsWithContext mocks base method.
func (m *MockGameLiftAPI) ListGameServerGroupsWithContext(arg0 aws.Context, arg1 *gamelift.ListGameServerGroupsInput, arg2 ...request.Option) (*gamelift.ListGameServerGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGameServerGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListGameServerGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGameServers mocks base method.
func (m *MockGameLiftAPI) ListGameServers(arg0 *gamelift.ListGameServersInput) (*gamelift.ListGameServersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGameServers", arg0)
	ret0, _ := ret[0].(*gamelift.ListGameServersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGameServersPages mocks base method.
func (m *MockGameLiftAPI) ListGameServersPages(arg0 *gamelift.ListGameServersInput, arg1 func(*gamelift.ListGameServersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGameServersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListGameServersPagesWithContext mocks base method.
func (m *MockGameLiftAPI) ListGameServersPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListGameServersInput, arg2 func(*gamelift.ListGameServersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGameServersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListGameServersRequest mocks base method.
func (m *MockGameLiftAPI) ListGameServersRequest(arg0 *gamelift.ListGameServersInput) (*request.Request, *gamelift.ListGameServersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGameServersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListGameServersOutput)
	return ret0, ret1
}

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

// ListGameServersWithContext mocks base method.
func (m *MockGameLiftAPI) ListGameServersWithContext(arg0 aws.Context, arg1 *gamelift.ListGameServersInput, arg2 ...request.Option) (*gamelift.ListGameServersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGameServersWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListGameServersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListLocations mocks base method.
func (m *MockGameLiftAPI) ListLocations(arg0 *gamelift.ListLocationsInput) (*gamelift.ListLocationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLocations", arg0)
	ret0, _ := ret[0].(*gamelift.ListLocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListLocationsPages mocks base method.
func (m *MockGameLiftAPI) ListLocationsPages(arg0 *gamelift.ListLocationsInput, arg1 func(*gamelift.ListLocationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLocationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListLocationsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) ListLocationsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListLocationsInput, arg2 func(*gamelift.ListLocationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLocationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListLocationsRequest mocks base method.
func (m *MockGameLiftAPI) ListLocationsRequest(arg0 *gamelift.ListLocationsInput) (*request.Request, *gamelift.ListLocationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLocationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListLocationsOutput)
	return ret0, ret1
}

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

// ListLocationsWithContext mocks base method.
func (m *MockGameLiftAPI) ListLocationsWithContext(arg0 aws.Context, arg1 *gamelift.ListLocationsInput, arg2 ...request.Option) (*gamelift.ListLocationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLocationsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListLocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListScripts mocks base method.
func (m *MockGameLiftAPI) ListScripts(arg0 *gamelift.ListScriptsInput) (*gamelift.ListScriptsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListScripts", arg0)
	ret0, _ := ret[0].(*gamelift.ListScriptsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListScriptsPages mocks base method.
func (m *MockGameLiftAPI) ListScriptsPages(arg0 *gamelift.ListScriptsInput, arg1 func(*gamelift.ListScriptsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListScriptsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListScriptsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) ListScriptsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListScriptsInput, arg2 func(*gamelift.ListScriptsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListScriptsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListScriptsRequest mocks base method.
func (m *MockGameLiftAPI) ListScriptsRequest(arg0 *gamelift.ListScriptsInput) (*request.Request, *gamelift.ListScriptsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListScriptsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListScriptsOutput)
	return ret0, ret1
}

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

// ListScriptsWithContext mocks base method.
func (m *MockGameLiftAPI) ListScriptsWithContext(arg0 aws.Context, arg1 *gamelift.ListScriptsInput, arg2 ...request.Option) (*gamelift.ListScriptsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListScriptsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListScriptsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForResource mocks base method.
func (m *MockGameLiftAPI) ListTagsForResource(arg0 *gamelift.ListTagsForResourceInput) (*gamelift.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
	ret0, _ := ret[0].(*gamelift.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForResourceRequest mocks base method.
func (m *MockGameLiftAPI) ListTagsForResourceRequest(arg0 *gamelift.ListTagsForResourceInput) (*request.Request, *gamelift.ListTagsForResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ListTagsForResourceOutput)
	return ret0, ret1
}

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

// ListTagsForResourceWithContext mocks base method.
func (m *MockGameLiftAPI) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *gamelift.ListTagsForResourceInput, arg2 ...request.Option) (*gamelift.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutScalingPolicy mocks base method.
func (m *MockGameLiftAPI) PutScalingPolicy(arg0 *gamelift.PutScalingPolicyInput) (*gamelift.PutScalingPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutScalingPolicy", arg0)
	ret0, _ := ret[0].(*gamelift.PutScalingPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutScalingPolicyRequest mocks base method.
func (m *MockGameLiftAPI) PutScalingPolicyRequest(arg0 *gamelift.PutScalingPolicyInput) (*request.Request, *gamelift.PutScalingPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutScalingPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.PutScalingPolicyOutput)
	return ret0, ret1
}

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

// PutScalingPolicyWithContext mocks base method.
func (m *MockGameLiftAPI) PutScalingPolicyWithContext(arg0 aws.Context, arg1 *gamelift.PutScalingPolicyInput, arg2 ...request.Option) (*gamelift.PutScalingPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutScalingPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.PutScalingPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterCompute mocks base method.
func (m *MockGameLiftAPI) RegisterCompute(arg0 *gamelift.RegisterComputeInput) (*gamelift.RegisterComputeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterCompute", arg0)
	ret0, _ := ret[0].(*gamelift.RegisterComputeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterComputeRequest mocks base method.
func (m *MockGameLiftAPI) RegisterComputeRequest(arg0 *gamelift.RegisterComputeInput) (*request.Request, *gamelift.RegisterComputeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterComputeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.RegisterComputeOutput)
	return ret0, ret1
}

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

// RegisterComputeWithContext mocks base method.
func (m *MockGameLiftAPI) RegisterComputeWithContext(arg0 aws.Context, arg1 *gamelift.RegisterComputeInput, arg2 ...request.Option) (*gamelift.RegisterComputeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterComputeWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.RegisterComputeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterGameServer mocks base method.
func (m *MockGameLiftAPI) RegisterGameServer(arg0 *gamelift.RegisterGameServerInput) (*gamelift.RegisterGameServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterGameServer", arg0)
	ret0, _ := ret[0].(*gamelift.RegisterGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterGameServerRequest mocks base method.
func (m *MockGameLiftAPI) RegisterGameServerRequest(arg0 *gamelift.RegisterGameServerInput) (*request.Request, *gamelift.RegisterGameServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterGameServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.RegisterGameServerOutput)
	return ret0, ret1
}

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

// RegisterGameServerWithContext mocks base method.
func (m *MockGameLiftAPI) RegisterGameServerWithContext(arg0 aws.Context, arg1 *gamelift.RegisterGameServerInput, arg2 ...request.Option) (*gamelift.RegisterGameServerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterGameServerWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.RegisterGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RequestUploadCredentials mocks base method.
func (m *MockGameLiftAPI) RequestUploadCredentials(arg0 *gamelift.RequestUploadCredentialsInput) (*gamelift.RequestUploadCredentialsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestUploadCredentials", arg0)
	ret0, _ := ret[0].(*gamelift.RequestUploadCredentialsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RequestUploadCredentialsRequest mocks base method.
func (m *MockGameLiftAPI) RequestUploadCredentialsRequest(arg0 *gamelift.RequestUploadCredentialsInput) (*request.Request, *gamelift.RequestUploadCredentialsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestUploadCredentialsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.RequestUploadCredentialsOutput)
	return ret0, ret1
}

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

// RequestUploadCredentialsWithContext mocks base method.
func (m *MockGameLiftAPI) RequestUploadCredentialsWithContext(arg0 aws.Context, arg1 *gamelift.RequestUploadCredentialsInput, arg2 ...request.Option) (*gamelift.RequestUploadCredentialsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RequestUploadCredentialsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.RequestUploadCredentialsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResolveAlias mocks base method.
func (m *MockGameLiftAPI) ResolveAlias(arg0 *gamelift.ResolveAliasInput) (*gamelift.ResolveAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveAlias", arg0)
	ret0, _ := ret[0].(*gamelift.ResolveAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResolveAliasRequest mocks base method.
func (m *MockGameLiftAPI) ResolveAliasRequest(arg0 *gamelift.ResolveAliasInput) (*request.Request, *gamelift.ResolveAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ResolveAliasOutput)
	return ret0, ret1
}

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

// ResolveAliasWithContext mocks base method.
func (m *MockGameLiftAPI) ResolveAliasWithContext(arg0 aws.Context, arg1 *gamelift.ResolveAliasInput, arg2 ...request.Option) (*gamelift.ResolveAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResolveAliasWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ResolveAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResumeGameServerGroup mocks base method.
func (m *MockGameLiftAPI) ResumeGameServerGroup(arg0 *gamelift.ResumeGameServerGroupInput) (*gamelift.ResumeGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeGameServerGroup", arg0)
	ret0, _ := ret[0].(*gamelift.ResumeGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResumeGameServerGroupRequest mocks base method.
func (m *MockGameLiftAPI) ResumeGameServerGroupRequest(arg0 *gamelift.ResumeGameServerGroupInput) (*request.Request, *gamelift.ResumeGameServerGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeGameServerGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ResumeGameServerGroupOutput)
	return ret0, ret1
}

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

// ResumeGameServerGroupWithContext mocks base method.
func (m *MockGameLiftAPI) ResumeGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.ResumeGameServerGroupInput, arg2 ...request.Option) (*gamelift.ResumeGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResumeGameServerGroupWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ResumeGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchGameSessions mocks base method.
func (m *MockGameLiftAPI) SearchGameSessions(arg0 *gamelift.SearchGameSessionsInput) (*gamelift.SearchGameSessionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchGameSessions", arg0)
	ret0, _ := ret[0].(*gamelift.SearchGameSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchGameSessionsPages mocks base method.
func (m *MockGameLiftAPI) SearchGameSessionsPages(arg0 *gamelift.SearchGameSessionsInput, arg1 func(*gamelift.SearchGameSessionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchGameSessionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchGameSessionsPagesWithContext mocks base method.
func (m *MockGameLiftAPI) SearchGameSessionsPagesWithContext(arg0 aws.Context, arg1 *gamelift.SearchGameSessionsInput, arg2 func(*gamelift.SearchGameSessionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchGameSessionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchGameSessionsRequest mocks base method.
func (m *MockGameLiftAPI) SearchGameSessionsRequest(arg0 *gamelift.SearchGameSessionsInput) (*request.Request, *gamelift.SearchGameSessionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchGameSessionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.SearchGameSessionsOutput)
	return ret0, ret1
}

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

// SearchGameSessionsWithContext mocks base method.
func (m *MockGameLiftAPI) SearchGameSessionsWithContext(arg0 aws.Context, arg1 *gamelift.SearchGameSessionsInput, arg2 ...request.Option) (*gamelift.SearchGameSessionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchGameSessionsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.SearchGameSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartFleetActions mocks base method.
func (m *MockGameLiftAPI) StartFleetActions(arg0 *gamelift.StartFleetActionsInput) (*gamelift.StartFleetActionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartFleetActions", arg0)
	ret0, _ := ret[0].(*gamelift.StartFleetActionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartFleetActionsRequest mocks base method.
func (m *MockGameLiftAPI) StartFleetActionsRequest(arg0 *gamelift.StartFleetActionsInput) (*request.Request, *gamelift.StartFleetActionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartFleetActionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.StartFleetActionsOutput)
	return ret0, ret1
}

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

// StartFleetActionsWithContext mocks base method.
func (m *MockGameLiftAPI) StartFleetActionsWithContext(arg0 aws.Context, arg1 *gamelift.StartFleetActionsInput, arg2 ...request.Option) (*gamelift.StartFleetActionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartFleetActionsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.StartFleetActionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartGameSessionPlacement mocks base method.
func (m *MockGameLiftAPI) StartGameSessionPlacement(arg0 *gamelift.StartGameSessionPlacementInput) (*gamelift.StartGameSessionPlacementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartGameSessionPlacement", arg0)
	ret0, _ := ret[0].(*gamelift.StartGameSessionPlacementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartGameSessionPlacementRequest mocks base method.
func (m *MockGameLiftAPI) StartGameSessionPlacementRequest(arg0 *gamelift.StartGameSessionPlacementInput) (*request.Request, *gamelift.StartGameSessionPlacementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartGameSessionPlacementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.StartGameSessionPlacementOutput)
	return ret0, ret1
}

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

// StartGameSessionPlacementWithContext mocks base method.
func (m *MockGameLiftAPI) StartGameSessionPlacementWithContext(arg0 aws.Context, arg1 *gamelift.StartGameSessionPlacementInput, arg2 ...request.Option) (*gamelift.StartGameSessionPlacementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartGameSessionPlacementWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.StartGameSessionPlacementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartMatchBackfill mocks base method.
func (m *MockGameLiftAPI) StartMatchBackfill(arg0 *gamelift.StartMatchBackfillInput) (*gamelift.StartMatchBackfillOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartMatchBackfill", arg0)
	ret0, _ := ret[0].(*gamelift.StartMatchBackfillOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartMatchBackfillRequest mocks base method.
func (m *MockGameLiftAPI) StartMatchBackfillRequest(arg0 *gamelift.StartMatchBackfillInput) (*request.Request, *gamelift.StartMatchBackfillOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartMatchBackfillRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.StartMatchBackfillOutput)
	return ret0, ret1
}

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

// StartMatchBackfillWithContext mocks base method.
func (m *MockGameLiftAPI) StartMatchBackfillWithContext(arg0 aws.Context, arg1 *gamelift.StartMatchBackfillInput, arg2 ...request.Option) (*gamelift.StartMatchBackfillOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartMatchBackfillWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.StartMatchBackfillOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartMatchmaking mocks base method.
func (m *MockGameLiftAPI) StartMatchmaking(arg0 *gamelift.StartMatchmakingInput) (*gamelift.StartMatchmakingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartMatchmaking", arg0)
	ret0, _ := ret[0].(*gamelift.StartMatchmakingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartMatchmakingRequest mocks base method.
func (m *MockGameLiftAPI) StartMatchmakingRequest(arg0 *gamelift.StartMatchmakingInput) (*request.Request, *gamelift.StartMatchmakingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartMatchmakingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.StartMatchmakingOutput)
	return ret0, ret1
}

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

// StartMatchmakingWithContext mocks base method.
func (m *MockGameLiftAPI) StartMatchmakingWithContext(arg0 aws.Context, arg1 *gamelift.StartMatchmakingInput, arg2 ...request.Option) (*gamelift.StartMatchmakingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartMatchmakingWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.StartMatchmakingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopFleetActions mocks base method.
func (m *MockGameLiftAPI) StopFleetActions(arg0 *gamelift.StopFleetActionsInput) (*gamelift.StopFleetActionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopFleetActions", arg0)
	ret0, _ := ret[0].(*gamelift.StopFleetActionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopFleetActionsRequest mocks base method.
func (m *MockGameLiftAPI) StopFleetActionsRequest(arg0 *gamelift.StopFleetActionsInput) (*request.Request, *gamelift.StopFleetActionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopFleetActionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.StopFleetActionsOutput)
	return ret0, ret1
}

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

// StopFleetActionsWithContext mocks base method.
func (m *MockGameLiftAPI) StopFleetActionsWithContext(arg0 aws.Context, arg1 *gamelift.StopFleetActionsInput, arg2 ...request.Option) (*gamelift.StopFleetActionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopFleetActionsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.StopFleetActionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopGameSessionPlacement mocks base method.
func (m *MockGameLiftAPI) StopGameSessionPlacement(arg0 *gamelift.StopGameSessionPlacementInput) (*gamelift.StopGameSessionPlacementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopGameSessionPlacement", arg0)
	ret0, _ := ret[0].(*gamelift.StopGameSessionPlacementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopGameSessionPlacementRequest mocks base method.
func (m *MockGameLiftAPI) StopGameSessionPlacementRequest(arg0 *gamelift.StopGameSessionPlacementInput) (*request.Request, *gamelift.StopGameSessionPlacementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopGameSessionPlacementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.StopGameSessionPlacementOutput)
	return ret0, ret1
}

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

// StopGameSessionPlacementWithContext mocks base method.
func (m *MockGameLiftAPI) StopGameSessionPlacementWithContext(arg0 aws.Context, arg1 *gamelift.StopGameSessionPlacementInput, arg2 ...request.Option) (*gamelift.StopGameSessionPlacementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopGameSessionPlacementWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.StopGameSessionPlacementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopMatchmaking mocks base method.
func (m *MockGameLiftAPI) StopMatchmaking(arg0 *gamelift.StopMatchmakingInput) (*gamelift.StopMatchmakingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopMatchmaking", arg0)
	ret0, _ := ret[0].(*gamelift.StopMatchmakingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopMatchmakingRequest mocks base method.
func (m *MockGameLiftAPI) StopMatchmakingRequest(arg0 *gamelift.StopMatchmakingInput) (*request.Request, *gamelift.StopMatchmakingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopMatchmakingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.StopMatchmakingOutput)
	return ret0, ret1
}

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

// StopMatchmakingWithContext mocks base method.
func (m *MockGameLiftAPI) StopMatchmakingWithContext(arg0 aws.Context, arg1 *gamelift.StopMatchmakingInput, arg2 ...request.Option) (*gamelift.StopMatchmakingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopMatchmakingWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.StopMatchmakingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SuspendGameServerGroup mocks base method.
func (m *MockGameLiftAPI) SuspendGameServerGroup(arg0 *gamelift.SuspendGameServerGroupInput) (*gamelift.SuspendGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SuspendGameServerGroup", arg0)
	ret0, _ := ret[0].(*gamelift.SuspendGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SuspendGameServerGroupRequest mocks base method.
func (m *MockGameLiftAPI) SuspendGameServerGroupRequest(arg0 *gamelift.SuspendGameServerGroupInput) (*request.Request, *gamelift.SuspendGameServerGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SuspendGameServerGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.SuspendGameServerGroupOutput)
	return ret0, ret1
}

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

// SuspendGameServerGroupWithContext mocks base method.
func (m *MockGameLiftAPI) SuspendGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.SuspendGameServerGroupInput, arg2 ...request.Option) (*gamelift.SuspendGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SuspendGameServerGroupWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.SuspendGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TagResource mocks base method.
func (m *MockGameLiftAPI) TagResource(arg0 *gamelift.TagResourceInput) (*gamelift.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResource", arg0)
	ret0, _ := ret[0].(*gamelift.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TagResourceRequest mocks base method.
func (m *MockGameLiftAPI) TagResourceRequest(arg0 *gamelift.TagResourceInput) (*request.Request, *gamelift.TagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.TagResourceOutput)
	return ret0, ret1
}

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

// TagResourceWithContext mocks base method.
func (m *MockGameLiftAPI) TagResourceWithContext(arg0 aws.Context, arg1 *gamelift.TagResourceInput, arg2 ...request.Option) (*gamelift.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UntagResource mocks base method.
func (m *MockGameLiftAPI) UntagResource(arg0 *gamelift.UntagResourceInput) (*gamelift.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResource", arg0)
	ret0, _ := ret[0].(*gamelift.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UntagResourceRequest mocks base method.
func (m *MockGameLiftAPI) UntagResourceRequest(arg0 *gamelift.UntagResourceInput) (*request.Request, *gamelift.UntagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UntagResourceOutput)
	return ret0, ret1
}

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

// UntagResourceWithContext mocks base method.
func (m *MockGameLiftAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *gamelift.UntagResourceInput, arg2 ...request.Option) (*gamelift.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAlias mocks base method.
func (m *MockGameLiftAPI) UpdateAlias(arg0 *gamelift.UpdateAliasInput) (*gamelift.UpdateAliasOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAlias", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAliasRequest mocks base method.
func (m *MockGameLiftAPI) UpdateAliasRequest(arg0 *gamelift.UpdateAliasInput) (*request.Request, *gamelift.UpdateAliasOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAliasRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateAliasOutput)
	return ret0, ret1
}

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

// UpdateAliasWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateAliasWithContext(arg0 aws.Context, arg1 *gamelift.UpdateAliasInput, arg2 ...request.Option) (*gamelift.UpdateAliasOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAliasWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateAliasOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateBuild mocks base method.
func (m *MockGameLiftAPI) UpdateBuild(arg0 *gamelift.UpdateBuildInput) (*gamelift.UpdateBuildOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBuild", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateBuildOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateBuildRequest mocks base method.
func (m *MockGameLiftAPI) UpdateBuildRequest(arg0 *gamelift.UpdateBuildInput) (*request.Request, *gamelift.UpdateBuildOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBuildRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateBuildOutput)
	return ret0, ret1
}

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

// UpdateBuildWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateBuildWithContext(arg0 aws.Context, arg1 *gamelift.UpdateBuildInput, arg2 ...request.Option) (*gamelift.UpdateBuildOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateBuildWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateBuildOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFleetAttributes mocks base method.
func (m *MockGameLiftAPI) UpdateFleetAttributes(arg0 *gamelift.UpdateFleetAttributesInput) (*gamelift.UpdateFleetAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFleetAttributes", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateFleetAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFleetAttributesRequest mocks base method.
func (m *MockGameLiftAPI) UpdateFleetAttributesRequest(arg0 *gamelift.UpdateFleetAttributesInput) (*request.Request, *gamelift.UpdateFleetAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFleetAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateFleetAttributesOutput)
	return ret0, ret1
}

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

// UpdateFleetAttributesWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateFleetAttributesWithContext(arg0 aws.Context, arg1 *gamelift.UpdateFleetAttributesInput, arg2 ...request.Option) (*gamelift.UpdateFleetAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateFleetAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateFleetAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFleetCapacity mocks base method.
func (m *MockGameLiftAPI) UpdateFleetCapacity(arg0 *gamelift.UpdateFleetCapacityInput) (*gamelift.UpdateFleetCapacityOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFleetCapacity", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateFleetCapacityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFleetCapacityRequest mocks base method.
func (m *MockGameLiftAPI) UpdateFleetCapacityRequest(arg0 *gamelift.UpdateFleetCapacityInput) (*request.Request, *gamelift.UpdateFleetCapacityOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFleetCapacityRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateFleetCapacityOutput)
	return ret0, ret1
}

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

// UpdateFleetCapacityWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateFleetCapacityWithContext(arg0 aws.Context, arg1 *gamelift.UpdateFleetCapacityInput, arg2 ...request.Option) (*gamelift.UpdateFleetCapacityOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateFleetCapacityWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateFleetCapacityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFleetPortSettings mocks base method.
func (m *MockGameLiftAPI) UpdateFleetPortSettings(arg0 *gamelift.UpdateFleetPortSettingsInput) (*gamelift.UpdateFleetPortSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFleetPortSettings", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateFleetPortSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFleetPortSettingsRequest mocks base method.
func (m *MockGameLiftAPI) UpdateFleetPortSettingsRequest(arg0 *gamelift.UpdateFleetPortSettingsInput) (*request.Request, *gamelift.UpdateFleetPortSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFleetPortSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateFleetPortSettingsOutput)
	return ret0, ret1
}

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

// UpdateFleetPortSettingsWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateFleetPortSettingsWithContext(arg0 aws.Context, arg1 *gamelift.UpdateFleetPortSettingsInput, arg2 ...request.Option) (*gamelift.UpdateFleetPortSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateFleetPortSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateFleetPortSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGameServer mocks base method.
func (m *MockGameLiftAPI) UpdateGameServer(arg0 *gamelift.UpdateGameServerInput) (*gamelift.UpdateGameServerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGameServer", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGameServerGroup mocks base method.
func (m *MockGameLiftAPI) UpdateGameServerGroup(arg0 *gamelift.UpdateGameServerGroupInput) (*gamelift.UpdateGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGameServerGroup", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGameServerGroupRequest mocks base method.
func (m *MockGameLiftAPI) UpdateGameServerGroupRequest(arg0 *gamelift.UpdateGameServerGroupInput) (*request.Request, *gamelift.UpdateGameServerGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGameServerGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateGameServerGroupOutput)
	return ret0, ret1
}

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

// UpdateGameServerGroupWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.UpdateGameServerGroupInput, arg2 ...request.Option) (*gamelift.UpdateGameServerGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateGameServerGroupWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateGameServerGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGameServerRequest mocks base method.
func (m *MockGameLiftAPI) UpdateGameServerRequest(arg0 *gamelift.UpdateGameServerInput) (*request.Request, *gamelift.UpdateGameServerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGameServerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateGameServerOutput)
	return ret0, ret1
}

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

// UpdateGameServerWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateGameServerWithContext(arg0 aws.Context, arg1 *gamelift.UpdateGameServerInput, arg2 ...request.Option) (*gamelift.UpdateGameServerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateGameServerWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateGameServerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGameSession mocks base method.
func (m *MockGameLiftAPI) UpdateGameSession(arg0 *gamelift.UpdateGameSessionInput) (*gamelift.UpdateGameSessionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGameSession", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateGameSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGameSessionQueue mocks base method.
func (m *MockGameLiftAPI) UpdateGameSessionQueue(arg0 *gamelift.UpdateGameSessionQueueInput) (*gamelift.UpdateGameSessionQueueOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGameSessionQueue", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateGameSessionQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGameSessionQueueRequest mocks base method.
func (m *MockGameLiftAPI) UpdateGameSessionQueueRequest(arg0 *gamelift.UpdateGameSessionQueueInput) (*request.Request, *gamelift.UpdateGameSessionQueueOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGameSessionQueueRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateGameSessionQueueOutput)
	return ret0, ret1
}

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

// UpdateGameSessionQueueWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateGameSessionQueueWithContext(arg0 aws.Context, arg1 *gamelift.UpdateGameSessionQueueInput, arg2 ...request.Option) (*gamelift.UpdateGameSessionQueueOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateGameSessionQueueWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateGameSessionQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGameSessionRequest mocks base method.
func (m *MockGameLiftAPI) UpdateGameSessionRequest(arg0 *gamelift.UpdateGameSessionInput) (*request.Request, *gamelift.UpdateGameSessionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGameSessionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateGameSessionOutput)
	return ret0, ret1
}

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

// UpdateGameSessionWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateGameSessionWithContext(arg0 aws.Context, arg1 *gamelift.UpdateGameSessionInput, arg2 ...request.Option) (*gamelift.UpdateGameSessionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateGameSessionWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateGameSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateMatchmakingConfiguration mocks base method.
func (m *MockGameLiftAPI) UpdateMatchmakingConfiguration(arg0 *gamelift.UpdateMatchmakingConfigurationInput) (*gamelift.UpdateMatchmakingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMatchmakingConfiguration", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateMatchmakingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateMatchmakingConfigurationRequest mocks base method.
func (m *MockGameLiftAPI) UpdateMatchmakingConfigurationRequest(arg0 *gamelift.UpdateMatchmakingConfigurationInput) (*request.Request, *gamelift.UpdateMatchmakingConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMatchmakingConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateMatchmakingConfigurationOutput)
	return ret0, ret1
}

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

// UpdateMatchmakingConfigurationWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateMatchmakingConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.UpdateMatchmakingConfigurationInput, arg2 ...request.Option) (*gamelift.UpdateMatchmakingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateMatchmakingConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateMatchmakingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateRuntimeConfiguration mocks base method.
func (m *MockGameLiftAPI) UpdateRuntimeConfiguration(arg0 *gamelift.UpdateRuntimeConfigurationInput) (*gamelift.UpdateRuntimeConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRuntimeConfiguration", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateRuntimeConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateRuntimeConfigurationRequest mocks base method.
func (m *MockGameLiftAPI) UpdateRuntimeConfigurationRequest(arg0 *gamelift.UpdateRuntimeConfigurationInput) (*request.Request, *gamelift.UpdateRuntimeConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRuntimeConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateRuntimeConfigurationOutput)
	return ret0, ret1
}

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

// UpdateRuntimeConfigurationWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateRuntimeConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.UpdateRuntimeConfigurationInput, arg2 ...request.Option) (*gamelift.UpdateRuntimeConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRuntimeConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateRuntimeConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateScript mocks base method.
func (m *MockGameLiftAPI) UpdateScript(arg0 *gamelift.UpdateScriptInput) (*gamelift.UpdateScriptOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateScript", arg0)
	ret0, _ := ret[0].(*gamelift.UpdateScriptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateScriptRequest mocks base method.
func (m *MockGameLiftAPI) UpdateScriptRequest(arg0 *gamelift.UpdateScriptInput) (*request.Request, *gamelift.UpdateScriptOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateScriptRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.UpdateScriptOutput)
	return ret0, ret1
}

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

// UpdateScriptWithContext mocks base method.
func (m *MockGameLiftAPI) UpdateScriptWithContext(arg0 aws.Context, arg1 *gamelift.UpdateScriptInput, arg2 ...request.Option) (*gamelift.UpdateScriptOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateScriptWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.UpdateScriptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ValidateMatchmakingRuleSet mocks base method.
func (m *MockGameLiftAPI) ValidateMatchmakingRuleSet(arg0 *gamelift.ValidateMatchmakingRuleSetInput) (*gamelift.ValidateMatchmakingRuleSetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateMatchmakingRuleSet", arg0)
	ret0, _ := ret[0].(*gamelift.ValidateMatchmakingRuleSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ValidateMatchmakingRuleSetRequest mocks base method.
func (m *MockGameLiftAPI) ValidateMatchmakingRuleSetRequest(arg0 *gamelift.ValidateMatchmakingRuleSetInput) (*request.Request, *gamelift.ValidateMatchmakingRuleSetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateMatchmakingRuleSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*gamelift.ValidateMatchmakingRuleSetOutput)
	return ret0, ret1
}

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

// ValidateMatchmakingRuleSetWithContext mocks base method.
func (m *MockGameLiftAPI) ValidateMatchmakingRuleSetWithContext(arg0 aws.Context, arg1 *gamelift.ValidateMatchmakingRuleSetInput, arg2 ...request.Option) (*gamelift.ValidateMatchmakingRuleSetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValidateMatchmakingRuleSetWithContext", varargs...)
	ret0, _ := ret[0].(*gamelift.ValidateMatchmakingRuleSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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