mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/workspacesweb/workspaceswebiface (interfaces: WorkSpacesWebAPI)

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

import (
	context "context"
	reflect "reflect"

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

// MockWorkSpacesWebAPI is a mock of WorkSpacesWebAPI interface.
type MockWorkSpacesWebAPI struct {
	ctrl     *gomock.Controller
	recorder *MockWorkSpacesWebAPIMockRecorder
}

// MockWorkSpacesWebAPIMockRecorder is the mock recorder for MockWorkSpacesWebAPI.
type MockWorkSpacesWebAPIMockRecorder struct {
	mock *MockWorkSpacesWebAPI
}

// NewMockWorkSpacesWebAPI creates a new mock instance.
func NewMockWorkSpacesWebAPI(ctrl *gomock.Controller) *MockWorkSpacesWebAPI {
	mock := &MockWorkSpacesWebAPI{ctrl: ctrl}
	mock.recorder = &MockWorkSpacesWebAPIMockRecorder{mock}
	return mock
}

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

// AssociateBrowserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateBrowserSettings(arg0 *workspacesweb.AssociateBrowserSettingsInput) (*workspacesweb.AssociateBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateBrowserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.AssociateBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateBrowserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateBrowserSettingsRequest(arg0 *workspacesweb.AssociateBrowserSettingsInput) (*request.Request, *workspacesweb.AssociateBrowserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateBrowserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.AssociateBrowserSettingsOutput)
	return ret0, ret1
}

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

// AssociateBrowserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateBrowserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.AssociateBrowserSettingsInput, arg2 ...request.Option) (*workspacesweb.AssociateBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateBrowserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.AssociateBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateBrowserSettingsWithContext indicates an expected call of AssociateBrowserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) AssociateBrowserSettingsWithContext(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, "AssociateBrowserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).AssociateBrowserSettingsWithContext), varargs...)
}

// AssociateNetworkSettings mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateNetworkSettings(arg0 *workspacesweb.AssociateNetworkSettingsInput) (*workspacesweb.AssociateNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateNetworkSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.AssociateNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateNetworkSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateNetworkSettingsRequest(arg0 *workspacesweb.AssociateNetworkSettingsInput) (*request.Request, *workspacesweb.AssociateNetworkSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateNetworkSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.AssociateNetworkSettingsOutput)
	return ret0, ret1
}

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

// AssociateNetworkSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateNetworkSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.AssociateNetworkSettingsInput, arg2 ...request.Option) (*workspacesweb.AssociateNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateNetworkSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.AssociateNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateNetworkSettingsWithContext indicates an expected call of AssociateNetworkSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) AssociateNetworkSettingsWithContext(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, "AssociateNetworkSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).AssociateNetworkSettingsWithContext), varargs...)
}

// AssociateTrustStore mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateTrustStore(arg0 *workspacesweb.AssociateTrustStoreInput) (*workspacesweb.AssociateTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTrustStore", arg0)
	ret0, _ := ret[0].(*workspacesweb.AssociateTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateTrustStoreRequest mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateTrustStoreRequest(arg0 *workspacesweb.AssociateTrustStoreInput) (*request.Request, *workspacesweb.AssociateTrustStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTrustStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.AssociateTrustStoreOutput)
	return ret0, ret1
}

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

// AssociateTrustStoreWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateTrustStoreWithContext(arg0 context.Context, arg1 *workspacesweb.AssociateTrustStoreInput, arg2 ...request.Option) (*workspacesweb.AssociateTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateTrustStoreWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.AssociateTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateTrustStoreWithContext indicates an expected call of AssociateTrustStoreWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) AssociateTrustStoreWithContext(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, "AssociateTrustStoreWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).AssociateTrustStoreWithContext), varargs...)
}

// AssociateUserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateUserSettings(arg0 *workspacesweb.AssociateUserSettingsInput) (*workspacesweb.AssociateUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateUserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.AssociateUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateUserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateUserSettingsRequest(arg0 *workspacesweb.AssociateUserSettingsInput) (*request.Request, *workspacesweb.AssociateUserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateUserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.AssociateUserSettingsOutput)
	return ret0, ret1
}

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

// AssociateUserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) AssociateUserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.AssociateUserSettingsInput, arg2 ...request.Option) (*workspacesweb.AssociateUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateUserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.AssociateUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateUserSettingsWithContext indicates an expected call of AssociateUserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) AssociateUserSettingsWithContext(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, "AssociateUserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).AssociateUserSettingsWithContext), varargs...)
}

// CreateBrowserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) CreateBrowserSettings(arg0 *workspacesweb.CreateBrowserSettingsInput) (*workspacesweb.CreateBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBrowserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.CreateBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateBrowserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) CreateBrowserSettingsRequest(arg0 *workspacesweb.CreateBrowserSettingsInput) (*request.Request, *workspacesweb.CreateBrowserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBrowserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.CreateBrowserSettingsOutput)
	return ret0, ret1
}

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

// CreateBrowserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) CreateBrowserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.CreateBrowserSettingsInput, arg2 ...request.Option) (*workspacesweb.CreateBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateBrowserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.CreateBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBrowserSettingsWithContext indicates an expected call of CreateBrowserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) CreateBrowserSettingsWithContext(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, "CreateBrowserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).CreateBrowserSettingsWithContext), varargs...)
}

// CreateIdentityProvider mocks base method.
func (m *MockWorkSpacesWebAPI) CreateIdentityProvider(arg0 *workspacesweb.CreateIdentityProviderInput) (*workspacesweb.CreateIdentityProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIdentityProvider", arg0)
	ret0, _ := ret[0].(*workspacesweb.CreateIdentityProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIdentityProviderRequest mocks base method.
func (m *MockWorkSpacesWebAPI) CreateIdentityProviderRequest(arg0 *workspacesweb.CreateIdentityProviderInput) (*request.Request, *workspacesweb.CreateIdentityProviderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIdentityProviderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.CreateIdentityProviderOutput)
	return ret0, ret1
}

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

// CreateIdentityProviderWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) CreateIdentityProviderWithContext(arg0 context.Context, arg1 *workspacesweb.CreateIdentityProviderInput, arg2 ...request.Option) (*workspacesweb.CreateIdentityProviderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateIdentityProviderWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.CreateIdentityProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIdentityProviderWithContext indicates an expected call of CreateIdentityProviderWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) CreateIdentityProviderWithContext(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, "CreateIdentityProviderWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).CreateIdentityProviderWithContext), varargs...)
}

// CreateNetworkSettings mocks base method.
func (m *MockWorkSpacesWebAPI) CreateNetworkSettings(arg0 *workspacesweb.CreateNetworkSettingsInput) (*workspacesweb.CreateNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.CreateNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNetworkSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) CreateNetworkSettingsRequest(arg0 *workspacesweb.CreateNetworkSettingsInput) (*request.Request, *workspacesweb.CreateNetworkSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.CreateNetworkSettingsOutput)
	return ret0, ret1
}

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

// CreateNetworkSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) CreateNetworkSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.CreateNetworkSettingsInput, arg2 ...request.Option) (*workspacesweb.CreateNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNetworkSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.CreateNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNetworkSettingsWithContext indicates an expected call of CreateNetworkSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) CreateNetworkSettingsWithContext(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, "CreateNetworkSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).CreateNetworkSettingsWithContext), varargs...)
}

// CreatePortal mocks base method.
func (m *MockWorkSpacesWebAPI) CreatePortal(arg0 *workspacesweb.CreatePortalInput) (*workspacesweb.CreatePortalOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePortal", arg0)
	ret0, _ := ret[0].(*workspacesweb.CreatePortalOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePortalRequest mocks base method.
func (m *MockWorkSpacesWebAPI) CreatePortalRequest(arg0 *workspacesweb.CreatePortalInput) (*request.Request, *workspacesweb.CreatePortalOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePortalRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.CreatePortalOutput)
	return ret0, ret1
}

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

// CreatePortalWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) CreatePortalWithContext(arg0 context.Context, arg1 *workspacesweb.CreatePortalInput, arg2 ...request.Option) (*workspacesweb.CreatePortalOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePortalWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.CreatePortalOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePortalWithContext indicates an expected call of CreatePortalWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) CreatePortalWithContext(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, "CreatePortalWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).CreatePortalWithContext), varargs...)
}

// CreateTrustStore mocks base method.
func (m *MockWorkSpacesWebAPI) CreateTrustStore(arg0 *workspacesweb.CreateTrustStoreInput) (*workspacesweb.CreateTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrustStore", arg0)
	ret0, _ := ret[0].(*workspacesweb.CreateTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTrustStoreRequest mocks base method.
func (m *MockWorkSpacesWebAPI) CreateTrustStoreRequest(arg0 *workspacesweb.CreateTrustStoreInput) (*request.Request, *workspacesweb.CreateTrustStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrustStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.CreateTrustStoreOutput)
	return ret0, ret1
}

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

// CreateTrustStoreWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) CreateTrustStoreWithContext(arg0 context.Context, arg1 *workspacesweb.CreateTrustStoreInput, arg2 ...request.Option) (*workspacesweb.CreateTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTrustStoreWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.CreateTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrustStoreWithContext indicates an expected call of CreateTrustStoreWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) CreateTrustStoreWithContext(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, "CreateTrustStoreWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).CreateTrustStoreWithContext), varargs...)
}

// CreateUserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) CreateUserSettings(arg0 *workspacesweb.CreateUserSettingsInput) (*workspacesweb.CreateUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.CreateUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateUserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) CreateUserSettingsRequest(arg0 *workspacesweb.CreateUserSettingsInput) (*request.Request, *workspacesweb.CreateUserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.CreateUserSettingsOutput)
	return ret0, ret1
}

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

// CreateUserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) CreateUserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.CreateUserSettingsInput, arg2 ...request.Option) (*workspacesweb.CreateUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateUserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.CreateUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateUserSettingsWithContext indicates an expected call of CreateUserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) CreateUserSettingsWithContext(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, "CreateUserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).CreateUserSettingsWithContext), varargs...)
}

// DeleteBrowserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteBrowserSettings(arg0 *workspacesweb.DeleteBrowserSettingsInput) (*workspacesweb.DeleteBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBrowserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.DeleteBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteBrowserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteBrowserSettingsRequest(arg0 *workspacesweb.DeleteBrowserSettingsInput) (*request.Request, *workspacesweb.DeleteBrowserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBrowserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DeleteBrowserSettingsOutput)
	return ret0, ret1
}

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

// DeleteBrowserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteBrowserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.DeleteBrowserSettingsInput, arg2 ...request.Option) (*workspacesweb.DeleteBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBrowserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DeleteBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBrowserSettingsWithContext indicates an expected call of DeleteBrowserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DeleteBrowserSettingsWithContext(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, "DeleteBrowserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DeleteBrowserSettingsWithContext), varargs...)
}

// DeleteIdentityProvider mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteIdentityProvider(arg0 *workspacesweb.DeleteIdentityProviderInput) (*workspacesweb.DeleteIdentityProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIdentityProvider", arg0)
	ret0, _ := ret[0].(*workspacesweb.DeleteIdentityProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIdentityProviderRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteIdentityProviderRequest(arg0 *workspacesweb.DeleteIdentityProviderInput) (*request.Request, *workspacesweb.DeleteIdentityProviderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIdentityProviderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DeleteIdentityProviderOutput)
	return ret0, ret1
}

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

// DeleteIdentityProviderWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteIdentityProviderWithContext(arg0 context.Context, arg1 *workspacesweb.DeleteIdentityProviderInput, arg2 ...request.Option) (*workspacesweb.DeleteIdentityProviderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteIdentityProviderWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DeleteIdentityProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteIdentityProviderWithContext indicates an expected call of DeleteIdentityProviderWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DeleteIdentityProviderWithContext(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, "DeleteIdentityProviderWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DeleteIdentityProviderWithContext), varargs...)
}

// DeleteNetworkSettings mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteNetworkSettings(arg0 *workspacesweb.DeleteNetworkSettingsInput) (*workspacesweb.DeleteNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.DeleteNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteNetworkSettingsRequest(arg0 *workspacesweb.DeleteNetworkSettingsInput) (*request.Request, *workspacesweb.DeleteNetworkSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DeleteNetworkSettingsOutput)
	return ret0, ret1
}

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

// DeleteNetworkSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteNetworkSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.DeleteNetworkSettingsInput, arg2 ...request.Option) (*workspacesweb.DeleteNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNetworkSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DeleteNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetworkSettingsWithContext indicates an expected call of DeleteNetworkSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DeleteNetworkSettingsWithContext(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, "DeleteNetworkSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DeleteNetworkSettingsWithContext), varargs...)
}

// DeletePortal mocks base method.
func (m *MockWorkSpacesWebAPI) DeletePortal(arg0 *workspacesweb.DeletePortalInput) (*workspacesweb.DeletePortalOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePortal", arg0)
	ret0, _ := ret[0].(*workspacesweb.DeletePortalOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePortalRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DeletePortalRequest(arg0 *workspacesweb.DeletePortalInput) (*request.Request, *workspacesweb.DeletePortalOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePortalRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DeletePortalOutput)
	return ret0, ret1
}

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

// DeletePortalWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DeletePortalWithContext(arg0 context.Context, arg1 *workspacesweb.DeletePortalInput, arg2 ...request.Option) (*workspacesweb.DeletePortalOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePortalWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DeletePortalOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePortalWithContext indicates an expected call of DeletePortalWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DeletePortalWithContext(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, "DeletePortalWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DeletePortalWithContext), varargs...)
}

// DeleteTrustStore mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteTrustStore(arg0 *workspacesweb.DeleteTrustStoreInput) (*workspacesweb.DeleteTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrustStore", arg0)
	ret0, _ := ret[0].(*workspacesweb.DeleteTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTrustStoreRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteTrustStoreRequest(arg0 *workspacesweb.DeleteTrustStoreInput) (*request.Request, *workspacesweb.DeleteTrustStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrustStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DeleteTrustStoreOutput)
	return ret0, ret1
}

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

// DeleteTrustStoreWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteTrustStoreWithContext(arg0 context.Context, arg1 *workspacesweb.DeleteTrustStoreInput, arg2 ...request.Option) (*workspacesweb.DeleteTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTrustStoreWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DeleteTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTrustStoreWithContext indicates an expected call of DeleteTrustStoreWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DeleteTrustStoreWithContext(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, "DeleteTrustStoreWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DeleteTrustStoreWithContext), varargs...)
}

// DeleteUserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteUserSettings(arg0 *workspacesweb.DeleteUserSettingsInput) (*workspacesweb.DeleteUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.DeleteUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteUserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteUserSettingsRequest(arg0 *workspacesweb.DeleteUserSettingsInput) (*request.Request, *workspacesweb.DeleteUserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DeleteUserSettingsOutput)
	return ret0, ret1
}

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

// DeleteUserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DeleteUserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.DeleteUserSettingsInput, arg2 ...request.Option) (*workspacesweb.DeleteUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteUserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DeleteUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteUserSettingsWithContext indicates an expected call of DeleteUserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DeleteUserSettingsWithContext(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, "DeleteUserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DeleteUserSettingsWithContext), varargs...)
}

// DisassociateBrowserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateBrowserSettings(arg0 *workspacesweb.DisassociateBrowserSettingsInput) (*workspacesweb.DisassociateBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateBrowserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.DisassociateBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateBrowserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateBrowserSettingsRequest(arg0 *workspacesweb.DisassociateBrowserSettingsInput) (*request.Request, *workspacesweb.DisassociateBrowserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateBrowserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DisassociateBrowserSettingsOutput)
	return ret0, ret1
}

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

// DisassociateBrowserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateBrowserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.DisassociateBrowserSettingsInput, arg2 ...request.Option) (*workspacesweb.DisassociateBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateBrowserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DisassociateBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateBrowserSettingsWithContext indicates an expected call of DisassociateBrowserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DisassociateBrowserSettingsWithContext(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, "DisassociateBrowserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DisassociateBrowserSettingsWithContext), varargs...)
}

// DisassociateNetworkSettings mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateNetworkSettings(arg0 *workspacesweb.DisassociateNetworkSettingsInput) (*workspacesweb.DisassociateNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateNetworkSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.DisassociateNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateNetworkSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateNetworkSettingsRequest(arg0 *workspacesweb.DisassociateNetworkSettingsInput) (*request.Request, *workspacesweb.DisassociateNetworkSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateNetworkSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DisassociateNetworkSettingsOutput)
	return ret0, ret1
}

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

// DisassociateNetworkSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateNetworkSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.DisassociateNetworkSettingsInput, arg2 ...request.Option) (*workspacesweb.DisassociateNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateNetworkSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DisassociateNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateNetworkSettingsWithContext indicates an expected call of DisassociateNetworkSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DisassociateNetworkSettingsWithContext(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, "DisassociateNetworkSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DisassociateNetworkSettingsWithContext), varargs...)
}

// DisassociateTrustStore mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateTrustStore(arg0 *workspacesweb.DisassociateTrustStoreInput) (*workspacesweb.DisassociateTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTrustStore", arg0)
	ret0, _ := ret[0].(*workspacesweb.DisassociateTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateTrustStoreRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateTrustStoreRequest(arg0 *workspacesweb.DisassociateTrustStoreInput) (*request.Request, *workspacesweb.DisassociateTrustStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTrustStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DisassociateTrustStoreOutput)
	return ret0, ret1
}

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

// DisassociateTrustStoreWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateTrustStoreWithContext(arg0 context.Context, arg1 *workspacesweb.DisassociateTrustStoreInput, arg2 ...request.Option) (*workspacesweb.DisassociateTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateTrustStoreWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DisassociateTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateTrustStoreWithContext indicates an expected call of DisassociateTrustStoreWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DisassociateTrustStoreWithContext(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, "DisassociateTrustStoreWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DisassociateTrustStoreWithContext), varargs...)
}

// DisassociateUserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateUserSettings(arg0 *workspacesweb.DisassociateUserSettingsInput) (*workspacesweb.DisassociateUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateUserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.DisassociateUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateUserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateUserSettingsRequest(arg0 *workspacesweb.DisassociateUserSettingsInput) (*request.Request, *workspacesweb.DisassociateUserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateUserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.DisassociateUserSettingsOutput)
	return ret0, ret1
}

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

// DisassociateUserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) DisassociateUserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.DisassociateUserSettingsInput, arg2 ...request.Option) (*workspacesweb.DisassociateUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateUserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.DisassociateUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateUserSettingsWithContext indicates an expected call of DisassociateUserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) DisassociateUserSettingsWithContext(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, "DisassociateUserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).DisassociateUserSettingsWithContext), varargs...)
}

// GetBrowserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) GetBrowserSettings(arg0 *workspacesweb.GetBrowserSettingsInput) (*workspacesweb.GetBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBrowserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.GetBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBrowserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) GetBrowserSettingsRequest(arg0 *workspacesweb.GetBrowserSettingsInput) (*request.Request, *workspacesweb.GetBrowserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBrowserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.GetBrowserSettingsOutput)
	return ret0, ret1
}

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

// GetBrowserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) GetBrowserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.GetBrowserSettingsInput, arg2 ...request.Option) (*workspacesweb.GetBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBrowserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.GetBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBrowserSettingsWithContext indicates an expected call of GetBrowserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) GetBrowserSettingsWithContext(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, "GetBrowserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).GetBrowserSettingsWithContext), varargs...)
}

// GetIdentityProvider mocks base method.
func (m *MockWorkSpacesWebAPI) GetIdentityProvider(arg0 *workspacesweb.GetIdentityProviderInput) (*workspacesweb.GetIdentityProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIdentityProvider", arg0)
	ret0, _ := ret[0].(*workspacesweb.GetIdentityProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetIdentityProviderRequest mocks base method.
func (m *MockWorkSpacesWebAPI) GetIdentityProviderRequest(arg0 *workspacesweb.GetIdentityProviderInput) (*request.Request, *workspacesweb.GetIdentityProviderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIdentityProviderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.GetIdentityProviderOutput)
	return ret0, ret1
}

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

// GetIdentityProviderWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) GetIdentityProviderWithContext(arg0 context.Context, arg1 *workspacesweb.GetIdentityProviderInput, arg2 ...request.Option) (*workspacesweb.GetIdentityProviderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIdentityProviderWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.GetIdentityProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIdentityProviderWithContext indicates an expected call of GetIdentityProviderWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) GetIdentityProviderWithContext(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, "GetIdentityProviderWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).GetIdentityProviderWithContext), varargs...)
}

// GetNetworkSettings mocks base method.
func (m *MockWorkSpacesWebAPI) GetNetworkSettings(arg0 *workspacesweb.GetNetworkSettingsInput) (*workspacesweb.GetNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.GetNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) GetNetworkSettingsRequest(arg0 *workspacesweb.GetNetworkSettingsInput) (*request.Request, *workspacesweb.GetNetworkSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.GetNetworkSettingsOutput)
	return ret0, ret1
}

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

// GetNetworkSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) GetNetworkSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.GetNetworkSettingsInput, arg2 ...request.Option) (*workspacesweb.GetNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.GetNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetworkSettingsWithContext indicates an expected call of GetNetworkSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) GetNetworkSettingsWithContext(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, "GetNetworkSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).GetNetworkSettingsWithContext), varargs...)
}

// GetPortal mocks base method.
func (m *MockWorkSpacesWebAPI) GetPortal(arg0 *workspacesweb.GetPortalInput) (*workspacesweb.GetPortalOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPortal", arg0)
	ret0, _ := ret[0].(*workspacesweb.GetPortalOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPortalRequest mocks base method.
func (m *MockWorkSpacesWebAPI) GetPortalRequest(arg0 *workspacesweb.GetPortalInput) (*request.Request, *workspacesweb.GetPortalOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPortalRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.GetPortalOutput)
	return ret0, ret1
}

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

// GetPortalServiceProviderMetadata mocks base method.
func (m *MockWorkSpacesWebAPI) GetPortalServiceProviderMetadata(arg0 *workspacesweb.GetPortalServiceProviderMetadataInput) (*workspacesweb.GetPortalServiceProviderMetadataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPortalServiceProviderMetadata", arg0)
	ret0, _ := ret[0].(*workspacesweb.GetPortalServiceProviderMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPortalServiceProviderMetadataRequest mocks base method.
func (m *MockWorkSpacesWebAPI) GetPortalServiceProviderMetadataRequest(arg0 *workspacesweb.GetPortalServiceProviderMetadataInput) (*request.Request, *workspacesweb.GetPortalServiceProviderMetadataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPortalServiceProviderMetadataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.GetPortalServiceProviderMetadataOutput)
	return ret0, ret1
}

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

// GetPortalServiceProviderMetadataWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) GetPortalServiceProviderMetadataWithContext(arg0 context.Context, arg1 *workspacesweb.GetPortalServiceProviderMetadataInput, arg2 ...request.Option) (*workspacesweb.GetPortalServiceProviderMetadataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPortalServiceProviderMetadataWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.GetPortalServiceProviderMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPortalServiceProviderMetadataWithContext indicates an expected call of GetPortalServiceProviderMetadataWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) GetPortalServiceProviderMetadataWithContext(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, "GetPortalServiceProviderMetadataWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).GetPortalServiceProviderMetadataWithContext), varargs...)
}

// GetPortalWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) GetPortalWithContext(arg0 context.Context, arg1 *workspacesweb.GetPortalInput, arg2 ...request.Option) (*workspacesweb.GetPortalOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPortalWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.GetPortalOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPortalWithContext indicates an expected call of GetPortalWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) GetPortalWithContext(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, "GetPortalWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).GetPortalWithContext), varargs...)
}

// GetTrustStore mocks base method.
func (m *MockWorkSpacesWebAPI) GetTrustStore(arg0 *workspacesweb.GetTrustStoreInput) (*workspacesweb.GetTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTrustStore", arg0)
	ret0, _ := ret[0].(*workspacesweb.GetTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTrustStoreCertificate mocks base method.
func (m *MockWorkSpacesWebAPI) GetTrustStoreCertificate(arg0 *workspacesweb.GetTrustStoreCertificateInput) (*workspacesweb.GetTrustStoreCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTrustStoreCertificate", arg0)
	ret0, _ := ret[0].(*workspacesweb.GetTrustStoreCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTrustStoreCertificateRequest mocks base method.
func (m *MockWorkSpacesWebAPI) GetTrustStoreCertificateRequest(arg0 *workspacesweb.GetTrustStoreCertificateInput) (*request.Request, *workspacesweb.GetTrustStoreCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTrustStoreCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.GetTrustStoreCertificateOutput)
	return ret0, ret1
}

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

// GetTrustStoreCertificateWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) GetTrustStoreCertificateWithContext(arg0 context.Context, arg1 *workspacesweb.GetTrustStoreCertificateInput, arg2 ...request.Option) (*workspacesweb.GetTrustStoreCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTrustStoreCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.GetTrustStoreCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTrustStoreCertificateWithContext indicates an expected call of GetTrustStoreCertificateWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) GetTrustStoreCertificateWithContext(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, "GetTrustStoreCertificateWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).GetTrustStoreCertificateWithContext), varargs...)
}

// GetTrustStoreRequest mocks base method.
func (m *MockWorkSpacesWebAPI) GetTrustStoreRequest(arg0 *workspacesweb.GetTrustStoreInput) (*request.Request, *workspacesweb.GetTrustStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTrustStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.GetTrustStoreOutput)
	return ret0, ret1
}

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

// GetTrustStoreWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) GetTrustStoreWithContext(arg0 context.Context, arg1 *workspacesweb.GetTrustStoreInput, arg2 ...request.Option) (*workspacesweb.GetTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTrustStoreWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.GetTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTrustStoreWithContext indicates an expected call of GetTrustStoreWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) GetTrustStoreWithContext(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, "GetTrustStoreWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).GetTrustStoreWithContext), varargs...)
}

// GetUserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) GetUserSettings(arg0 *workspacesweb.GetUserSettingsInput) (*workspacesweb.GetUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.GetUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) GetUserSettingsRequest(arg0 *workspacesweb.GetUserSettingsInput) (*request.Request, *workspacesweb.GetUserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.GetUserSettingsOutput)
	return ret0, ret1
}

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

// GetUserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) GetUserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.GetUserSettingsInput, arg2 ...request.Option) (*workspacesweb.GetUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.GetUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserSettingsWithContext indicates an expected call of GetUserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) GetUserSettingsWithContext(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, "GetUserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).GetUserSettingsWithContext), varargs...)
}

// ListBrowserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) ListBrowserSettings(arg0 *workspacesweb.ListBrowserSettingsInput) (*workspacesweb.ListBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBrowserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.ListBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBrowserSettingsPages mocks base method.
func (m *MockWorkSpacesWebAPI) ListBrowserSettingsPages(arg0 *workspacesweb.ListBrowserSettingsInput, arg1 func(*workspacesweb.ListBrowserSettingsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBrowserSettingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListBrowserSettingsPagesWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListBrowserSettingsPagesWithContext(arg0 context.Context, arg1 *workspacesweb.ListBrowserSettingsInput, arg2 func(*workspacesweb.ListBrowserSettingsOutput, 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, "ListBrowserSettingsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListBrowserSettingsPagesWithContext indicates an expected call of ListBrowserSettingsPagesWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListBrowserSettingsPagesWithContext(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, "ListBrowserSettingsPagesWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListBrowserSettingsPagesWithContext), varargs...)
}

// ListBrowserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) ListBrowserSettingsRequest(arg0 *workspacesweb.ListBrowserSettingsInput) (*request.Request, *workspacesweb.ListBrowserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBrowserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.ListBrowserSettingsOutput)
	return ret0, ret1
}

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

// ListBrowserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListBrowserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.ListBrowserSettingsInput, arg2 ...request.Option) (*workspacesweb.ListBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBrowserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.ListBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBrowserSettingsWithContext indicates an expected call of ListBrowserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListBrowserSettingsWithContext(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, "ListBrowserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListBrowserSettingsWithContext), varargs...)
}

// ListIdentityProviders mocks base method.
func (m *MockWorkSpacesWebAPI) ListIdentityProviders(arg0 *workspacesweb.ListIdentityProvidersInput) (*workspacesweb.ListIdentityProvidersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIdentityProviders", arg0)
	ret0, _ := ret[0].(*workspacesweb.ListIdentityProvidersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIdentityProvidersPages mocks base method.
func (m *MockWorkSpacesWebAPI) ListIdentityProvidersPages(arg0 *workspacesweb.ListIdentityProvidersInput, arg1 func(*workspacesweb.ListIdentityProvidersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIdentityProvidersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListIdentityProvidersPagesWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListIdentityProvidersPagesWithContext(arg0 context.Context, arg1 *workspacesweb.ListIdentityProvidersInput, arg2 func(*workspacesweb.ListIdentityProvidersOutput, 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, "ListIdentityProvidersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListIdentityProvidersPagesWithContext indicates an expected call of ListIdentityProvidersPagesWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListIdentityProvidersPagesWithContext(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, "ListIdentityProvidersPagesWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListIdentityProvidersPagesWithContext), varargs...)
}

// ListIdentityProvidersRequest mocks base method.
func (m *MockWorkSpacesWebAPI) ListIdentityProvidersRequest(arg0 *workspacesweb.ListIdentityProvidersInput) (*request.Request, *workspacesweb.ListIdentityProvidersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIdentityProvidersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.ListIdentityProvidersOutput)
	return ret0, ret1
}

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

// ListIdentityProvidersWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListIdentityProvidersWithContext(arg0 context.Context, arg1 *workspacesweb.ListIdentityProvidersInput, arg2 ...request.Option) (*workspacesweb.ListIdentityProvidersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIdentityProvidersWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.ListIdentityProvidersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListIdentityProvidersWithContext indicates an expected call of ListIdentityProvidersWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListIdentityProvidersWithContext(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, "ListIdentityProvidersWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListIdentityProvidersWithContext), varargs...)
}

// ListNetworkSettings mocks base method.
func (m *MockWorkSpacesWebAPI) ListNetworkSettings(arg0 *workspacesweb.ListNetworkSettingsInput) (*workspacesweb.ListNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetworkSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.ListNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNetworkSettingsPages mocks base method.
func (m *MockWorkSpacesWebAPI) ListNetworkSettingsPages(arg0 *workspacesweb.ListNetworkSettingsInput, arg1 func(*workspacesweb.ListNetworkSettingsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetworkSettingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListNetworkSettingsPagesWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListNetworkSettingsPagesWithContext(arg0 context.Context, arg1 *workspacesweb.ListNetworkSettingsInput, arg2 func(*workspacesweb.ListNetworkSettingsOutput, 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, "ListNetworkSettingsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListNetworkSettingsPagesWithContext indicates an expected call of ListNetworkSettingsPagesWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListNetworkSettingsPagesWithContext(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, "ListNetworkSettingsPagesWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListNetworkSettingsPagesWithContext), varargs...)
}

// ListNetworkSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) ListNetworkSettingsRequest(arg0 *workspacesweb.ListNetworkSettingsInput) (*request.Request, *workspacesweb.ListNetworkSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetworkSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.ListNetworkSettingsOutput)
	return ret0, ret1
}

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

// ListNetworkSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListNetworkSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.ListNetworkSettingsInput, arg2 ...request.Option) (*workspacesweb.ListNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNetworkSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.ListNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNetworkSettingsWithContext indicates an expected call of ListNetworkSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListNetworkSettingsWithContext(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, "ListNetworkSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListNetworkSettingsWithContext), varargs...)
}

// ListPortals mocks base method.
func (m *MockWorkSpacesWebAPI) ListPortals(arg0 *workspacesweb.ListPortalsInput) (*workspacesweb.ListPortalsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPortals", arg0)
	ret0, _ := ret[0].(*workspacesweb.ListPortalsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPortalsPages mocks base method.
func (m *MockWorkSpacesWebAPI) ListPortalsPages(arg0 *workspacesweb.ListPortalsInput, arg1 func(*workspacesweb.ListPortalsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPortalsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPortalsPagesWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListPortalsPagesWithContext(arg0 context.Context, arg1 *workspacesweb.ListPortalsInput, arg2 func(*workspacesweb.ListPortalsOutput, 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, "ListPortalsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPortalsPagesWithContext indicates an expected call of ListPortalsPagesWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListPortalsPagesWithContext(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, "ListPortalsPagesWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListPortalsPagesWithContext), varargs...)
}

// ListPortalsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) ListPortalsRequest(arg0 *workspacesweb.ListPortalsInput) (*request.Request, *workspacesweb.ListPortalsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPortalsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.ListPortalsOutput)
	return ret0, ret1
}

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

// ListPortalsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListPortalsWithContext(arg0 context.Context, arg1 *workspacesweb.ListPortalsInput, arg2 ...request.Option) (*workspacesweb.ListPortalsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPortalsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.ListPortalsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPortalsWithContext indicates an expected call of ListPortalsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListPortalsWithContext(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, "ListPortalsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListPortalsWithContext), varargs...)
}

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

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

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

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

// ListTagsForResourceWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListTagsForResourceWithContext(arg0 context.Context, arg1 *workspacesweb.ListTagsForResourceInput, arg2 ...request.Option) (*workspacesweb.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].(*workspacesweb.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) 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((*MockWorkSpacesWebAPI)(nil).ListTagsForResourceWithContext), varargs...)
}

// ListTrustStoreCertificates mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStoreCertificates(arg0 *workspacesweb.ListTrustStoreCertificatesInput) (*workspacesweb.ListTrustStoreCertificatesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrustStoreCertificates", arg0)
	ret0, _ := ret[0].(*workspacesweb.ListTrustStoreCertificatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTrustStoreCertificatesPages mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStoreCertificatesPages(arg0 *workspacesweb.ListTrustStoreCertificatesInput, arg1 func(*workspacesweb.ListTrustStoreCertificatesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrustStoreCertificatesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTrustStoreCertificatesPagesWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStoreCertificatesPagesWithContext(arg0 context.Context, arg1 *workspacesweb.ListTrustStoreCertificatesInput, arg2 func(*workspacesweb.ListTrustStoreCertificatesOutput, 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, "ListTrustStoreCertificatesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrustStoreCertificatesPagesWithContext indicates an expected call of ListTrustStoreCertificatesPagesWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListTrustStoreCertificatesPagesWithContext(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, "ListTrustStoreCertificatesPagesWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListTrustStoreCertificatesPagesWithContext), varargs...)
}

// ListTrustStoreCertificatesRequest mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStoreCertificatesRequest(arg0 *workspacesweb.ListTrustStoreCertificatesInput) (*request.Request, *workspacesweb.ListTrustStoreCertificatesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrustStoreCertificatesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.ListTrustStoreCertificatesOutput)
	return ret0, ret1
}

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

// ListTrustStoreCertificatesWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStoreCertificatesWithContext(arg0 context.Context, arg1 *workspacesweb.ListTrustStoreCertificatesInput, arg2 ...request.Option) (*workspacesweb.ListTrustStoreCertificatesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrustStoreCertificatesWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.ListTrustStoreCertificatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrustStoreCertificatesWithContext indicates an expected call of ListTrustStoreCertificatesWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListTrustStoreCertificatesWithContext(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, "ListTrustStoreCertificatesWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListTrustStoreCertificatesWithContext), varargs...)
}

// ListTrustStores mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStores(arg0 *workspacesweb.ListTrustStoresInput) (*workspacesweb.ListTrustStoresOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrustStores", arg0)
	ret0, _ := ret[0].(*workspacesweb.ListTrustStoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTrustStoresPages mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStoresPages(arg0 *workspacesweb.ListTrustStoresInput, arg1 func(*workspacesweb.ListTrustStoresOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrustStoresPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTrustStoresPagesWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStoresPagesWithContext(arg0 context.Context, arg1 *workspacesweb.ListTrustStoresInput, arg2 func(*workspacesweb.ListTrustStoresOutput, 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, "ListTrustStoresPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTrustStoresPagesWithContext indicates an expected call of ListTrustStoresPagesWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListTrustStoresPagesWithContext(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, "ListTrustStoresPagesWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListTrustStoresPagesWithContext), varargs...)
}

// ListTrustStoresRequest mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStoresRequest(arg0 *workspacesweb.ListTrustStoresInput) (*request.Request, *workspacesweb.ListTrustStoresOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrustStoresRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.ListTrustStoresOutput)
	return ret0, ret1
}

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

// ListTrustStoresWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListTrustStoresWithContext(arg0 context.Context, arg1 *workspacesweb.ListTrustStoresInput, arg2 ...request.Option) (*workspacesweb.ListTrustStoresOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrustStoresWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.ListTrustStoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrustStoresWithContext indicates an expected call of ListTrustStoresWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListTrustStoresWithContext(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, "ListTrustStoresWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListTrustStoresWithContext), varargs...)
}

// ListUserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) ListUserSettings(arg0 *workspacesweb.ListUserSettingsInput) (*workspacesweb.ListUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.ListUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUserSettingsPages mocks base method.
func (m *MockWorkSpacesWebAPI) ListUserSettingsPages(arg0 *workspacesweb.ListUserSettingsInput, arg1 func(*workspacesweb.ListUserSettingsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserSettingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListUserSettingsPagesWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListUserSettingsPagesWithContext(arg0 context.Context, arg1 *workspacesweb.ListUserSettingsInput, arg2 func(*workspacesweb.ListUserSettingsOutput, 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, "ListUserSettingsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListUserSettingsPagesWithContext indicates an expected call of ListUserSettingsPagesWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListUserSettingsPagesWithContext(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, "ListUserSettingsPagesWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListUserSettingsPagesWithContext), varargs...)
}

// ListUserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) ListUserSettingsRequest(arg0 *workspacesweb.ListUserSettingsInput) (*request.Request, *workspacesweb.ListUserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.ListUserSettingsOutput)
	return ret0, ret1
}

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

// ListUserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) ListUserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.ListUserSettingsInput, arg2 ...request.Option) (*workspacesweb.ListUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.ListUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUserSettingsWithContext indicates an expected call of ListUserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) ListUserSettingsWithContext(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, "ListUserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).ListUserSettingsWithContext), varargs...)
}

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

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

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

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

// TagResourceWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) TagResourceWithContext(arg0 context.Context, arg1 *workspacesweb.TagResourceInput, arg2 ...request.Option) (*workspacesweb.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].(*workspacesweb.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagResourceWithContext indicates an expected call of TagResourceWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) 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((*MockWorkSpacesWebAPI)(nil).TagResourceWithContext), varargs...)
}

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

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

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

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

// UntagResourceWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) UntagResourceWithContext(arg0 context.Context, arg1 *workspacesweb.UntagResourceInput, arg2 ...request.Option) (*workspacesweb.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].(*workspacesweb.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UntagResourceWithContext indicates an expected call of UntagResourceWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) 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((*MockWorkSpacesWebAPI)(nil).UntagResourceWithContext), varargs...)
}

// UpdateBrowserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateBrowserSettings(arg0 *workspacesweb.UpdateBrowserSettingsInput) (*workspacesweb.UpdateBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBrowserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.UpdateBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateBrowserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateBrowserSettingsRequest(arg0 *workspacesweb.UpdateBrowserSettingsInput) (*request.Request, *workspacesweb.UpdateBrowserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBrowserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.UpdateBrowserSettingsOutput)
	return ret0, ret1
}

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

// UpdateBrowserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateBrowserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.UpdateBrowserSettingsInput, arg2 ...request.Option) (*workspacesweb.UpdateBrowserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateBrowserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.UpdateBrowserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateBrowserSettingsWithContext indicates an expected call of UpdateBrowserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) UpdateBrowserSettingsWithContext(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, "UpdateBrowserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).UpdateBrowserSettingsWithContext), varargs...)
}

// UpdateIdentityProvider mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateIdentityProvider(arg0 *workspacesweb.UpdateIdentityProviderInput) (*workspacesweb.UpdateIdentityProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIdentityProvider", arg0)
	ret0, _ := ret[0].(*workspacesweb.UpdateIdentityProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateIdentityProviderRequest mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateIdentityProviderRequest(arg0 *workspacesweb.UpdateIdentityProviderInput) (*request.Request, *workspacesweb.UpdateIdentityProviderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIdentityProviderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.UpdateIdentityProviderOutput)
	return ret0, ret1
}

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

// UpdateIdentityProviderWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateIdentityProviderWithContext(arg0 context.Context, arg1 *workspacesweb.UpdateIdentityProviderInput, arg2 ...request.Option) (*workspacesweb.UpdateIdentityProviderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateIdentityProviderWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.UpdateIdentityProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateIdentityProviderWithContext indicates an expected call of UpdateIdentityProviderWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) UpdateIdentityProviderWithContext(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, "UpdateIdentityProviderWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).UpdateIdentityProviderWithContext), varargs...)
}

// UpdateNetworkSettings mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateNetworkSettings(arg0 *workspacesweb.UpdateNetworkSettingsInput) (*workspacesweb.UpdateNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNetworkSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.UpdateNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNetworkSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateNetworkSettingsRequest(arg0 *workspacesweb.UpdateNetworkSettingsInput) (*request.Request, *workspacesweb.UpdateNetworkSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNetworkSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.UpdateNetworkSettingsOutput)
	return ret0, ret1
}

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

// UpdateNetworkSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateNetworkSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.UpdateNetworkSettingsInput, arg2 ...request.Option) (*workspacesweb.UpdateNetworkSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNetworkSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.UpdateNetworkSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNetworkSettingsWithContext indicates an expected call of UpdateNetworkSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) UpdateNetworkSettingsWithContext(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, "UpdateNetworkSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).UpdateNetworkSettingsWithContext), varargs...)
}

// UpdatePortal mocks base method.
func (m *MockWorkSpacesWebAPI) UpdatePortal(arg0 *workspacesweb.UpdatePortalInput) (*workspacesweb.UpdatePortalOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePortal", arg0)
	ret0, _ := ret[0].(*workspacesweb.UpdatePortalOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePortalRequest mocks base method.
func (m *MockWorkSpacesWebAPI) UpdatePortalRequest(arg0 *workspacesweb.UpdatePortalInput) (*request.Request, *workspacesweb.UpdatePortalOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePortalRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.UpdatePortalOutput)
	return ret0, ret1
}

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

// UpdatePortalWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) UpdatePortalWithContext(arg0 context.Context, arg1 *workspacesweb.UpdatePortalInput, arg2 ...request.Option) (*workspacesweb.UpdatePortalOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePortalWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.UpdatePortalOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePortalWithContext indicates an expected call of UpdatePortalWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) UpdatePortalWithContext(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, "UpdatePortalWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).UpdatePortalWithContext), varargs...)
}

// UpdateTrustStore mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateTrustStore(arg0 *workspacesweb.UpdateTrustStoreInput) (*workspacesweb.UpdateTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTrustStore", arg0)
	ret0, _ := ret[0].(*workspacesweb.UpdateTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTrustStoreRequest mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateTrustStoreRequest(arg0 *workspacesweb.UpdateTrustStoreInput) (*request.Request, *workspacesweb.UpdateTrustStoreOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTrustStoreRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.UpdateTrustStoreOutput)
	return ret0, ret1
}

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

// UpdateTrustStoreWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateTrustStoreWithContext(arg0 context.Context, arg1 *workspacesweb.UpdateTrustStoreInput, arg2 ...request.Option) (*workspacesweb.UpdateTrustStoreOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTrustStoreWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.UpdateTrustStoreOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrustStoreWithContext indicates an expected call of UpdateTrustStoreWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) UpdateTrustStoreWithContext(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, "UpdateTrustStoreWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).UpdateTrustStoreWithContext), varargs...)
}

// UpdateUserSettings mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateUserSettings(arg0 *workspacesweb.UpdateUserSettingsInput) (*workspacesweb.UpdateUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserSettings", arg0)
	ret0, _ := ret[0].(*workspacesweb.UpdateUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateUserSettingsRequest mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateUserSettingsRequest(arg0 *workspacesweb.UpdateUserSettingsInput) (*request.Request, *workspacesweb.UpdateUserSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*workspacesweb.UpdateUserSettingsOutput)
	return ret0, ret1
}

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

// UpdateUserSettingsWithContext mocks base method.
func (m *MockWorkSpacesWebAPI) UpdateUserSettingsWithContext(arg0 context.Context, arg1 *workspacesweb.UpdateUserSettingsInput, arg2 ...request.Option) (*workspacesweb.UpdateUserSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUserSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*workspacesweb.UpdateUserSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserSettingsWithContext indicates an expected call of UpdateUserSettingsWithContext.
func (mr *MockWorkSpacesWebAPIMockRecorder) UpdateUserSettingsWithContext(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, "UpdateUserSettingsWithContext", reflect.TypeOf((*MockWorkSpacesWebAPI)(nil).UpdateUserSettingsWithContext), varargs...)
}