// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: MIT-0

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

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

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

// MockKinesisAPI is a mock of KinesisAPI interface
type MockKinesisAPI struct {
	ctrl     *gomock.Controller
	recorder *MockKinesisAPIMockRecorder
}

// MockKinesisAPIMockRecorder is the mock recorder for MockKinesisAPI
type MockKinesisAPIMockRecorder struct {
	mock *MockKinesisAPI
}

// NewMockKinesisAPI creates a new mock instance
func NewMockKinesisAPI(ctrl *gomock.Controller) *MockKinesisAPI {
	mock := &MockKinesisAPI{ctrl: ctrl}
	mock.recorder = &MockKinesisAPIMockRecorder{mock}
	return mock
}

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

// AddTagsToStream mocks base method
func (m *MockKinesisAPI) AddTagsToStream(arg0 *kinesis.AddTagsToStreamInput) (*kinesis.AddTagsToStreamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTagsToStream", arg0)
	ret0, _ := ret[0].(*kinesis.AddTagsToStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddTagsToStreamRequest mocks base method
func (m *MockKinesisAPI) AddTagsToStreamRequest(arg0 *kinesis.AddTagsToStreamInput) (*request.Request, *kinesis.AddTagsToStreamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTagsToStreamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.AddTagsToStreamOutput)
	return ret0, ret1
}

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

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

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

// CreateStream mocks base method
func (m *MockKinesisAPI) CreateStream(arg0 *kinesis.CreateStreamInput) (*kinesis.CreateStreamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStream", arg0)
	ret0, _ := ret[0].(*kinesis.CreateStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateStreamRequest mocks base method
func (m *MockKinesisAPI) CreateStreamRequest(arg0 *kinesis.CreateStreamInput) (*request.Request, *kinesis.CreateStreamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStreamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.CreateStreamOutput)
	return ret0, ret1
}

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

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

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

// DecreaseStreamRetentionPeriod mocks base method
func (m *MockKinesisAPI) DecreaseStreamRetentionPeriod(arg0 *kinesis.DecreaseStreamRetentionPeriodInput) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecreaseStreamRetentionPeriod", arg0)
	ret0, _ := ret[0].(*kinesis.DecreaseStreamRetentionPeriodOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DecreaseStreamRetentionPeriodRequest mocks base method
func (m *MockKinesisAPI) DecreaseStreamRetentionPeriodRequest(arg0 *kinesis.DecreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.DecreaseStreamRetentionPeriodOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecreaseStreamRetentionPeriodRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DecreaseStreamRetentionPeriodOutput)
	return ret0, ret1
}

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

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

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

// DeleteStream mocks base method
func (m *MockKinesisAPI) DeleteStream(arg0 *kinesis.DeleteStreamInput) (*kinesis.DeleteStreamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteStream", arg0)
	ret0, _ := ret[0].(*kinesis.DeleteStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteStreamRequest mocks base method
func (m *MockKinesisAPI) DeleteStreamRequest(arg0 *kinesis.DeleteStreamInput) (*request.Request, *kinesis.DeleteStreamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteStreamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DeleteStreamOutput)
	return ret0, ret1
}

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

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

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

// DeregisterStreamConsumer mocks base method
func (m *MockKinesisAPI) DeregisterStreamConsumer(arg0 *kinesis.DeregisterStreamConsumerInput) (*kinesis.DeregisterStreamConsumerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterStreamConsumer", arg0)
	ret0, _ := ret[0].(*kinesis.DeregisterStreamConsumerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterStreamConsumerRequest mocks base method
func (m *MockKinesisAPI) DeregisterStreamConsumerRequest(arg0 *kinesis.DeregisterStreamConsumerInput) (*request.Request, *kinesis.DeregisterStreamConsumerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterStreamConsumerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DeregisterStreamConsumerOutput)
	return ret0, ret1
}

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

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

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

// DescribeLimits mocks base method
func (m *MockKinesisAPI) DescribeLimits(arg0 *kinesis.DescribeLimitsInput) (*kinesis.DescribeLimitsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLimits", arg0)
	ret0, _ := ret[0].(*kinesis.DescribeLimitsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLimitsRequest mocks base method
func (m *MockKinesisAPI) DescribeLimitsRequest(arg0 *kinesis.DescribeLimitsInput) (*request.Request, *kinesis.DescribeLimitsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLimitsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DescribeLimitsOutput)
	return ret0, ret1
}

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

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

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

// DescribeStream mocks base method
func (m *MockKinesisAPI) DescribeStream(arg0 *kinesis.DescribeStreamInput) (*kinesis.DescribeStreamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStream", arg0)
	ret0, _ := ret[0].(*kinesis.DescribeStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeStreamConsumer mocks base method
func (m *MockKinesisAPI) DescribeStreamConsumer(arg0 *kinesis.DescribeStreamConsumerInput) (*kinesis.DescribeStreamConsumerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStreamConsumer", arg0)
	ret0, _ := ret[0].(*kinesis.DescribeStreamConsumerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeStreamConsumerRequest mocks base method
func (m *MockKinesisAPI) DescribeStreamConsumerRequest(arg0 *kinesis.DescribeStreamConsumerInput) (*request.Request, *kinesis.DescribeStreamConsumerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStreamConsumerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DescribeStreamConsumerOutput)
	return ret0, ret1
}

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

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

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

// DescribeStreamPages mocks base method
func (m *MockKinesisAPI) DescribeStreamPages(arg0 *kinesis.DescribeStreamInput, arg1 func(*kinesis.DescribeStreamOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStreamPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeStreamPagesWithContext mocks base method
func (m *MockKinesisAPI) DescribeStreamPagesWithContext(arg0 context.Context, arg1 *kinesis.DescribeStreamInput, arg2 func(*kinesis.DescribeStreamOutput, 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, "DescribeStreamPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeStreamRequest mocks base method
func (m *MockKinesisAPI) DescribeStreamRequest(arg0 *kinesis.DescribeStreamInput) (*request.Request, *kinesis.DescribeStreamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStreamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DescribeStreamOutput)
	return ret0, ret1
}

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

// DescribeStreamSummary mocks base method
func (m *MockKinesisAPI) DescribeStreamSummary(arg0 *kinesis.DescribeStreamSummaryInput) (*kinesis.DescribeStreamSummaryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStreamSummary", arg0)
	ret0, _ := ret[0].(*kinesis.DescribeStreamSummaryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeStreamSummaryRequest mocks base method
func (m *MockKinesisAPI) DescribeStreamSummaryRequest(arg0 *kinesis.DescribeStreamSummaryInput) (*request.Request, *kinesis.DescribeStreamSummaryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStreamSummaryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.DescribeStreamSummaryOutput)
	return ret0, ret1
}

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

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

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

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

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

// DisableEnhancedMonitoring mocks base method
func (m *MockKinesisAPI) DisableEnhancedMonitoring(arg0 *kinesis.DisableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableEnhancedMonitoring", arg0)
	ret0, _ := ret[0].(*kinesis.EnhancedMonitoringOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableEnhancedMonitoringRequest mocks base method
func (m *MockKinesisAPI) DisableEnhancedMonitoringRequest(arg0 *kinesis.DisableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableEnhancedMonitoringRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.EnhancedMonitoringOutput)
	return ret0, ret1
}

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

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

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

// EnableEnhancedMonitoring mocks base method
func (m *MockKinesisAPI) EnableEnhancedMonitoring(arg0 *kinesis.EnableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableEnhancedMonitoring", arg0)
	ret0, _ := ret[0].(*kinesis.EnhancedMonitoringOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableEnhancedMonitoringRequest mocks base method
func (m *MockKinesisAPI) EnableEnhancedMonitoringRequest(arg0 *kinesis.EnableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableEnhancedMonitoringRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.EnhancedMonitoringOutput)
	return ret0, ret1
}

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

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

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

// GetRecords mocks base method
func (m *MockKinesisAPI) GetRecords(arg0 *kinesis.GetRecordsInput) (*kinesis.GetRecordsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRecords", arg0)
	ret0, _ := ret[0].(*kinesis.GetRecordsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRecordsRequest mocks base method
func (m *MockKinesisAPI) GetRecordsRequest(arg0 *kinesis.GetRecordsInput) (*request.Request, *kinesis.GetRecordsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRecordsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.GetRecordsOutput)
	return ret0, ret1
}

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

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

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

// GetShardIterator mocks base method
func (m *MockKinesisAPI) GetShardIterator(arg0 *kinesis.GetShardIteratorInput) (*kinesis.GetShardIteratorOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShardIterator", arg0)
	ret0, _ := ret[0].(*kinesis.GetShardIteratorOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetShardIteratorRequest mocks base method
func (m *MockKinesisAPI) GetShardIteratorRequest(arg0 *kinesis.GetShardIteratorInput) (*request.Request, *kinesis.GetShardIteratorOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShardIteratorRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.GetShardIteratorOutput)
	return ret0, ret1
}

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

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

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

// IncreaseStreamRetentionPeriod mocks base method
func (m *MockKinesisAPI) IncreaseStreamRetentionPeriod(arg0 *kinesis.IncreaseStreamRetentionPeriodInput) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncreaseStreamRetentionPeriod", arg0)
	ret0, _ := ret[0].(*kinesis.IncreaseStreamRetentionPeriodOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// IncreaseStreamRetentionPeriodRequest mocks base method
func (m *MockKinesisAPI) IncreaseStreamRetentionPeriodRequest(arg0 *kinesis.IncreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.IncreaseStreamRetentionPeriodOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncreaseStreamRetentionPeriodRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.IncreaseStreamRetentionPeriodOutput)
	return ret0, ret1
}

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

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

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

// ListShards mocks base method
func (m *MockKinesisAPI) ListShards(arg0 *kinesis.ListShardsInput) (*kinesis.ListShardsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListShards", arg0)
	ret0, _ := ret[0].(*kinesis.ListShardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListShardsRequest mocks base method
func (m *MockKinesisAPI) ListShardsRequest(arg0 *kinesis.ListShardsInput) (*request.Request, *kinesis.ListShardsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListShardsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.ListShardsOutput)
	return ret0, ret1
}

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

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

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

// ListStreamConsumers mocks base method
func (m *MockKinesisAPI) ListStreamConsumers(arg0 *kinesis.ListStreamConsumersInput) (*kinesis.ListStreamConsumersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStreamConsumers", arg0)
	ret0, _ := ret[0].(*kinesis.ListStreamConsumersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListStreamConsumersPages mocks base method
func (m *MockKinesisAPI) ListStreamConsumersPages(arg0 *kinesis.ListStreamConsumersInput, arg1 func(*kinesis.ListStreamConsumersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStreamConsumersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListStreamConsumersPagesWithContext mocks base method
func (m *MockKinesisAPI) ListStreamConsumersPagesWithContext(arg0 context.Context, arg1 *kinesis.ListStreamConsumersInput, arg2 func(*kinesis.ListStreamConsumersOutput, 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, "ListStreamConsumersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListStreamConsumersRequest mocks base method
func (m *MockKinesisAPI) ListStreamConsumersRequest(arg0 *kinesis.ListStreamConsumersInput) (*request.Request, *kinesis.ListStreamConsumersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStreamConsumersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.ListStreamConsumersOutput)
	return ret0, ret1
}

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

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

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

// ListStreams mocks base method
func (m *MockKinesisAPI) ListStreams(arg0 *kinesis.ListStreamsInput) (*kinesis.ListStreamsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStreams", arg0)
	ret0, _ := ret[0].(*kinesis.ListStreamsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListStreamsPages mocks base method
func (m *MockKinesisAPI) ListStreamsPages(arg0 *kinesis.ListStreamsInput, arg1 func(*kinesis.ListStreamsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStreamsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListStreamsPagesWithContext mocks base method
func (m *MockKinesisAPI) ListStreamsPagesWithContext(arg0 context.Context, arg1 *kinesis.ListStreamsInput, arg2 func(*kinesis.ListStreamsOutput, 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, "ListStreamsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListStreamsRequest mocks base method
func (m *MockKinesisAPI) ListStreamsRequest(arg0 *kinesis.ListStreamsInput) (*request.Request, *kinesis.ListStreamsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStreamsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.ListStreamsOutput)
	return ret0, ret1
}

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

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

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

// ListTagsForStream mocks base method
func (m *MockKinesisAPI) ListTagsForStream(arg0 *kinesis.ListTagsForStreamInput) (*kinesis.ListTagsForStreamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForStream", arg0)
	ret0, _ := ret[0].(*kinesis.ListTagsForStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForStreamRequest mocks base method
func (m *MockKinesisAPI) ListTagsForStreamRequest(arg0 *kinesis.ListTagsForStreamInput) (*request.Request, *kinesis.ListTagsForStreamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForStreamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.ListTagsForStreamOutput)
	return ret0, ret1
}

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

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

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

// MergeShards mocks base method
func (m *MockKinesisAPI) MergeShards(arg0 *kinesis.MergeShardsInput) (*kinesis.MergeShardsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MergeShards", arg0)
	ret0, _ := ret[0].(*kinesis.MergeShardsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MergeShardsRequest mocks base method
func (m *MockKinesisAPI) MergeShardsRequest(arg0 *kinesis.MergeShardsInput) (*request.Request, *kinesis.MergeShardsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MergeShardsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.MergeShardsOutput)
	return ret0, ret1
}

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

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

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

// PutRecord mocks base method
func (m *MockKinesisAPI) PutRecord(arg0 *kinesis.PutRecordInput) (*kinesis.PutRecordOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutRecord", arg0)
	ret0, _ := ret[0].(*kinesis.PutRecordOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutRecordRequest mocks base method
func (m *MockKinesisAPI) PutRecordRequest(arg0 *kinesis.PutRecordInput) (*request.Request, *kinesis.PutRecordOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutRecordRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.PutRecordOutput)
	return ret0, ret1
}

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

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

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

// PutRecords mocks base method
func (m *MockKinesisAPI) PutRecords(arg0 *kinesis.PutRecordsInput) (*kinesis.PutRecordsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutRecords", arg0)
	ret0, _ := ret[0].(*kinesis.PutRecordsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutRecordsRequest mocks base method
func (m *MockKinesisAPI) PutRecordsRequest(arg0 *kinesis.PutRecordsInput) (*request.Request, *kinesis.PutRecordsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutRecordsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.PutRecordsOutput)
	return ret0, ret1
}

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

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

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

// RegisterStreamConsumer mocks base method
func (m *MockKinesisAPI) RegisterStreamConsumer(arg0 *kinesis.RegisterStreamConsumerInput) (*kinesis.RegisterStreamConsumerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterStreamConsumer", arg0)
	ret0, _ := ret[0].(*kinesis.RegisterStreamConsumerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterStreamConsumerRequest mocks base method
func (m *MockKinesisAPI) RegisterStreamConsumerRequest(arg0 *kinesis.RegisterStreamConsumerInput) (*request.Request, *kinesis.RegisterStreamConsumerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterStreamConsumerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.RegisterStreamConsumerOutput)
	return ret0, ret1
}

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

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

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

// RemoveTagsFromStream mocks base method
func (m *MockKinesisAPI) RemoveTagsFromStream(arg0 *kinesis.RemoveTagsFromStreamInput) (*kinesis.RemoveTagsFromStreamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveTagsFromStream", arg0)
	ret0, _ := ret[0].(*kinesis.RemoveTagsFromStreamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveTagsFromStreamRequest mocks base method
func (m *MockKinesisAPI) RemoveTagsFromStreamRequest(arg0 *kinesis.RemoveTagsFromStreamInput) (*request.Request, *kinesis.RemoveTagsFromStreamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveTagsFromStreamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.RemoveTagsFromStreamOutput)
	return ret0, ret1
}

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

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

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

// SplitShard mocks base method
func (m *MockKinesisAPI) SplitShard(arg0 *kinesis.SplitShardInput) (*kinesis.SplitShardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SplitShard", arg0)
	ret0, _ := ret[0].(*kinesis.SplitShardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SplitShardRequest mocks base method
func (m *MockKinesisAPI) SplitShardRequest(arg0 *kinesis.SplitShardInput) (*request.Request, *kinesis.SplitShardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SplitShardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.SplitShardOutput)
	return ret0, ret1
}

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

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

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

// StartStreamEncryption mocks base method
func (m *MockKinesisAPI) StartStreamEncryption(arg0 *kinesis.StartStreamEncryptionInput) (*kinesis.StartStreamEncryptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartStreamEncryption", arg0)
	ret0, _ := ret[0].(*kinesis.StartStreamEncryptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartStreamEncryptionRequest mocks base method
func (m *MockKinesisAPI) StartStreamEncryptionRequest(arg0 *kinesis.StartStreamEncryptionInput) (*request.Request, *kinesis.StartStreamEncryptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartStreamEncryptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.StartStreamEncryptionOutput)
	return ret0, ret1
}

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

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

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

// StopStreamEncryption mocks base method
func (m *MockKinesisAPI) StopStreamEncryption(arg0 *kinesis.StopStreamEncryptionInput) (*kinesis.StopStreamEncryptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopStreamEncryption", arg0)
	ret0, _ := ret[0].(*kinesis.StopStreamEncryptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopStreamEncryptionRequest mocks base method
func (m *MockKinesisAPI) StopStreamEncryptionRequest(arg0 *kinesis.StopStreamEncryptionInput) (*request.Request, *kinesis.StopStreamEncryptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopStreamEncryptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.StopStreamEncryptionOutput)
	return ret0, ret1
}

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

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

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

// SubscribeToShard mocks base method
func (m *MockKinesisAPI) SubscribeToShard(arg0 *kinesis.SubscribeToShardInput) (*kinesis.SubscribeToShardOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeToShard", arg0)
	ret0, _ := ret[0].(*kinesis.SubscribeToShardOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeToShardRequest mocks base method
func (m *MockKinesisAPI) SubscribeToShardRequest(arg0 *kinesis.SubscribeToShardInput) (*request.Request, *kinesis.SubscribeToShardOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeToShardRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.SubscribeToShardOutput)
	return ret0, ret1
}

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

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

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

// UpdateShardCount mocks base method
func (m *MockKinesisAPI) UpdateShardCount(arg0 *kinesis.UpdateShardCountInput) (*kinesis.UpdateShardCountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShardCount", arg0)
	ret0, _ := ret[0].(*kinesis.UpdateShardCountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateShardCountRequest mocks base method
func (m *MockKinesisAPI) UpdateShardCountRequest(arg0 *kinesis.UpdateShardCountInput) (*request.Request, *kinesis.UpdateShardCountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShardCountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*kinesis.UpdateShardCountOutput)
	return ret0, ret1
}

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

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

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

// WaitUntilStreamExists mocks base method
func (m *MockKinesisAPI) WaitUntilStreamExists(arg0 *kinesis.DescribeStreamInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilStreamExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilStreamExistsWithContext mocks base method
func (m *MockKinesisAPI) WaitUntilStreamExistsWithContext(arg0 context.Context, arg1 *kinesis.DescribeStreamInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilStreamExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilStreamNotExists mocks base method
func (m *MockKinesisAPI) WaitUntilStreamNotExists(arg0 *kinesis.DescribeStreamInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilStreamNotExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilStreamNotExistsWithContext mocks base method
func (m *MockKinesisAPI) WaitUntilStreamNotExistsWithContext(arg0 context.Context, arg1 *kinesis.DescribeStreamInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilStreamNotExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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