// Automatically generated by MockGen. DO NOT EDIT!
// Source: github.com/aws/aws-sdk-go/service/kinesis/kinesisiface (interfaces: KinesisAPI)

package mock_kinesisiface

import (
	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	kinesis "github.com/aws/aws-sdk-go/service/kinesis"
	gomock "github.com/golang/mock/gomock"
)

// Mock of KinesisAPI interface
type MockKinesisAPI struct {
	ctrl     *gomock.Controller
	recorder *_MockKinesisAPIRecorder
}

// Recorder for MockKinesisAPI (not exported)
type _MockKinesisAPIRecorder struct {
	mock *MockKinesisAPI
}

func NewMockKinesisAPI(ctrl *gomock.Controller) *MockKinesisAPI {
	mock := &MockKinesisAPI{ctrl: ctrl}
	mock.recorder = &_MockKinesisAPIRecorder{mock}
	return mock
}

func (_m *MockKinesisAPI) EXPECT() *_MockKinesisAPIRecorder {
	return _m.recorder
}

func (_m *MockKinesisAPI) AddTagsToStream(_param0 *kinesis.AddTagsToStreamInput) (*kinesis.AddTagsToStreamOutput, error) {
	ret := _m.ctrl.Call(_m, "AddTagsToStream", _param0)
	ret0, _ := ret[0].(*kinesis.AddTagsToStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) AddTagsToStream(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddTagsToStream", arg0)
}

func (_m *MockKinesisAPI) AddTagsToStreamRequest(_param0 *kinesis.AddTagsToStreamInput) (*request.Request, *kinesis.AddTagsToStreamOutput) {
	ret := _m.ctrl.Call(_m, "AddTagsToStreamRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.AddTagsToStreamOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) AddTagsToStreamRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddTagsToStreamRequest", arg0)
}

func (_m *MockKinesisAPI) AddTagsToStreamWithContext(_param0 aws.Context, _param1 *kinesis.AddTagsToStreamInput, _param2 ...request.Option) (*kinesis.AddTagsToStreamOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "AddTagsToStreamWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.AddTagsToStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) AddTagsToStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddTagsToStreamWithContext", _s...)
}

func (_m *MockKinesisAPI) CreateStream(_param0 *kinesis.CreateStreamInput) (*kinesis.CreateStreamOutput, error) {
	ret := _m.ctrl.Call(_m, "CreateStream", _param0)
	ret0, _ := ret[0].(*kinesis.CreateStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) CreateStream(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateStream", arg0)
}

func (_m *MockKinesisAPI) CreateStreamRequest(_param0 *kinesis.CreateStreamInput) (*request.Request, *kinesis.CreateStreamOutput) {
	ret := _m.ctrl.Call(_m, "CreateStreamRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.CreateStreamOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) CreateStreamRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateStreamRequest", arg0)
}

func (_m *MockKinesisAPI) CreateStreamWithContext(_param0 aws.Context, _param1 *kinesis.CreateStreamInput, _param2 ...request.Option) (*kinesis.CreateStreamOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "CreateStreamWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.CreateStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) CreateStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateStreamWithContext", _s...)
}

func (_m *MockKinesisAPI) DecreaseStreamRetentionPeriod(_param0 *kinesis.DecreaseStreamRetentionPeriodInput) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) {
	ret := _m.ctrl.Call(_m, "DecreaseStreamRetentionPeriod", _param0)
	ret0, _ := ret[0].(*kinesis.DecreaseStreamRetentionPeriodOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DecreaseStreamRetentionPeriod(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DecreaseStreamRetentionPeriod", arg0)
}

func (_m *MockKinesisAPI) DecreaseStreamRetentionPeriodRequest(_param0 *kinesis.DecreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.DecreaseStreamRetentionPeriodOutput) {
	ret := _m.ctrl.Call(_m, "DecreaseStreamRetentionPeriodRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DecreaseStreamRetentionPeriodOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DecreaseStreamRetentionPeriodRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DecreaseStreamRetentionPeriodRequest", arg0)
}

func (_m *MockKinesisAPI) DecreaseStreamRetentionPeriodWithContext(_param0 aws.Context, _param1 *kinesis.DecreaseStreamRetentionPeriodInput, _param2 ...request.Option) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DecreaseStreamRetentionPeriodWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.DecreaseStreamRetentionPeriodOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DecreaseStreamRetentionPeriodWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DecreaseStreamRetentionPeriodWithContext", _s...)
}

func (_m *MockKinesisAPI) DeleteStream(_param0 *kinesis.DeleteStreamInput) (*kinesis.DeleteStreamOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteStream", _param0)
	ret0, _ := ret[0].(*kinesis.DeleteStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DeleteStream(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteStream", arg0)
}

func (_m *MockKinesisAPI) DeleteStreamRequest(_param0 *kinesis.DeleteStreamInput) (*request.Request, *kinesis.DeleteStreamOutput) {
	ret := _m.ctrl.Call(_m, "DeleteStreamRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DeleteStreamOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DeleteStreamRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteStreamRequest", arg0)
}

func (_m *MockKinesisAPI) DeleteStreamWithContext(_param0 aws.Context, _param1 *kinesis.DeleteStreamInput, _param2 ...request.Option) (*kinesis.DeleteStreamOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteStreamWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.DeleteStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DeleteStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteStreamWithContext", _s...)
}

func (_m *MockKinesisAPI) DescribeLimits(_param0 *kinesis.DescribeLimitsInput) (*kinesis.DescribeLimitsOutput, error) {
	ret := _m.ctrl.Call(_m, "DescribeLimits", _param0)
	ret0, _ := ret[0].(*kinesis.DescribeLimitsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DescribeLimits(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeLimits", arg0)
}

func (_m *MockKinesisAPI) DescribeLimitsRequest(_param0 *kinesis.DescribeLimitsInput) (*request.Request, *kinesis.DescribeLimitsOutput) {
	ret := _m.ctrl.Call(_m, "DescribeLimitsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DescribeLimitsOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DescribeLimitsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeLimitsRequest", arg0)
}

func (_m *MockKinesisAPI) DescribeLimitsWithContext(_param0 aws.Context, _param1 *kinesis.DescribeLimitsInput, _param2 ...request.Option) (*kinesis.DescribeLimitsOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DescribeLimitsWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.DescribeLimitsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DescribeLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeLimitsWithContext", _s...)
}

func (_m *MockKinesisAPI) DescribeStream(_param0 *kinesis.DescribeStreamInput) (*kinesis.DescribeStreamOutput, error) {
	ret := _m.ctrl.Call(_m, "DescribeStream", _param0)
	ret0, _ := ret[0].(*kinesis.DescribeStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DescribeStream(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeStream", arg0)
}

func (_m *MockKinesisAPI) DescribeStreamPages(_param0 *kinesis.DescribeStreamInput, _param1 func(*kinesis.DescribeStreamOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "DescribeStreamPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockKinesisAPIRecorder) DescribeStreamPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeStreamPages", arg0, arg1)
}

func (_m *MockKinesisAPI) DescribeStreamPagesWithContext(_param0 aws.Context, _param1 *kinesis.DescribeStreamInput, _param2 func(*kinesis.DescribeStreamOutput, bool) bool, _param3 ...request.Option) error {
	_s := []interface{}{_param0, _param1, _param2}
	for _, _x := range _param3 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DescribeStreamPagesWithContext", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockKinesisAPIRecorder) DescribeStreamPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeStreamPagesWithContext", _s...)
}

func (_m *MockKinesisAPI) DescribeStreamRequest(_param0 *kinesis.DescribeStreamInput) (*request.Request, *kinesis.DescribeStreamOutput) {
	ret := _m.ctrl.Call(_m, "DescribeStreamRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DescribeStreamOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DescribeStreamRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeStreamRequest", arg0)
}

func (_m *MockKinesisAPI) DescribeStreamWithContext(_param0 aws.Context, _param1 *kinesis.DescribeStreamInput, _param2 ...request.Option) (*kinesis.DescribeStreamOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DescribeStreamWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.DescribeStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DescribeStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeStreamWithContext", _s...)
}

func (_m *MockKinesisAPI) DisableEnhancedMonitoring(_param0 *kinesis.DisableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) {
	ret := _m.ctrl.Call(_m, "DisableEnhancedMonitoring", _param0)
	ret0, _ := ret[0].(*kinesis.EnhancedMonitoringOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DisableEnhancedMonitoring(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableEnhancedMonitoring", arg0)
}

func (_m *MockKinesisAPI) DisableEnhancedMonitoringRequest(_param0 *kinesis.DisableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) {
	ret := _m.ctrl.Call(_m, "DisableEnhancedMonitoringRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.EnhancedMonitoringOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DisableEnhancedMonitoringRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableEnhancedMonitoringRequest", arg0)
}

func (_m *MockKinesisAPI) DisableEnhancedMonitoringWithContext(_param0 aws.Context, _param1 *kinesis.DisableEnhancedMonitoringInput, _param2 ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DisableEnhancedMonitoringWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.EnhancedMonitoringOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) DisableEnhancedMonitoringWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DisableEnhancedMonitoringWithContext", _s...)
}

func (_m *MockKinesisAPI) EnableEnhancedMonitoring(_param0 *kinesis.EnableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) {
	ret := _m.ctrl.Call(_m, "EnableEnhancedMonitoring", _param0)
	ret0, _ := ret[0].(*kinesis.EnhancedMonitoringOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) EnableEnhancedMonitoring(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "EnableEnhancedMonitoring", arg0)
}

func (_m *MockKinesisAPI) EnableEnhancedMonitoringRequest(_param0 *kinesis.EnableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) {
	ret := _m.ctrl.Call(_m, "EnableEnhancedMonitoringRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.EnhancedMonitoringOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) EnableEnhancedMonitoringRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "EnableEnhancedMonitoringRequest", arg0)
}

func (_m *MockKinesisAPI) EnableEnhancedMonitoringWithContext(_param0 aws.Context, _param1 *kinesis.EnableEnhancedMonitoringInput, _param2 ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "EnableEnhancedMonitoringWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.EnhancedMonitoringOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) EnableEnhancedMonitoringWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "EnableEnhancedMonitoringWithContext", _s...)
}

func (_m *MockKinesisAPI) GetRecords(_param0 *kinesis.GetRecordsInput) (*kinesis.GetRecordsOutput, error) {
	ret := _m.ctrl.Call(_m, "GetRecords", _param0)
	ret0, _ := ret[0].(*kinesis.GetRecordsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) GetRecords(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetRecords", arg0)
}

func (_m *MockKinesisAPI) GetRecordsRequest(_param0 *kinesis.GetRecordsInput) (*request.Request, *kinesis.GetRecordsOutput) {
	ret := _m.ctrl.Call(_m, "GetRecordsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.GetRecordsOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) GetRecordsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetRecordsRequest", arg0)
}

func (_m *MockKinesisAPI) GetRecordsWithContext(_param0 aws.Context, _param1 *kinesis.GetRecordsInput, _param2 ...request.Option) (*kinesis.GetRecordsOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "GetRecordsWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.GetRecordsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) GetRecordsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetRecordsWithContext", _s...)
}

func (_m *MockKinesisAPI) GetShardIterator(_param0 *kinesis.GetShardIteratorInput) (*kinesis.GetShardIteratorOutput, error) {
	ret := _m.ctrl.Call(_m, "GetShardIterator", _param0)
	ret0, _ := ret[0].(*kinesis.GetShardIteratorOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) GetShardIterator(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetShardIterator", arg0)
}

func (_m *MockKinesisAPI) GetShardIteratorRequest(_param0 *kinesis.GetShardIteratorInput) (*request.Request, *kinesis.GetShardIteratorOutput) {
	ret := _m.ctrl.Call(_m, "GetShardIteratorRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.GetShardIteratorOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) GetShardIteratorRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetShardIteratorRequest", arg0)
}

func (_m *MockKinesisAPI) GetShardIteratorWithContext(_param0 aws.Context, _param1 *kinesis.GetShardIteratorInput, _param2 ...request.Option) (*kinesis.GetShardIteratorOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "GetShardIteratorWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.GetShardIteratorOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) GetShardIteratorWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetShardIteratorWithContext", _s...)
}

func (_m *MockKinesisAPI) IncreaseStreamRetentionPeriod(_param0 *kinesis.IncreaseStreamRetentionPeriodInput) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) {
	ret := _m.ctrl.Call(_m, "IncreaseStreamRetentionPeriod", _param0)
	ret0, _ := ret[0].(*kinesis.IncreaseStreamRetentionPeriodOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) IncreaseStreamRetentionPeriod(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "IncreaseStreamRetentionPeriod", arg0)
}

func (_m *MockKinesisAPI) IncreaseStreamRetentionPeriodRequest(_param0 *kinesis.IncreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.IncreaseStreamRetentionPeriodOutput) {
	ret := _m.ctrl.Call(_m, "IncreaseStreamRetentionPeriodRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.IncreaseStreamRetentionPeriodOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) IncreaseStreamRetentionPeriodRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "IncreaseStreamRetentionPeriodRequest", arg0)
}

func (_m *MockKinesisAPI) IncreaseStreamRetentionPeriodWithContext(_param0 aws.Context, _param1 *kinesis.IncreaseStreamRetentionPeriodInput, _param2 ...request.Option) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "IncreaseStreamRetentionPeriodWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.IncreaseStreamRetentionPeriodOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) IncreaseStreamRetentionPeriodWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "IncreaseStreamRetentionPeriodWithContext", _s...)
}

func (_m *MockKinesisAPI) ListStreams(_param0 *kinesis.ListStreamsInput) (*kinesis.ListStreamsOutput, error) {
	ret := _m.ctrl.Call(_m, "ListStreams", _param0)
	ret0, _ := ret[0].(*kinesis.ListStreamsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) ListStreams(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListStreams", arg0)
}

func (_m *MockKinesisAPI) ListStreamsPages(_param0 *kinesis.ListStreamsInput, _param1 func(*kinesis.ListStreamsOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "ListStreamsPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockKinesisAPIRecorder) ListStreamsPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListStreamsPages", arg0, arg1)
}

func (_m *MockKinesisAPI) ListStreamsPagesWithContext(_param0 aws.Context, _param1 *kinesis.ListStreamsInput, _param2 func(*kinesis.ListStreamsOutput, bool) bool, _param3 ...request.Option) error {
	_s := []interface{}{_param0, _param1, _param2}
	for _, _x := range _param3 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ListStreamsPagesWithContext", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockKinesisAPIRecorder) ListStreamsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListStreamsPagesWithContext", _s...)
}

func (_m *MockKinesisAPI) ListStreamsRequest(_param0 *kinesis.ListStreamsInput) (*request.Request, *kinesis.ListStreamsOutput) {
	ret := _m.ctrl.Call(_m, "ListStreamsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.ListStreamsOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) ListStreamsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListStreamsRequest", arg0)
}

func (_m *MockKinesisAPI) ListStreamsWithContext(_param0 aws.Context, _param1 *kinesis.ListStreamsInput, _param2 ...request.Option) (*kinesis.ListStreamsOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ListStreamsWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.ListStreamsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) ListStreamsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListStreamsWithContext", _s...)
}

func (_m *MockKinesisAPI) ListTagsForStream(_param0 *kinesis.ListTagsForStreamInput) (*kinesis.ListTagsForStreamOutput, error) {
	ret := _m.ctrl.Call(_m, "ListTagsForStream", _param0)
	ret0, _ := ret[0].(*kinesis.ListTagsForStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) ListTagsForStream(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTagsForStream", arg0)
}

func (_m *MockKinesisAPI) ListTagsForStreamRequest(_param0 *kinesis.ListTagsForStreamInput) (*request.Request, *kinesis.ListTagsForStreamOutput) {
	ret := _m.ctrl.Call(_m, "ListTagsForStreamRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.ListTagsForStreamOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) ListTagsForStreamRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTagsForStreamRequest", arg0)
}

func (_m *MockKinesisAPI) ListTagsForStreamWithContext(_param0 aws.Context, _param1 *kinesis.ListTagsForStreamInput, _param2 ...request.Option) (*kinesis.ListTagsForStreamOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ListTagsForStreamWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.ListTagsForStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) ListTagsForStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTagsForStreamWithContext", _s...)
}

func (_m *MockKinesisAPI) MergeShards(_param0 *kinesis.MergeShardsInput) (*kinesis.MergeShardsOutput, error) {
	ret := _m.ctrl.Call(_m, "MergeShards", _param0)
	ret0, _ := ret[0].(*kinesis.MergeShardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) MergeShards(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "MergeShards", arg0)
}

func (_m *MockKinesisAPI) MergeShardsRequest(_param0 *kinesis.MergeShardsInput) (*request.Request, *kinesis.MergeShardsOutput) {
	ret := _m.ctrl.Call(_m, "MergeShardsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.MergeShardsOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) MergeShardsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "MergeShardsRequest", arg0)
}

func (_m *MockKinesisAPI) MergeShardsWithContext(_param0 aws.Context, _param1 *kinesis.MergeShardsInput, _param2 ...request.Option) (*kinesis.MergeShardsOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "MergeShardsWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.MergeShardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) MergeShardsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "MergeShardsWithContext", _s...)
}

func (_m *MockKinesisAPI) PutRecord(_param0 *kinesis.PutRecordInput) (*kinesis.PutRecordOutput, error) {
	ret := _m.ctrl.Call(_m, "PutRecord", _param0)
	ret0, _ := ret[0].(*kinesis.PutRecordOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) PutRecord(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutRecord", arg0)
}

func (_m *MockKinesisAPI) PutRecordRequest(_param0 *kinesis.PutRecordInput) (*request.Request, *kinesis.PutRecordOutput) {
	ret := _m.ctrl.Call(_m, "PutRecordRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.PutRecordOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) PutRecordRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutRecordRequest", arg0)
}

func (_m *MockKinesisAPI) PutRecordWithContext(_param0 aws.Context, _param1 *kinesis.PutRecordInput, _param2 ...request.Option) (*kinesis.PutRecordOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "PutRecordWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.PutRecordOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) PutRecordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutRecordWithContext", _s...)
}

func (_m *MockKinesisAPI) PutRecords(_param0 *kinesis.PutRecordsInput) (*kinesis.PutRecordsOutput, error) {
	ret := _m.ctrl.Call(_m, "PutRecords", _param0)
	ret0, _ := ret[0].(*kinesis.PutRecordsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) PutRecords(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutRecords", arg0)
}

func (_m *MockKinesisAPI) PutRecordsRequest(_param0 *kinesis.PutRecordsInput) (*request.Request, *kinesis.PutRecordsOutput) {
	ret := _m.ctrl.Call(_m, "PutRecordsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.PutRecordsOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) PutRecordsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutRecordsRequest", arg0)
}

func (_m *MockKinesisAPI) PutRecordsWithContext(_param0 aws.Context, _param1 *kinesis.PutRecordsInput, _param2 ...request.Option) (*kinesis.PutRecordsOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "PutRecordsWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.PutRecordsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) PutRecordsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutRecordsWithContext", _s...)
}

func (_m *MockKinesisAPI) RemoveTagsFromStream(_param0 *kinesis.RemoveTagsFromStreamInput) (*kinesis.RemoveTagsFromStreamOutput, error) {
	ret := _m.ctrl.Call(_m, "RemoveTagsFromStream", _param0)
	ret0, _ := ret[0].(*kinesis.RemoveTagsFromStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) RemoveTagsFromStream(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveTagsFromStream", arg0)
}

func (_m *MockKinesisAPI) RemoveTagsFromStreamRequest(_param0 *kinesis.RemoveTagsFromStreamInput) (*request.Request, *kinesis.RemoveTagsFromStreamOutput) {
	ret := _m.ctrl.Call(_m, "RemoveTagsFromStreamRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.RemoveTagsFromStreamOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) RemoveTagsFromStreamRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveTagsFromStreamRequest", arg0)
}

func (_m *MockKinesisAPI) RemoveTagsFromStreamWithContext(_param0 aws.Context, _param1 *kinesis.RemoveTagsFromStreamInput, _param2 ...request.Option) (*kinesis.RemoveTagsFromStreamOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "RemoveTagsFromStreamWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.RemoveTagsFromStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) RemoveTagsFromStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveTagsFromStreamWithContext", _s...)
}

func (_m *MockKinesisAPI) SplitShard(_param0 *kinesis.SplitShardInput) (*kinesis.SplitShardOutput, error) {
	ret := _m.ctrl.Call(_m, "SplitShard", _param0)
	ret0, _ := ret[0].(*kinesis.SplitShardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) SplitShard(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SplitShard", arg0)
}

func (_m *MockKinesisAPI) SplitShardRequest(_param0 *kinesis.SplitShardInput) (*request.Request, *kinesis.SplitShardOutput) {
	ret := _m.ctrl.Call(_m, "SplitShardRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.SplitShardOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) SplitShardRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SplitShardRequest", arg0)
}

func (_m *MockKinesisAPI) SplitShardWithContext(_param0 aws.Context, _param1 *kinesis.SplitShardInput, _param2 ...request.Option) (*kinesis.SplitShardOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "SplitShardWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.SplitShardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) SplitShardWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SplitShardWithContext", _s...)
}

func (_m *MockKinesisAPI) UpdateShardCount(_param0 *kinesis.UpdateShardCountInput) (*kinesis.UpdateShardCountOutput, error) {
	ret := _m.ctrl.Call(_m, "UpdateShardCount", _param0)
	ret0, _ := ret[0].(*kinesis.UpdateShardCountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) UpdateShardCount(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateShardCount", arg0)
}

func (_m *MockKinesisAPI) UpdateShardCountRequest(_param0 *kinesis.UpdateShardCountInput) (*request.Request, *kinesis.UpdateShardCountOutput) {
	ret := _m.ctrl.Call(_m, "UpdateShardCountRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.UpdateShardCountOutput)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) UpdateShardCountRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateShardCountRequest", arg0)
}

func (_m *MockKinesisAPI) UpdateShardCountWithContext(_param0 aws.Context, _param1 *kinesis.UpdateShardCountInput, _param2 ...request.Option) (*kinesis.UpdateShardCountOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "UpdateShardCountWithContext", _s...)
	ret0, _ := ret[0].(*kinesis.UpdateShardCountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKinesisAPIRecorder) UpdateShardCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateShardCountWithContext", _s...)
}

func (_m *MockKinesisAPI) WaitUntilStreamExists(_param0 *kinesis.DescribeStreamInput) error {
	ret := _m.ctrl.Call(_m, "WaitUntilStreamExists", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockKinesisAPIRecorder) WaitUntilStreamExists(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WaitUntilStreamExists", arg0)
}

func (_m *MockKinesisAPI) WaitUntilStreamExistsWithContext(_param0 aws.Context, _param1 *kinesis.DescribeStreamInput, _param2 ...request.WaiterOption) error {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "WaitUntilStreamExistsWithContext", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockKinesisAPIRecorder) WaitUntilStreamExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WaitUntilStreamExistsWithContext", _s...)
}

func (_m *MockKinesisAPI) WaitUntilStreamNotExists(_param0 *kinesis.DescribeStreamInput) error {
	ret := _m.ctrl.Call(_m, "WaitUntilStreamNotExists", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockKinesisAPIRecorder) WaitUntilStreamNotExists(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WaitUntilStreamNotExists", arg0)
}

func (_m *MockKinesisAPI) WaitUntilStreamNotExistsWithContext(_param0 aws.Context, _param1 *kinesis.DescribeStreamInput, _param2 ...request.WaiterOption) error {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "WaitUntilStreamNotExistsWithContext", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockKinesisAPIRecorder) WaitUntilStreamNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "WaitUntilStreamNotExistsWithContext", _s...)
}
