// Code generated by mockery v2.52.3. DO NOT EDIT.

package textractmock

import (
	context "context"

	mock "github.com/stretchr/testify/mock"

	textract "github.com/aws/aws-sdk-go-v2/service/textract"
)

// MockTextractClient is an autogenerated mock type for the TextractClient type
type MockTextractClient struct {
	mock.Mock
}

type MockTextractClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTextractClient) EXPECT() *MockTextractClient_Expecter {
	return &MockTextractClient_Expecter{mock: &_m.Mock}
}

// AnalyzeDocument provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) AnalyzeDocument(ctx context.Context, params *textract.AnalyzeDocumentInput, opts ...func(*textract.Options)) (*textract.AnalyzeDocumentOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AnalyzeDocument")
	}

	var r0 *textract.AnalyzeDocumentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeDocumentInput, ...func(*textract.Options)) (*textract.AnalyzeDocumentOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeDocumentInput, ...func(*textract.Options)) *textract.AnalyzeDocumentOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.AnalyzeDocumentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.AnalyzeDocumentInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_AnalyzeDocument_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnalyzeDocument'
type MockTextractClient_AnalyzeDocument_Call struct {
	*mock.Call
}

// AnalyzeDocument is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.AnalyzeDocumentInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) AnalyzeDocument(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_AnalyzeDocument_Call {
	return &MockTextractClient_AnalyzeDocument_Call{Call: _e.mock.On("AnalyzeDocument",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_AnalyzeDocument_Call) Run(run func(ctx context.Context, params *textract.AnalyzeDocumentInput, opts ...func(*textract.Options))) *MockTextractClient_AnalyzeDocument_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.AnalyzeDocumentInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_AnalyzeDocument_Call) Return(_a0 *textract.AnalyzeDocumentOutput, _a1 error) *MockTextractClient_AnalyzeDocument_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_AnalyzeDocument_Call) RunAndReturn(run func(context.Context, *textract.AnalyzeDocumentInput, ...func(*textract.Options)) (*textract.AnalyzeDocumentOutput, error)) *MockTextractClient_AnalyzeDocument_Call {
	_c.Call.Return(run)
	return _c
}

// AnalyzeExpense provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) AnalyzeExpense(ctx context.Context, params *textract.AnalyzeExpenseInput, opts ...func(*textract.Options)) (*textract.AnalyzeExpenseOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AnalyzeExpense")
	}

	var r0 *textract.AnalyzeExpenseOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeExpenseInput, ...func(*textract.Options)) (*textract.AnalyzeExpenseOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeExpenseInput, ...func(*textract.Options)) *textract.AnalyzeExpenseOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.AnalyzeExpenseOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.AnalyzeExpenseInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_AnalyzeExpense_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnalyzeExpense'
type MockTextractClient_AnalyzeExpense_Call struct {
	*mock.Call
}

// AnalyzeExpense is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.AnalyzeExpenseInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) AnalyzeExpense(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_AnalyzeExpense_Call {
	return &MockTextractClient_AnalyzeExpense_Call{Call: _e.mock.On("AnalyzeExpense",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_AnalyzeExpense_Call) Run(run func(ctx context.Context, params *textract.AnalyzeExpenseInput, opts ...func(*textract.Options))) *MockTextractClient_AnalyzeExpense_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.AnalyzeExpenseInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_AnalyzeExpense_Call) Return(_a0 *textract.AnalyzeExpenseOutput, _a1 error) *MockTextractClient_AnalyzeExpense_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_AnalyzeExpense_Call) RunAndReturn(run func(context.Context, *textract.AnalyzeExpenseInput, ...func(*textract.Options)) (*textract.AnalyzeExpenseOutput, error)) *MockTextractClient_AnalyzeExpense_Call {
	_c.Call.Return(run)
	return _c
}

// AnalyzeID provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) AnalyzeID(ctx context.Context, params *textract.AnalyzeIDInput, opts ...func(*textract.Options)) (*textract.AnalyzeIDOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AnalyzeID")
	}

	var r0 *textract.AnalyzeIDOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeIDInput, ...func(*textract.Options)) (*textract.AnalyzeIDOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeIDInput, ...func(*textract.Options)) *textract.AnalyzeIDOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.AnalyzeIDOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.AnalyzeIDInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_AnalyzeID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnalyzeID'
type MockTextractClient_AnalyzeID_Call struct {
	*mock.Call
}

// AnalyzeID is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.AnalyzeIDInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) AnalyzeID(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_AnalyzeID_Call {
	return &MockTextractClient_AnalyzeID_Call{Call: _e.mock.On("AnalyzeID",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_AnalyzeID_Call) Run(run func(ctx context.Context, params *textract.AnalyzeIDInput, opts ...func(*textract.Options))) *MockTextractClient_AnalyzeID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.AnalyzeIDInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_AnalyzeID_Call) Return(_a0 *textract.AnalyzeIDOutput, _a1 error) *MockTextractClient_AnalyzeID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_AnalyzeID_Call) RunAndReturn(run func(context.Context, *textract.AnalyzeIDInput, ...func(*textract.Options)) (*textract.AnalyzeIDOutput, error)) *MockTextractClient_AnalyzeID_Call {
	_c.Call.Return(run)
	return _c
}

// DetectDocumentText provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) DetectDocumentText(ctx context.Context, params *textract.DetectDocumentTextInput, opts ...func(*textract.Options)) (*textract.DetectDocumentTextOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetectDocumentText")
	}

	var r0 *textract.DetectDocumentTextOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.DetectDocumentTextInput, ...func(*textract.Options)) (*textract.DetectDocumentTextOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.DetectDocumentTextInput, ...func(*textract.Options)) *textract.DetectDocumentTextOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.DetectDocumentTextOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.DetectDocumentTextInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_DetectDocumentText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectDocumentText'
type MockTextractClient_DetectDocumentText_Call struct {
	*mock.Call
}

// DetectDocumentText is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.DetectDocumentTextInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) DetectDocumentText(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_DetectDocumentText_Call {
	return &MockTextractClient_DetectDocumentText_Call{Call: _e.mock.On("DetectDocumentText",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_DetectDocumentText_Call) Run(run func(ctx context.Context, params *textract.DetectDocumentTextInput, opts ...func(*textract.Options))) *MockTextractClient_DetectDocumentText_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.DetectDocumentTextInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_DetectDocumentText_Call) Return(_a0 *textract.DetectDocumentTextOutput, _a1 error) *MockTextractClient_DetectDocumentText_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_DetectDocumentText_Call) RunAndReturn(run func(context.Context, *textract.DetectDocumentTextInput, ...func(*textract.Options)) (*textract.DetectDocumentTextOutput, error)) *MockTextractClient_DetectDocumentText_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocumentAnalysis provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) GetDocumentAnalysis(ctx context.Context, params *textract.GetDocumentAnalysisInput, opts ...func(*textract.Options)) (*textract.GetDocumentAnalysisOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetDocumentAnalysis")
	}

	var r0 *textract.GetDocumentAnalysisOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.GetDocumentAnalysisInput, ...func(*textract.Options)) (*textract.GetDocumentAnalysisOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.GetDocumentAnalysisInput, ...func(*textract.Options)) *textract.GetDocumentAnalysisOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.GetDocumentAnalysisOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.GetDocumentAnalysisInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_GetDocumentAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDocumentAnalysis'
type MockTextractClient_GetDocumentAnalysis_Call struct {
	*mock.Call
}

// GetDocumentAnalysis is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.GetDocumentAnalysisInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) GetDocumentAnalysis(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_GetDocumentAnalysis_Call {
	return &MockTextractClient_GetDocumentAnalysis_Call{Call: _e.mock.On("GetDocumentAnalysis",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_GetDocumentAnalysis_Call) Run(run func(ctx context.Context, params *textract.GetDocumentAnalysisInput, opts ...func(*textract.Options))) *MockTextractClient_GetDocumentAnalysis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.GetDocumentAnalysisInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_GetDocumentAnalysis_Call) Return(_a0 *textract.GetDocumentAnalysisOutput, _a1 error) *MockTextractClient_GetDocumentAnalysis_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_GetDocumentAnalysis_Call) RunAndReturn(run func(context.Context, *textract.GetDocumentAnalysisInput, ...func(*textract.Options)) (*textract.GetDocumentAnalysisOutput, error)) *MockTextractClient_GetDocumentAnalysis_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocumentTextDetection provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) GetDocumentTextDetection(ctx context.Context, params *textract.GetDocumentTextDetectionInput, opts ...func(*textract.Options)) (*textract.GetDocumentTextDetectionOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetDocumentTextDetection")
	}

	var r0 *textract.GetDocumentTextDetectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.GetDocumentTextDetectionInput, ...func(*textract.Options)) (*textract.GetDocumentTextDetectionOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.GetDocumentTextDetectionInput, ...func(*textract.Options)) *textract.GetDocumentTextDetectionOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.GetDocumentTextDetectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.GetDocumentTextDetectionInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_GetDocumentTextDetection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDocumentTextDetection'
type MockTextractClient_GetDocumentTextDetection_Call struct {
	*mock.Call
}

// GetDocumentTextDetection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.GetDocumentTextDetectionInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) GetDocumentTextDetection(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_GetDocumentTextDetection_Call {
	return &MockTextractClient_GetDocumentTextDetection_Call{Call: _e.mock.On("GetDocumentTextDetection",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_GetDocumentTextDetection_Call) Run(run func(ctx context.Context, params *textract.GetDocumentTextDetectionInput, opts ...func(*textract.Options))) *MockTextractClient_GetDocumentTextDetection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.GetDocumentTextDetectionInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_GetDocumentTextDetection_Call) Return(_a0 *textract.GetDocumentTextDetectionOutput, _a1 error) *MockTextractClient_GetDocumentTextDetection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_GetDocumentTextDetection_Call) RunAndReturn(run func(context.Context, *textract.GetDocumentTextDetectionInput, ...func(*textract.Options)) (*textract.GetDocumentTextDetectionOutput, error)) *MockTextractClient_GetDocumentTextDetection_Call {
	_c.Call.Return(run)
	return _c
}

// GetExpenseAnalysis provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) GetExpenseAnalysis(ctx context.Context, params *textract.GetExpenseAnalysisInput, opts ...func(*textract.Options)) (*textract.GetExpenseAnalysisOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetExpenseAnalysis")
	}

	var r0 *textract.GetExpenseAnalysisOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.GetExpenseAnalysisInput, ...func(*textract.Options)) (*textract.GetExpenseAnalysisOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.GetExpenseAnalysisInput, ...func(*textract.Options)) *textract.GetExpenseAnalysisOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.GetExpenseAnalysisOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.GetExpenseAnalysisInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_GetExpenseAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExpenseAnalysis'
type MockTextractClient_GetExpenseAnalysis_Call struct {
	*mock.Call
}

// GetExpenseAnalysis is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.GetExpenseAnalysisInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) GetExpenseAnalysis(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_GetExpenseAnalysis_Call {
	return &MockTextractClient_GetExpenseAnalysis_Call{Call: _e.mock.On("GetExpenseAnalysis",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_GetExpenseAnalysis_Call) Run(run func(ctx context.Context, params *textract.GetExpenseAnalysisInput, opts ...func(*textract.Options))) *MockTextractClient_GetExpenseAnalysis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.GetExpenseAnalysisInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_GetExpenseAnalysis_Call) Return(_a0 *textract.GetExpenseAnalysisOutput, _a1 error) *MockTextractClient_GetExpenseAnalysis_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_GetExpenseAnalysis_Call) RunAndReturn(run func(context.Context, *textract.GetExpenseAnalysisInput, ...func(*textract.Options)) (*textract.GetExpenseAnalysisOutput, error)) *MockTextractClient_GetExpenseAnalysis_Call {
	_c.Call.Return(run)
	return _c
}

// StartDocumentAnalysis provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) StartDocumentAnalysis(ctx context.Context, params *textract.StartDocumentAnalysisInput, opts ...func(*textract.Options)) (*textract.StartDocumentAnalysisOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartDocumentAnalysis")
	}

	var r0 *textract.StartDocumentAnalysisOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.StartDocumentAnalysisInput, ...func(*textract.Options)) (*textract.StartDocumentAnalysisOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.StartDocumentAnalysisInput, ...func(*textract.Options)) *textract.StartDocumentAnalysisOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.StartDocumentAnalysisOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.StartDocumentAnalysisInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_StartDocumentAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartDocumentAnalysis'
type MockTextractClient_StartDocumentAnalysis_Call struct {
	*mock.Call
}

// StartDocumentAnalysis is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.StartDocumentAnalysisInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) StartDocumentAnalysis(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_StartDocumentAnalysis_Call {
	return &MockTextractClient_StartDocumentAnalysis_Call{Call: _e.mock.On("StartDocumentAnalysis",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_StartDocumentAnalysis_Call) Run(run func(ctx context.Context, params *textract.StartDocumentAnalysisInput, opts ...func(*textract.Options))) *MockTextractClient_StartDocumentAnalysis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.StartDocumentAnalysisInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_StartDocumentAnalysis_Call) Return(_a0 *textract.StartDocumentAnalysisOutput, _a1 error) *MockTextractClient_StartDocumentAnalysis_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_StartDocumentAnalysis_Call) RunAndReturn(run func(context.Context, *textract.StartDocumentAnalysisInput, ...func(*textract.Options)) (*textract.StartDocumentAnalysisOutput, error)) *MockTextractClient_StartDocumentAnalysis_Call {
	_c.Call.Return(run)
	return _c
}

// StartDocumentTextDetection provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) StartDocumentTextDetection(ctx context.Context, params *textract.StartDocumentTextDetectionInput, opts ...func(*textract.Options)) (*textract.StartDocumentTextDetectionOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartDocumentTextDetection")
	}

	var r0 *textract.StartDocumentTextDetectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.StartDocumentTextDetectionInput, ...func(*textract.Options)) (*textract.StartDocumentTextDetectionOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.StartDocumentTextDetectionInput, ...func(*textract.Options)) *textract.StartDocumentTextDetectionOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.StartDocumentTextDetectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.StartDocumentTextDetectionInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_StartDocumentTextDetection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartDocumentTextDetection'
type MockTextractClient_StartDocumentTextDetection_Call struct {
	*mock.Call
}

// StartDocumentTextDetection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.StartDocumentTextDetectionInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) StartDocumentTextDetection(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_StartDocumentTextDetection_Call {
	return &MockTextractClient_StartDocumentTextDetection_Call{Call: _e.mock.On("StartDocumentTextDetection",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_StartDocumentTextDetection_Call) Run(run func(ctx context.Context, params *textract.StartDocumentTextDetectionInput, opts ...func(*textract.Options))) *MockTextractClient_StartDocumentTextDetection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.StartDocumentTextDetectionInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_StartDocumentTextDetection_Call) Return(_a0 *textract.StartDocumentTextDetectionOutput, _a1 error) *MockTextractClient_StartDocumentTextDetection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_StartDocumentTextDetection_Call) RunAndReturn(run func(context.Context, *textract.StartDocumentTextDetectionInput, ...func(*textract.Options)) (*textract.StartDocumentTextDetectionOutput, error)) *MockTextractClient_StartDocumentTextDetection_Call {
	_c.Call.Return(run)
	return _c
}

// StartExpenseAnalysis provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) StartExpenseAnalysis(ctx context.Context, params *textract.StartExpenseAnalysisInput, opts ...func(*textract.Options)) (*textract.StartExpenseAnalysisOutput, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartExpenseAnalysis")
	}

	var r0 *textract.StartExpenseAnalysisOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *textract.StartExpenseAnalysisInput, ...func(*textract.Options)) (*textract.StartExpenseAnalysisOutput, error)); ok {
		return rf(ctx, params, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *textract.StartExpenseAnalysisInput, ...func(*textract.Options)) *textract.StartExpenseAnalysisOutput); ok {
		r0 = rf(ctx, params, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*textract.StartExpenseAnalysisOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *textract.StartExpenseAnalysisInput, ...func(*textract.Options)) error); ok {
		r1 = rf(ctx, params, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTextractClient_StartExpenseAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartExpenseAnalysis'
type MockTextractClient_StartExpenseAnalysis_Call struct {
	*mock.Call
}

// StartExpenseAnalysis is a helper method to define mock.On call
//   - ctx context.Context
//   - params *textract.StartExpenseAnalysisInput
//   - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) StartExpenseAnalysis(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_StartExpenseAnalysis_Call {
	return &MockTextractClient_StartExpenseAnalysis_Call{Call: _e.mock.On("StartExpenseAnalysis",
		append([]interface{}{ctx, params}, opts...)...)}
}

func (_c *MockTextractClient_StartExpenseAnalysis_Call) Run(run func(ctx context.Context, params *textract.StartExpenseAnalysisInput, opts ...func(*textract.Options))) *MockTextractClient_StartExpenseAnalysis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*textract.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*textract.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*textract.StartExpenseAnalysisInput), variadicArgs...)
	})
	return _c
}

func (_c *MockTextractClient_StartExpenseAnalysis_Call) Return(_a0 *textract.StartExpenseAnalysisOutput, _a1 error) *MockTextractClient_StartExpenseAnalysis_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTextractClient_StartExpenseAnalysis_Call) RunAndReturn(run func(context.Context, *textract.StartExpenseAnalysisInput, ...func(*textract.Options)) (*textract.StartExpenseAnalysisOutput, error)) *MockTextractClient_StartExpenseAnalysis_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockTextractClient creates a new instance of MockTextractClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockTextractClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTextractClient {
	mock := &MockTextractClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}