organizations.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/organizations/organizationsiface (interfaces: OrganizationsAPI)

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

import (
	context "context"
	reflect "reflect"

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

// MockOrganizationsAPI is a mock of OrganizationsAPI interface.
type MockOrganizationsAPI struct {
	ctrl     *gomock.Controller
	recorder *MockOrganizationsAPIMockRecorder
}

// MockOrganizationsAPIMockRecorder is the mock recorder for MockOrganizationsAPI.
type MockOrganizationsAPIMockRecorder struct {
	mock *MockOrganizationsAPI
}

// NewMockOrganizationsAPI creates a new mock instance.
func NewMockOrganizationsAPI(ctrl *gomock.Controller) *MockOrganizationsAPI {
	mock := &MockOrganizationsAPI{ctrl: ctrl}
	mock.recorder = &MockOrganizationsAPIMockRecorder{mock}
	return mock
}

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

// AcceptHandshake mocks base method.
func (m *MockOrganizationsAPI) AcceptHandshake(arg0 *organizations.AcceptHandshakeInput) (*organizations.AcceptHandshakeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptHandshake", arg0)
	ret0, _ := ret[0].(*organizations.AcceptHandshakeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcceptHandshakeRequest mocks base method.
func (m *MockOrganizationsAPI) AcceptHandshakeRequest(arg0 *organizations.AcceptHandshakeInput) (*request.Request, *organizations.AcceptHandshakeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptHandshakeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.AcceptHandshakeOutput)
	return ret0, ret1
}

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

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

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

// AttachPolicy mocks base method.
func (m *MockOrganizationsAPI) AttachPolicy(arg0 *organizations.AttachPolicyInput) (*organizations.AttachPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachPolicy", arg0)
	ret0, _ := ret[0].(*organizations.AttachPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AttachPolicyRequest mocks base method.
func (m *MockOrganizationsAPI) AttachPolicyRequest(arg0 *organizations.AttachPolicyInput) (*request.Request, *organizations.AttachPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.AttachPolicyOutput)
	return ret0, ret1
}

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

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

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

// CancelHandshake mocks base method.
func (m *MockOrganizationsAPI) CancelHandshake(arg0 *organizations.CancelHandshakeInput) (*organizations.CancelHandshakeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelHandshake", arg0)
	ret0, _ := ret[0].(*organizations.CancelHandshakeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelHandshakeRequest mocks base method.
func (m *MockOrganizationsAPI) CancelHandshakeRequest(arg0 *organizations.CancelHandshakeInput) (*request.Request, *organizations.CancelHandshakeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelHandshakeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.CancelHandshakeOutput)
	return ret0, ret1
}

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

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

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

// CloseAccount mocks base method.
func (m *MockOrganizationsAPI) CloseAccount(arg0 *organizations.CloseAccountInput) (*organizations.CloseAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseAccount", arg0)
	ret0, _ := ret[0].(*organizations.CloseAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CloseAccountRequest mocks base method.
func (m *MockOrganizationsAPI) CloseAccountRequest(arg0 *organizations.CloseAccountInput) (*request.Request, *organizations.CloseAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.CloseAccountOutput)
	return ret0, ret1
}

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

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

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

// CreateAccount mocks base method.
func (m *MockOrganizationsAPI) CreateAccount(arg0 *organizations.CreateAccountInput) (*organizations.CreateAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccount", arg0)
	ret0, _ := ret[0].(*organizations.CreateAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAccountRequest mocks base method.
func (m *MockOrganizationsAPI) CreateAccountRequest(arg0 *organizations.CreateAccountInput) (*request.Request, *organizations.CreateAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.CreateAccountOutput)
	return ret0, ret1
}

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

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

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

// CreateGovCloudAccount mocks base method.
func (m *MockOrganizationsAPI) CreateGovCloudAccount(arg0 *organizations.CreateGovCloudAccountInput) (*organizations.CreateGovCloudAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGovCloudAccount", arg0)
	ret0, _ := ret[0].(*organizations.CreateGovCloudAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGovCloudAccountRequest mocks base method.
func (m *MockOrganizationsAPI) CreateGovCloudAccountRequest(arg0 *organizations.CreateGovCloudAccountInput) (*request.Request, *organizations.CreateGovCloudAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGovCloudAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.CreateGovCloudAccountOutput)
	return ret0, ret1
}

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

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

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

// CreateOrganization mocks base method.
func (m *MockOrganizationsAPI) CreateOrganization(arg0 *organizations.CreateOrganizationInput) (*organizations.CreateOrganizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrganization", arg0)
	ret0, _ := ret[0].(*organizations.CreateOrganizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateOrganizationRequest mocks base method.
func (m *MockOrganizationsAPI) CreateOrganizationRequest(arg0 *organizations.CreateOrganizationInput) (*request.Request, *organizations.CreateOrganizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrganizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.CreateOrganizationOutput)
	return ret0, ret1
}

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

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

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

// CreateOrganizationalUnit mocks base method.
func (m *MockOrganizationsAPI) CreateOrganizationalUnit(arg0 *organizations.CreateOrganizationalUnitInput) (*organizations.CreateOrganizationalUnitOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrganizationalUnit", arg0)
	ret0, _ := ret[0].(*organizations.CreateOrganizationalUnitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateOrganizationalUnitRequest mocks base method.
func (m *MockOrganizationsAPI) CreateOrganizationalUnitRequest(arg0 *organizations.CreateOrganizationalUnitInput) (*request.Request, *organizations.CreateOrganizationalUnitOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrganizationalUnitRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.CreateOrganizationalUnitOutput)
	return ret0, ret1
}

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

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

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

// CreatePolicy mocks base method.
func (m *MockOrganizationsAPI) CreatePolicy(arg0 *organizations.CreatePolicyInput) (*organizations.CreatePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePolicy", arg0)
	ret0, _ := ret[0].(*organizations.CreatePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePolicyRequest mocks base method.
func (m *MockOrganizationsAPI) CreatePolicyRequest(arg0 *organizations.CreatePolicyInput) (*request.Request, *organizations.CreatePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.CreatePolicyOutput)
	return ret0, ret1
}

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

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

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

// DeclineHandshake mocks base method.
func (m *MockOrganizationsAPI) DeclineHandshake(arg0 *organizations.DeclineHandshakeInput) (*organizations.DeclineHandshakeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeclineHandshake", arg0)
	ret0, _ := ret[0].(*organizations.DeclineHandshakeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeclineHandshakeRequest mocks base method.
func (m *MockOrganizationsAPI) DeclineHandshakeRequest(arg0 *organizations.DeclineHandshakeInput) (*request.Request, *organizations.DeclineHandshakeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeclineHandshakeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DeclineHandshakeOutput)
	return ret0, ret1
}

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

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

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

// DeleteOrganization mocks base method.
func (m *MockOrganizationsAPI) DeleteOrganization(arg0 *organizations.DeleteOrganizationInput) (*organizations.DeleteOrganizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOrganization", arg0)
	ret0, _ := ret[0].(*organizations.DeleteOrganizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteOrganizationRequest mocks base method.
func (m *MockOrganizationsAPI) DeleteOrganizationRequest(arg0 *organizations.DeleteOrganizationInput) (*request.Request, *organizations.DeleteOrganizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOrganizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DeleteOrganizationOutput)
	return ret0, ret1
}

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

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

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

// DeleteOrganizationalUnit mocks base method.
func (m *MockOrganizationsAPI) DeleteOrganizationalUnit(arg0 *organizations.DeleteOrganizationalUnitInput) (*organizations.DeleteOrganizationalUnitOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOrganizationalUnit", arg0)
	ret0, _ := ret[0].(*organizations.DeleteOrganizationalUnitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteOrganizationalUnitRequest mocks base method.
func (m *MockOrganizationsAPI) DeleteOrganizationalUnitRequest(arg0 *organizations.DeleteOrganizationalUnitInput) (*request.Request, *organizations.DeleteOrganizationalUnitOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOrganizationalUnitRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DeleteOrganizationalUnitOutput)
	return ret0, ret1
}

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

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

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

// DeletePolicy mocks base method.
func (m *MockOrganizationsAPI) DeletePolicy(arg0 *organizations.DeletePolicyInput) (*organizations.DeletePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePolicy", arg0)
	ret0, _ := ret[0].(*organizations.DeletePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePolicyRequest mocks base method.
func (m *MockOrganizationsAPI) DeletePolicyRequest(arg0 *organizations.DeletePolicyInput) (*request.Request, *organizations.DeletePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DeletePolicyOutput)
	return ret0, ret1
}

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

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

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

// DeleteResourcePolicy mocks base method.
func (m *MockOrganizationsAPI) DeleteResourcePolicy(arg0 *organizations.DeleteResourcePolicyInput) (*organizations.DeleteResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteResourcePolicy", arg0)
	ret0, _ := ret[0].(*organizations.DeleteResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteResourcePolicyRequest mocks base method.
func (m *MockOrganizationsAPI) DeleteResourcePolicyRequest(arg0 *organizations.DeleteResourcePolicyInput) (*request.Request, *organizations.DeleteResourcePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteResourcePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DeleteResourcePolicyOutput)
	return ret0, ret1
}

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

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

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

// DeregisterDelegatedAdministrator mocks base method.
func (m *MockOrganizationsAPI) DeregisterDelegatedAdministrator(arg0 *organizations.DeregisterDelegatedAdministratorInput) (*organizations.DeregisterDelegatedAdministratorOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterDelegatedAdministrator", arg0)
	ret0, _ := ret[0].(*organizations.DeregisterDelegatedAdministratorOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterDelegatedAdministratorRequest mocks base method.
func (m *MockOrganizationsAPI) DeregisterDelegatedAdministratorRequest(arg0 *organizations.DeregisterDelegatedAdministratorInput) (*request.Request, *organizations.DeregisterDelegatedAdministratorOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterDelegatedAdministratorRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DeregisterDelegatedAdministratorOutput)
	return ret0, ret1
}

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

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

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

// DescribeAccount mocks base method.
func (m *MockOrganizationsAPI) DescribeAccount(arg0 *organizations.DescribeAccountInput) (*organizations.DescribeAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccount", arg0)
	ret0, _ := ret[0].(*organizations.DescribeAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAccountRequest mocks base method.
func (m *MockOrganizationsAPI) DescribeAccountRequest(arg0 *organizations.DescribeAccountInput) (*request.Request, *organizations.DescribeAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DescribeAccountOutput)
	return ret0, ret1
}

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

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

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

// DescribeCreateAccountStatus mocks base method.
func (m *MockOrganizationsAPI) DescribeCreateAccountStatus(arg0 *organizations.DescribeCreateAccountStatusInput) (*organizations.DescribeCreateAccountStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCreateAccountStatus", arg0)
	ret0, _ := ret[0].(*organizations.DescribeCreateAccountStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCreateAccountStatusRequest mocks base method.
func (m *MockOrganizationsAPI) DescribeCreateAccountStatusRequest(arg0 *organizations.DescribeCreateAccountStatusInput) (*request.Request, *organizations.DescribeCreateAccountStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCreateAccountStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DescribeCreateAccountStatusOutput)
	return ret0, ret1
}

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

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

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

// DescribeEffectivePolicy mocks base method.
func (m *MockOrganizationsAPI) DescribeEffectivePolicy(arg0 *organizations.DescribeEffectivePolicyInput) (*organizations.DescribeEffectivePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEffectivePolicy", arg0)
	ret0, _ := ret[0].(*organizations.DescribeEffectivePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEffectivePolicyRequest mocks base method.
func (m *MockOrganizationsAPI) DescribeEffectivePolicyRequest(arg0 *organizations.DescribeEffectivePolicyInput) (*request.Request, *organizations.DescribeEffectivePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEffectivePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DescribeEffectivePolicyOutput)
	return ret0, ret1
}

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

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

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

// DescribeHandshake mocks base method.
func (m *MockOrganizationsAPI) DescribeHandshake(arg0 *organizations.DescribeHandshakeInput) (*organizations.DescribeHandshakeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHandshake", arg0)
	ret0, _ := ret[0].(*organizations.DescribeHandshakeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeHandshakeRequest mocks base method.
func (m *MockOrganizationsAPI) DescribeHandshakeRequest(arg0 *organizations.DescribeHandshakeInput) (*request.Request, *organizations.DescribeHandshakeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHandshakeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DescribeHandshakeOutput)
	return ret0, ret1
}

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

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

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

// DescribeOrganization mocks base method.
func (m *MockOrganizationsAPI) DescribeOrganization(arg0 *organizations.DescribeOrganizationInput) (*organizations.DescribeOrganizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeOrganization", arg0)
	ret0, _ := ret[0].(*organizations.DescribeOrganizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeOrganizationRequest mocks base method.
func (m *MockOrganizationsAPI) DescribeOrganizationRequest(arg0 *organizations.DescribeOrganizationInput) (*request.Request, *organizations.DescribeOrganizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeOrganizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DescribeOrganizationOutput)
	return ret0, ret1
}

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

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

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

// DescribeOrganizationalUnit mocks base method.
func (m *MockOrganizationsAPI) DescribeOrganizationalUnit(arg0 *organizations.DescribeOrganizationalUnitInput) (*organizations.DescribeOrganizationalUnitOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeOrganizationalUnit", arg0)
	ret0, _ := ret[0].(*organizations.DescribeOrganizationalUnitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeOrganizationalUnitRequest mocks base method.
func (m *MockOrganizationsAPI) DescribeOrganizationalUnitRequest(arg0 *organizations.DescribeOrganizationalUnitInput) (*request.Request, *organizations.DescribeOrganizationalUnitOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeOrganizationalUnitRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DescribeOrganizationalUnitOutput)
	return ret0, ret1
}

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

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

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

// DescribePolicy mocks base method.
func (m *MockOrganizationsAPI) DescribePolicy(arg0 *organizations.DescribePolicyInput) (*organizations.DescribePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePolicy", arg0)
	ret0, _ := ret[0].(*organizations.DescribePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePolicyRequest mocks base method.
func (m *MockOrganizationsAPI) DescribePolicyRequest(arg0 *organizations.DescribePolicyInput) (*request.Request, *organizations.DescribePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DescribePolicyOutput)
	return ret0, ret1
}

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

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

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

// DescribeResourcePolicy mocks base method.
func (m *MockOrganizationsAPI) DescribeResourcePolicy(arg0 *organizations.DescribeResourcePolicyInput) (*organizations.DescribeResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeResourcePolicy", arg0)
	ret0, _ := ret[0].(*organizations.DescribeResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeResourcePolicyRequest mocks base method.
func (m *MockOrganizationsAPI) DescribeResourcePolicyRequest(arg0 *organizations.DescribeResourcePolicyInput) (*request.Request, *organizations.DescribeResourcePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeResourcePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DescribeResourcePolicyOutput)
	return ret0, ret1
}

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

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

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

// DetachPolicy mocks base method.
func (m *MockOrganizationsAPI) DetachPolicy(arg0 *organizations.DetachPolicyInput) (*organizations.DetachPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachPolicy", arg0)
	ret0, _ := ret[0].(*organizations.DetachPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DetachPolicyRequest mocks base method.
func (m *MockOrganizationsAPI) DetachPolicyRequest(arg0 *organizations.DetachPolicyInput) (*request.Request, *organizations.DetachPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DetachPolicyOutput)
	return ret0, ret1
}

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

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

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

// DisableAWSServiceAccess mocks base method.
func (m *MockOrganizationsAPI) DisableAWSServiceAccess(arg0 *organizations.DisableAWSServiceAccessInput) (*organizations.DisableAWSServiceAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableAWSServiceAccess", arg0)
	ret0, _ := ret[0].(*organizations.DisableAWSServiceAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableAWSServiceAccessRequest mocks base method.
func (m *MockOrganizationsAPI) DisableAWSServiceAccessRequest(arg0 *organizations.DisableAWSServiceAccessInput) (*request.Request, *organizations.DisableAWSServiceAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableAWSServiceAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DisableAWSServiceAccessOutput)
	return ret0, ret1
}

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

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

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

// DisablePolicyType mocks base method.
func (m *MockOrganizationsAPI) DisablePolicyType(arg0 *organizations.DisablePolicyTypeInput) (*organizations.DisablePolicyTypeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisablePolicyType", arg0)
	ret0, _ := ret[0].(*organizations.DisablePolicyTypeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisablePolicyTypeRequest mocks base method.
func (m *MockOrganizationsAPI) DisablePolicyTypeRequest(arg0 *organizations.DisablePolicyTypeInput) (*request.Request, *organizations.DisablePolicyTypeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisablePolicyTypeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.DisablePolicyTypeOutput)
	return ret0, ret1
}

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

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

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

// EnableAWSServiceAccess mocks base method.
func (m *MockOrganizationsAPI) EnableAWSServiceAccess(arg0 *organizations.EnableAWSServiceAccessInput) (*organizations.EnableAWSServiceAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAWSServiceAccess", arg0)
	ret0, _ := ret[0].(*organizations.EnableAWSServiceAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableAWSServiceAccessRequest mocks base method.
func (m *MockOrganizationsAPI) EnableAWSServiceAccessRequest(arg0 *organizations.EnableAWSServiceAccessInput) (*request.Request, *organizations.EnableAWSServiceAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAWSServiceAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.EnableAWSServiceAccessOutput)
	return ret0, ret1
}

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

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

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

// EnableAllFeatures mocks base method.
func (m *MockOrganizationsAPI) EnableAllFeatures(arg0 *organizations.EnableAllFeaturesInput) (*organizations.EnableAllFeaturesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAllFeatures", arg0)
	ret0, _ := ret[0].(*organizations.EnableAllFeaturesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableAllFeaturesRequest mocks base method.
func (m *MockOrganizationsAPI) EnableAllFeaturesRequest(arg0 *organizations.EnableAllFeaturesInput) (*request.Request, *organizations.EnableAllFeaturesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAllFeaturesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.EnableAllFeaturesOutput)
	return ret0, ret1
}

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

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

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

// EnablePolicyType mocks base method.
func (m *MockOrganizationsAPI) EnablePolicyType(arg0 *organizations.EnablePolicyTypeInput) (*organizations.EnablePolicyTypeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnablePolicyType", arg0)
	ret0, _ := ret[0].(*organizations.EnablePolicyTypeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnablePolicyTypeRequest mocks base method.
func (m *MockOrganizationsAPI) EnablePolicyTypeRequest(arg0 *organizations.EnablePolicyTypeInput) (*request.Request, *organizations.EnablePolicyTypeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnablePolicyTypeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.EnablePolicyTypeOutput)
	return ret0, ret1
}

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

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

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

// InviteAccountToOrganization mocks base method.
func (m *MockOrganizationsAPI) InviteAccountToOrganization(arg0 *organizations.InviteAccountToOrganizationInput) (*organizations.InviteAccountToOrganizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InviteAccountToOrganization", arg0)
	ret0, _ := ret[0].(*organizations.InviteAccountToOrganizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InviteAccountToOrganizationRequest mocks base method.
func (m *MockOrganizationsAPI) InviteAccountToOrganizationRequest(arg0 *organizations.InviteAccountToOrganizationInput) (*request.Request, *organizations.InviteAccountToOrganizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InviteAccountToOrganizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.InviteAccountToOrganizationOutput)
	return ret0, ret1
}

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

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

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

// LeaveOrganization mocks base method.
func (m *MockOrganizationsAPI) LeaveOrganization(arg0 *organizations.LeaveOrganizationInput) (*organizations.LeaveOrganizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LeaveOrganization", arg0)
	ret0, _ := ret[0].(*organizations.LeaveOrganizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LeaveOrganizationRequest mocks base method.
func (m *MockOrganizationsAPI) LeaveOrganizationRequest(arg0 *organizations.LeaveOrganizationInput) (*request.Request, *organizations.LeaveOrganizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LeaveOrganizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.LeaveOrganizationOutput)
	return ret0, ret1
}

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

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

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

// ListAWSServiceAccessForOrganization mocks base method.
func (m *MockOrganizationsAPI) ListAWSServiceAccessForOrganization(arg0 *organizations.ListAWSServiceAccessForOrganizationInput) (*organizations.ListAWSServiceAccessForOrganizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAWSServiceAccessForOrganization", arg0)
	ret0, _ := ret[0].(*organizations.ListAWSServiceAccessForOrganizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAWSServiceAccessForOrganizationPages mocks base method.
func (m *MockOrganizationsAPI) ListAWSServiceAccessForOrganizationPages(arg0 *organizations.ListAWSServiceAccessForOrganizationInput, arg1 func(*organizations.ListAWSServiceAccessForOrganizationOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAWSServiceAccessForOrganizationPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAWSServiceAccessForOrganizationPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListAWSServiceAccessForOrganizationPagesWithContext(arg0 context.Context, arg1 *organizations.ListAWSServiceAccessForOrganizationInput, arg2 func(*organizations.ListAWSServiceAccessForOrganizationOutput, 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, "ListAWSServiceAccessForOrganizationPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAWSServiceAccessForOrganizationRequest mocks base method.
func (m *MockOrganizationsAPI) ListAWSServiceAccessForOrganizationRequest(arg0 *organizations.ListAWSServiceAccessForOrganizationInput) (*request.Request, *organizations.ListAWSServiceAccessForOrganizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAWSServiceAccessForOrganizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListAWSServiceAccessForOrganizationOutput)
	return ret0, ret1
}

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

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

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

// ListAccounts mocks base method.
func (m *MockOrganizationsAPI) ListAccounts(arg0 *organizations.ListAccountsInput) (*organizations.ListAccountsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccounts", arg0)
	ret0, _ := ret[0].(*organizations.ListAccountsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAccountsForParent mocks base method.
func (m *MockOrganizationsAPI) ListAccountsForParent(arg0 *organizations.ListAccountsForParentInput) (*organizations.ListAccountsForParentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccountsForParent", arg0)
	ret0, _ := ret[0].(*organizations.ListAccountsForParentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAccountsForParentPages mocks base method.
func (m *MockOrganizationsAPI) ListAccountsForParentPages(arg0 *organizations.ListAccountsForParentInput, arg1 func(*organizations.ListAccountsForParentOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccountsForParentPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAccountsForParentPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListAccountsForParentPagesWithContext(arg0 context.Context, arg1 *organizations.ListAccountsForParentInput, arg2 func(*organizations.ListAccountsForParentOutput, 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, "ListAccountsForParentPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAccountsForParentRequest mocks base method.
func (m *MockOrganizationsAPI) ListAccountsForParentRequest(arg0 *organizations.ListAccountsForParentInput) (*request.Request, *organizations.ListAccountsForParentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccountsForParentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListAccountsForParentOutput)
	return ret0, ret1
}

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

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

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

// ListAccountsPages mocks base method.
func (m *MockOrganizationsAPI) ListAccountsPages(arg0 *organizations.ListAccountsInput, arg1 func(*organizations.ListAccountsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccountsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAccountsPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListAccountsPagesWithContext(arg0 context.Context, arg1 *organizations.ListAccountsInput, arg2 func(*organizations.ListAccountsOutput, 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, "ListAccountsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAccountsRequest mocks base method.
func (m *MockOrganizationsAPI) ListAccountsRequest(arg0 *organizations.ListAccountsInput) (*request.Request, *organizations.ListAccountsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccountsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListAccountsOutput)
	return ret0, ret1
}

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

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

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

// ListChildren mocks base method.
func (m *MockOrganizationsAPI) ListChildren(arg0 *organizations.ListChildrenInput) (*organizations.ListChildrenOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChildren", arg0)
	ret0, _ := ret[0].(*organizations.ListChildrenOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListChildrenPages mocks base method.
func (m *MockOrganizationsAPI) ListChildrenPages(arg0 *organizations.ListChildrenInput, arg1 func(*organizations.ListChildrenOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChildrenPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListChildrenPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListChildrenPagesWithContext(arg0 context.Context, arg1 *organizations.ListChildrenInput, arg2 func(*organizations.ListChildrenOutput, 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, "ListChildrenPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListChildrenRequest mocks base method.
func (m *MockOrganizationsAPI) ListChildrenRequest(arg0 *organizations.ListChildrenInput) (*request.Request, *organizations.ListChildrenOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChildrenRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListChildrenOutput)
	return ret0, ret1
}

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

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

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

// ListCreateAccountStatus mocks base method.
func (m *MockOrganizationsAPI) ListCreateAccountStatus(arg0 *organizations.ListCreateAccountStatusInput) (*organizations.ListCreateAccountStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCreateAccountStatus", arg0)
	ret0, _ := ret[0].(*organizations.ListCreateAccountStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCreateAccountStatusPages mocks base method.
func (m *MockOrganizationsAPI) ListCreateAccountStatusPages(arg0 *organizations.ListCreateAccountStatusInput, arg1 func(*organizations.ListCreateAccountStatusOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCreateAccountStatusPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListCreateAccountStatusPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListCreateAccountStatusPagesWithContext(arg0 context.Context, arg1 *organizations.ListCreateAccountStatusInput, arg2 func(*organizations.ListCreateAccountStatusOutput, 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, "ListCreateAccountStatusPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListCreateAccountStatusRequest mocks base method.
func (m *MockOrganizationsAPI) ListCreateAccountStatusRequest(arg0 *organizations.ListCreateAccountStatusInput) (*request.Request, *organizations.ListCreateAccountStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCreateAccountStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListCreateAccountStatusOutput)
	return ret0, ret1
}

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

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

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

// ListDelegatedAdministrators mocks base method.
func (m *MockOrganizationsAPI) ListDelegatedAdministrators(arg0 *organizations.ListDelegatedAdministratorsInput) (*organizations.ListDelegatedAdministratorsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDelegatedAdministrators", arg0)
	ret0, _ := ret[0].(*organizations.ListDelegatedAdministratorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDelegatedAdministratorsPages mocks base method.
func (m *MockOrganizationsAPI) ListDelegatedAdministratorsPages(arg0 *organizations.ListDelegatedAdministratorsInput, arg1 func(*organizations.ListDelegatedAdministratorsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDelegatedAdministratorsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDelegatedAdministratorsPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListDelegatedAdministratorsPagesWithContext(arg0 context.Context, arg1 *organizations.ListDelegatedAdministratorsInput, arg2 func(*organizations.ListDelegatedAdministratorsOutput, 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, "ListDelegatedAdministratorsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDelegatedAdministratorsRequest mocks base method.
func (m *MockOrganizationsAPI) ListDelegatedAdministratorsRequest(arg0 *organizations.ListDelegatedAdministratorsInput) (*request.Request, *organizations.ListDelegatedAdministratorsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDelegatedAdministratorsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListDelegatedAdministratorsOutput)
	return ret0, ret1
}

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

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

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

// ListDelegatedServicesForAccount mocks base method.
func (m *MockOrganizationsAPI) ListDelegatedServicesForAccount(arg0 *organizations.ListDelegatedServicesForAccountInput) (*organizations.ListDelegatedServicesForAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDelegatedServicesForAccount", arg0)
	ret0, _ := ret[0].(*organizations.ListDelegatedServicesForAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDelegatedServicesForAccountPages mocks base method.
func (m *MockOrganizationsAPI) ListDelegatedServicesForAccountPages(arg0 *organizations.ListDelegatedServicesForAccountInput, arg1 func(*organizations.ListDelegatedServicesForAccountOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDelegatedServicesForAccountPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDelegatedServicesForAccountPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListDelegatedServicesForAccountPagesWithContext(arg0 context.Context, arg1 *organizations.ListDelegatedServicesForAccountInput, arg2 func(*organizations.ListDelegatedServicesForAccountOutput, 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, "ListDelegatedServicesForAccountPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDelegatedServicesForAccountRequest mocks base method.
func (m *MockOrganizationsAPI) ListDelegatedServicesForAccountRequest(arg0 *organizations.ListDelegatedServicesForAccountInput) (*request.Request, *organizations.ListDelegatedServicesForAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDelegatedServicesForAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListDelegatedServicesForAccountOutput)
	return ret0, ret1
}

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

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

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

// ListHandshakesForAccount mocks base method.
func (m *MockOrganizationsAPI) ListHandshakesForAccount(arg0 *organizations.ListHandshakesForAccountInput) (*organizations.ListHandshakesForAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHandshakesForAccount", arg0)
	ret0, _ := ret[0].(*organizations.ListHandshakesForAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListHandshakesForAccountPages mocks base method.
func (m *MockOrganizationsAPI) ListHandshakesForAccountPages(arg0 *organizations.ListHandshakesForAccountInput, arg1 func(*organizations.ListHandshakesForAccountOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHandshakesForAccountPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListHandshakesForAccountPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListHandshakesForAccountPagesWithContext(arg0 context.Context, arg1 *organizations.ListHandshakesForAccountInput, arg2 func(*organizations.ListHandshakesForAccountOutput, 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, "ListHandshakesForAccountPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListHandshakesForAccountRequest mocks base method.
func (m *MockOrganizationsAPI) ListHandshakesForAccountRequest(arg0 *organizations.ListHandshakesForAccountInput) (*request.Request, *organizations.ListHandshakesForAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHandshakesForAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListHandshakesForAccountOutput)
	return ret0, ret1
}

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

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

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

// ListHandshakesForOrganization mocks base method.
func (m *MockOrganizationsAPI) ListHandshakesForOrganization(arg0 *organizations.ListHandshakesForOrganizationInput) (*organizations.ListHandshakesForOrganizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHandshakesForOrganization", arg0)
	ret0, _ := ret[0].(*organizations.ListHandshakesForOrganizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListHandshakesForOrganizationPages mocks base method.
func (m *MockOrganizationsAPI) ListHandshakesForOrganizationPages(arg0 *organizations.ListHandshakesForOrganizationInput, arg1 func(*organizations.ListHandshakesForOrganizationOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHandshakesForOrganizationPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListHandshakesForOrganizationPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListHandshakesForOrganizationPagesWithContext(arg0 context.Context, arg1 *organizations.ListHandshakesForOrganizationInput, arg2 func(*organizations.ListHandshakesForOrganizationOutput, 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, "ListHandshakesForOrganizationPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListHandshakesForOrganizationRequest mocks base method.
func (m *MockOrganizationsAPI) ListHandshakesForOrganizationRequest(arg0 *organizations.ListHandshakesForOrganizationInput) (*request.Request, *organizations.ListHandshakesForOrganizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHandshakesForOrganizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListHandshakesForOrganizationOutput)
	return ret0, ret1
}

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

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

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

// ListOrganizationalUnitsForParent mocks base method.
func (m *MockOrganizationsAPI) ListOrganizationalUnitsForParent(arg0 *organizations.ListOrganizationalUnitsForParentInput) (*organizations.ListOrganizationalUnitsForParentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOrganizationalUnitsForParent", arg0)
	ret0, _ := ret[0].(*organizations.ListOrganizationalUnitsForParentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListOrganizationalUnitsForParentPages mocks base method.
func (m *MockOrganizationsAPI) ListOrganizationalUnitsForParentPages(arg0 *organizations.ListOrganizationalUnitsForParentInput, arg1 func(*organizations.ListOrganizationalUnitsForParentOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOrganizationalUnitsForParentPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListOrganizationalUnitsForParentPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListOrganizationalUnitsForParentPagesWithContext(arg0 context.Context, arg1 *organizations.ListOrganizationalUnitsForParentInput, arg2 func(*organizations.ListOrganizationalUnitsForParentOutput, 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, "ListOrganizationalUnitsForParentPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListOrganizationalUnitsForParentRequest mocks base method.
func (m *MockOrganizationsAPI) ListOrganizationalUnitsForParentRequest(arg0 *organizations.ListOrganizationalUnitsForParentInput) (*request.Request, *organizations.ListOrganizationalUnitsForParentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOrganizationalUnitsForParentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListOrganizationalUnitsForParentOutput)
	return ret0, ret1
}

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

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

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

// ListParents mocks base method.
func (m *MockOrganizationsAPI) ListParents(arg0 *organizations.ListParentsInput) (*organizations.ListParentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListParents", arg0)
	ret0, _ := ret[0].(*organizations.ListParentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListParentsPages mocks base method.
func (m *MockOrganizationsAPI) ListParentsPages(arg0 *organizations.ListParentsInput, arg1 func(*organizations.ListParentsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListParentsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListParentsPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListParentsPagesWithContext(arg0 context.Context, arg1 *organizations.ListParentsInput, arg2 func(*organizations.ListParentsOutput, 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, "ListParentsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListParentsRequest mocks base method.
func (m *MockOrganizationsAPI) ListParentsRequest(arg0 *organizations.ListParentsInput) (*request.Request, *organizations.ListParentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListParentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListParentsOutput)
	return ret0, ret1
}

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

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

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

// ListPolicies mocks base method.
func (m *MockOrganizationsAPI) ListPolicies(arg0 *organizations.ListPoliciesInput) (*organizations.ListPoliciesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPolicies", arg0)
	ret0, _ := ret[0].(*organizations.ListPoliciesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPoliciesForTarget mocks base method.
func (m *MockOrganizationsAPI) ListPoliciesForTarget(arg0 *organizations.ListPoliciesForTargetInput) (*organizations.ListPoliciesForTargetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPoliciesForTarget", arg0)
	ret0, _ := ret[0].(*organizations.ListPoliciesForTargetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPoliciesForTargetPages mocks base method.
func (m *MockOrganizationsAPI) ListPoliciesForTargetPages(arg0 *organizations.ListPoliciesForTargetInput, arg1 func(*organizations.ListPoliciesForTargetOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPoliciesForTargetPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPoliciesForTargetPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListPoliciesForTargetPagesWithContext(arg0 context.Context, arg1 *organizations.ListPoliciesForTargetInput, arg2 func(*organizations.ListPoliciesForTargetOutput, 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, "ListPoliciesForTargetPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPoliciesForTargetRequest mocks base method.
func (m *MockOrganizationsAPI) ListPoliciesForTargetRequest(arg0 *organizations.ListPoliciesForTargetInput) (*request.Request, *organizations.ListPoliciesForTargetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPoliciesForTargetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListPoliciesForTargetOutput)
	return ret0, ret1
}

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

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

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

// ListPoliciesPages mocks base method.
func (m *MockOrganizationsAPI) ListPoliciesPages(arg0 *organizations.ListPoliciesInput, arg1 func(*organizations.ListPoliciesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPoliciesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPoliciesPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListPoliciesPagesWithContext(arg0 context.Context, arg1 *organizations.ListPoliciesInput, arg2 func(*organizations.ListPoliciesOutput, 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, "ListPoliciesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPoliciesRequest mocks base method.
func (m *MockOrganizationsAPI) ListPoliciesRequest(arg0 *organizations.ListPoliciesInput) (*request.Request, *organizations.ListPoliciesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPoliciesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListPoliciesOutput)
	return ret0, ret1
}

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

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

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

// ListRoots mocks base method.
func (m *MockOrganizationsAPI) ListRoots(arg0 *organizations.ListRootsInput) (*organizations.ListRootsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRoots", arg0)
	ret0, _ := ret[0].(*organizations.ListRootsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRootsPages mocks base method.
func (m *MockOrganizationsAPI) ListRootsPages(arg0 *organizations.ListRootsInput, arg1 func(*organizations.ListRootsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRootsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListRootsPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListRootsPagesWithContext(arg0 context.Context, arg1 *organizations.ListRootsInput, arg2 func(*organizations.ListRootsOutput, 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, "ListRootsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListRootsRequest mocks base method.
func (m *MockOrganizationsAPI) ListRootsRequest(arg0 *organizations.ListRootsInput) (*request.Request, *organizations.ListRootsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRootsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListRootsOutput)
	return ret0, ret1
}

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

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

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

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

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

// ListTagsForResourcePages mocks base method.
func (m *MockOrganizationsAPI) ListTagsForResourcePages(arg0 *organizations.ListTagsForResourceInput, arg1 func(*organizations.ListTagsForResourceOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResourcePages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTagsForResourcePagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListTagsForResourcePagesWithContext(arg0 context.Context, arg1 *organizations.ListTagsForResourceInput, arg2 func(*organizations.ListTagsForResourceOutput, 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, "ListTagsForResourcePagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// ListTargetsForPolicy mocks base method.
func (m *MockOrganizationsAPI) ListTargetsForPolicy(arg0 *organizations.ListTargetsForPolicyInput) (*organizations.ListTargetsForPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTargetsForPolicy", arg0)
	ret0, _ := ret[0].(*organizations.ListTargetsForPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTargetsForPolicyPages mocks base method.
func (m *MockOrganizationsAPI) ListTargetsForPolicyPages(arg0 *organizations.ListTargetsForPolicyInput, arg1 func(*organizations.ListTargetsForPolicyOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTargetsForPolicyPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTargetsForPolicyPagesWithContext mocks base method.
func (m *MockOrganizationsAPI) ListTargetsForPolicyPagesWithContext(arg0 context.Context, arg1 *organizations.ListTargetsForPolicyInput, arg2 func(*organizations.ListTargetsForPolicyOutput, 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, "ListTargetsForPolicyPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTargetsForPolicyRequest mocks base method.
func (m *MockOrganizationsAPI) ListTargetsForPolicyRequest(arg0 *organizations.ListTargetsForPolicyInput) (*request.Request, *organizations.ListTargetsForPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTargetsForPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.ListTargetsForPolicyOutput)
	return ret0, ret1
}

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

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

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

// MoveAccount mocks base method.
func (m *MockOrganizationsAPI) MoveAccount(arg0 *organizations.MoveAccountInput) (*organizations.MoveAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MoveAccount", arg0)
	ret0, _ := ret[0].(*organizations.MoveAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MoveAccountRequest mocks base method.
func (m *MockOrganizationsAPI) MoveAccountRequest(arg0 *organizations.MoveAccountInput) (*request.Request, *organizations.MoveAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MoveAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.MoveAccountOutput)
	return ret0, ret1
}

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

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

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

// PutResourcePolicy mocks base method.
func (m *MockOrganizationsAPI) PutResourcePolicy(arg0 *organizations.PutResourcePolicyInput) (*organizations.PutResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutResourcePolicy", arg0)
	ret0, _ := ret[0].(*organizations.PutResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutResourcePolicyRequest mocks base method.
func (m *MockOrganizationsAPI) PutResourcePolicyRequest(arg0 *organizations.PutResourcePolicyInput) (*request.Request, *organizations.PutResourcePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutResourcePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.PutResourcePolicyOutput)
	return ret0, ret1
}

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

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

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

// RegisterDelegatedAdministrator mocks base method.
func (m *MockOrganizationsAPI) RegisterDelegatedAdministrator(arg0 *organizations.RegisterDelegatedAdministratorInput) (*organizations.RegisterDelegatedAdministratorOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterDelegatedAdministrator", arg0)
	ret0, _ := ret[0].(*organizations.RegisterDelegatedAdministratorOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterDelegatedAdministratorRequest mocks base method.
func (m *MockOrganizationsAPI) RegisterDelegatedAdministratorRequest(arg0 *organizations.RegisterDelegatedAdministratorInput) (*request.Request, *organizations.RegisterDelegatedAdministratorOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterDelegatedAdministratorRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.RegisterDelegatedAdministratorOutput)
	return ret0, ret1
}

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

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

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

// RemoveAccountFromOrganization mocks base method.
func (m *MockOrganizationsAPI) RemoveAccountFromOrganization(arg0 *organizations.RemoveAccountFromOrganizationInput) (*organizations.RemoveAccountFromOrganizationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveAccountFromOrganization", arg0)
	ret0, _ := ret[0].(*organizations.RemoveAccountFromOrganizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveAccountFromOrganizationRequest mocks base method.
func (m *MockOrganizationsAPI) RemoveAccountFromOrganizationRequest(arg0 *organizations.RemoveAccountFromOrganizationInput) (*request.Request, *organizations.RemoveAccountFromOrganizationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveAccountFromOrganizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.RemoveAccountFromOrganizationOutput)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UpdateOrganizationalUnit mocks base method.
func (m *MockOrganizationsAPI) UpdateOrganizationalUnit(arg0 *organizations.UpdateOrganizationalUnitInput) (*organizations.UpdateOrganizationalUnitOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOrganizationalUnit", arg0)
	ret0, _ := ret[0].(*organizations.UpdateOrganizationalUnitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateOrganizationalUnitRequest mocks base method.
func (m *MockOrganizationsAPI) UpdateOrganizationalUnitRequest(arg0 *organizations.UpdateOrganizationalUnitInput) (*request.Request, *organizations.UpdateOrganizationalUnitOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOrganizationalUnitRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.UpdateOrganizationalUnitOutput)
	return ret0, ret1
}

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

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

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

// UpdatePolicy mocks base method.
func (m *MockOrganizationsAPI) UpdatePolicy(arg0 *organizations.UpdatePolicyInput) (*organizations.UpdatePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePolicy", arg0)
	ret0, _ := ret[0].(*organizations.UpdatePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePolicyRequest mocks base method.
func (m *MockOrganizationsAPI) UpdatePolicyRequest(arg0 *organizations.UpdatePolicyInput) (*request.Request, *organizations.UpdatePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*organizations.UpdatePolicyOutput)
	return ret0, ret1
}

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

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

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