// Code generated by MockGen. DO NOT EDIT.
// Source: interface.go

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

import (
	context "context"
	reflect "reflect"

	v9 "github.com/Clever/wag/samples/gen-go-db-only/models/v9"
	expression "github.com/aws/aws-sdk-go-v2/feature/dynamodb/expression"
	strfmt "github.com/go-openapi/strfmt"
	gomock "github.com/golang/mock/gomock"
)

// MockInterface is a mock of Interface interface.
type MockInterface struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceMockRecorder
}

// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
	mock *MockInterface
}

// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
	mock := &MockInterface{ctrl: ctrl}
	mock.recorder = &MockInterfaceMockRecorder{mock}
	return mock
}

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

// DeleteArrayOfThingAllowingBatchWrites mocks base method.
func (m *MockInterface) DeleteArrayOfThingAllowingBatchWrites(ctx context.Context, ms []v9.ThingAllowingBatchWrites) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteArrayOfThingAllowingBatchWrites", ctx, ms)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteArrayOfThingAllowingBatchWrites indicates an expected call of DeleteArrayOfThingAllowingBatchWrites.
func (mr *MockInterfaceMockRecorder) DeleteArrayOfThingAllowingBatchWrites(ctx, ms interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteArrayOfThingAllowingBatchWrites", reflect.TypeOf((*MockInterface)(nil).DeleteArrayOfThingAllowingBatchWrites), ctx, ms)
}

// DeleteArrayOfThingAllowingBatchWritesWithCompositeAttributes mocks base method.
func (m *MockInterface) DeleteArrayOfThingAllowingBatchWritesWithCompositeAttributes(ctx context.Context, ms []v9.ThingAllowingBatchWritesWithCompositeAttributes) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteArrayOfThingAllowingBatchWritesWithCompositeAttributes", ctx, ms)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteArrayOfThingAllowingBatchWritesWithCompositeAttributes indicates an expected call of DeleteArrayOfThingAllowingBatchWritesWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) DeleteArrayOfThingAllowingBatchWritesWithCompositeAttributes(ctx, ms interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteArrayOfThingAllowingBatchWritesWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).DeleteArrayOfThingAllowingBatchWritesWithCompositeAttributes), ctx, ms)
}

// DeleteDeployment mocks base method.
func (m *MockInterface) DeleteDeployment(ctx context.Context, environment, application, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDeployment", ctx, environment, application, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDeployment indicates an expected call of DeleteDeployment.
func (mr *MockInterfaceMockRecorder) DeleteDeployment(ctx, environment, application, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDeployment", reflect.TypeOf((*MockInterface)(nil).DeleteDeployment), ctx, environment, application, version)
}

// DeleteEvent mocks base method.
func (m *MockInterface) DeleteEvent(ctx context.Context, pk, sk string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEvent", ctx, pk, sk)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteEvent indicates an expected call of DeleteEvent.
func (mr *MockInterfaceMockRecorder) DeleteEvent(ctx, pk, sk interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEvent", reflect.TypeOf((*MockInterface)(nil).DeleteEvent), ctx, pk, sk)
}

// DeleteNoRangeThingWithCompositeAttributes mocks base method.
func (m *MockInterface) DeleteNoRangeThingWithCompositeAttributes(ctx context.Context, name, branch string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNoRangeThingWithCompositeAttributes", ctx, name, branch)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNoRangeThingWithCompositeAttributes indicates an expected call of DeleteNoRangeThingWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) DeleteNoRangeThingWithCompositeAttributes(ctx, name, branch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNoRangeThingWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).DeleteNoRangeThingWithCompositeAttributes), ctx, name, branch)
}

// DeleteSimpleThing mocks base method.
func (m *MockInterface) DeleteSimpleThing(ctx context.Context, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSimpleThing", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSimpleThing indicates an expected call of DeleteSimpleThing.
func (mr *MockInterfaceMockRecorder) DeleteSimpleThing(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSimpleThing", reflect.TypeOf((*MockInterface)(nil).DeleteSimpleThing), ctx, name)
}

// DeleteTeacherSharingRule mocks base method.
func (m *MockInterface) DeleteTeacherSharingRule(ctx context.Context, teacher, school, app string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTeacherSharingRule", ctx, teacher, school, app)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTeacherSharingRule indicates an expected call of DeleteTeacherSharingRule.
func (mr *MockInterfaceMockRecorder) DeleteTeacherSharingRule(ctx, teacher, school, app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTeacherSharingRule", reflect.TypeOf((*MockInterface)(nil).DeleteTeacherSharingRule), ctx, teacher, school, app)
}

// DeleteThing mocks base method.
func (m *MockInterface) DeleteThing(ctx context.Context, name string, version int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThing", ctx, name, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThing indicates an expected call of DeleteThing.
func (mr *MockInterfaceMockRecorder) DeleteThing(ctx, name, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThing", reflect.TypeOf((*MockInterface)(nil).DeleteThing), ctx, name, version)
}

// DeleteThingAllowingBatchWrites mocks base method.
func (m *MockInterface) DeleteThingAllowingBatchWrites(ctx context.Context, name string, version int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingAllowingBatchWrites", ctx, name, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingAllowingBatchWrites indicates an expected call of DeleteThingAllowingBatchWrites.
func (mr *MockInterfaceMockRecorder) DeleteThingAllowingBatchWrites(ctx, name, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingAllowingBatchWrites", reflect.TypeOf((*MockInterface)(nil).DeleteThingAllowingBatchWrites), ctx, name, version)
}

// DeleteThingAllowingBatchWritesWithCompositeAttributes mocks base method.
func (m *MockInterface) DeleteThingAllowingBatchWritesWithCompositeAttributes(ctx context.Context, name, id string, date strfmt.DateTime) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingAllowingBatchWritesWithCompositeAttributes", ctx, name, id, date)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingAllowingBatchWritesWithCompositeAttributes indicates an expected call of DeleteThingAllowingBatchWritesWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) DeleteThingAllowingBatchWritesWithCompositeAttributes(ctx, name, id, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingAllowingBatchWritesWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).DeleteThingAllowingBatchWritesWithCompositeAttributes), ctx, name, id, date)
}

// DeleteThingWithAdditionalAttributes mocks base method.
func (m *MockInterface) DeleteThingWithAdditionalAttributes(ctx context.Context, name string, version int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithAdditionalAttributes", ctx, name, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithAdditionalAttributes indicates an expected call of DeleteThingWithAdditionalAttributes.
func (mr *MockInterfaceMockRecorder) DeleteThingWithAdditionalAttributes(ctx, name, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithAdditionalAttributes", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithAdditionalAttributes), ctx, name, version)
}

// DeleteThingWithCompositeAttributes mocks base method.
func (m *MockInterface) DeleteThingWithCompositeAttributes(ctx context.Context, name, branch string, date strfmt.DateTime) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithCompositeAttributes", ctx, name, branch, date)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithCompositeAttributes indicates an expected call of DeleteThingWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) DeleteThingWithCompositeAttributes(ctx, name, branch, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithCompositeAttributes), ctx, name, branch, date)
}

// DeleteThingWithCompositeEnumAttributes mocks base method.
func (m *MockInterface) DeleteThingWithCompositeEnumAttributes(ctx context.Context, name string, branchID v9.Branch, date strfmt.DateTime) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithCompositeEnumAttributes", ctx, name, branchID, date)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithCompositeEnumAttributes indicates an expected call of DeleteThingWithCompositeEnumAttributes.
func (mr *MockInterfaceMockRecorder) DeleteThingWithCompositeEnumAttributes(ctx, name, branchID, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithCompositeEnumAttributes", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithCompositeEnumAttributes), ctx, name, branchID, date)
}

// DeleteThingWithDateGSI mocks base method.
func (m *MockInterface) DeleteThingWithDateGSI(ctx context.Context, dateH strfmt.Date) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithDateGSI", ctx, dateH)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithDateGSI indicates an expected call of DeleteThingWithDateGSI.
func (mr *MockInterfaceMockRecorder) DeleteThingWithDateGSI(ctx, dateH interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithDateGSI", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithDateGSI), ctx, dateH)
}

// DeleteThingWithDateRange mocks base method.
func (m *MockInterface) DeleteThingWithDateRange(ctx context.Context, name string, date strfmt.DateTime) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithDateRange", ctx, name, date)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithDateRange indicates an expected call of DeleteThingWithDateRange.
func (mr *MockInterfaceMockRecorder) DeleteThingWithDateRange(ctx, name, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithDateRange", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithDateRange), ctx, name, date)
}

// DeleteThingWithDateRangeKey mocks base method.
func (m *MockInterface) DeleteThingWithDateRangeKey(ctx context.Context, id string, date strfmt.Date) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithDateRangeKey", ctx, id, date)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithDateRangeKey indicates an expected call of DeleteThingWithDateRangeKey.
func (mr *MockInterfaceMockRecorder) DeleteThingWithDateRangeKey(ctx, id, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithDateRangeKey", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithDateRangeKey), ctx, id, date)
}

// DeleteThingWithDateTimeComposite mocks base method.
func (m *MockInterface) DeleteThingWithDateTimeComposite(ctx context.Context, typeVar, id string, created strfmt.DateTime, resource string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithDateTimeComposite", ctx, typeVar, id, created, resource)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithDateTimeComposite indicates an expected call of DeleteThingWithDateTimeComposite.
func (mr *MockInterfaceMockRecorder) DeleteThingWithDateTimeComposite(ctx, typeVar, id, created, resource interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithDateTimeComposite", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithDateTimeComposite), ctx, typeVar, id, created, resource)
}

// DeleteThingWithDatetimeGSI mocks base method.
func (m *MockInterface) DeleteThingWithDatetimeGSI(ctx context.Context, id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithDatetimeGSI", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithDatetimeGSI indicates an expected call of DeleteThingWithDatetimeGSI.
func (mr *MockInterfaceMockRecorder) DeleteThingWithDatetimeGSI(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithDatetimeGSI", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithDatetimeGSI), ctx, id)
}

// DeleteThingWithEnumHashKey mocks base method.
func (m *MockInterface) DeleteThingWithEnumHashKey(ctx context.Context, branch v9.Branch, date strfmt.DateTime) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithEnumHashKey", ctx, branch, date)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithEnumHashKey indicates an expected call of DeleteThingWithEnumHashKey.
func (mr *MockInterfaceMockRecorder) DeleteThingWithEnumHashKey(ctx, branch, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithEnumHashKey", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithEnumHashKey), ctx, branch, date)
}

// DeleteThingWithMatchingKeys mocks base method.
func (m *MockInterface) DeleteThingWithMatchingKeys(ctx context.Context, bear, assocType, assocID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithMatchingKeys", ctx, bear, assocType, assocID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithMatchingKeys indicates an expected call of DeleteThingWithMatchingKeys.
func (mr *MockInterfaceMockRecorder) DeleteThingWithMatchingKeys(ctx, bear, assocType, assocID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithMatchingKeys", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithMatchingKeys), ctx, bear, assocType, assocID)
}

// DeleteThingWithMultiUseCompositeAttribute mocks base method.
func (m *MockInterface) DeleteThingWithMultiUseCompositeAttribute(ctx context.Context, one string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithMultiUseCompositeAttribute", ctx, one)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithMultiUseCompositeAttribute indicates an expected call of DeleteThingWithMultiUseCompositeAttribute.
func (mr *MockInterfaceMockRecorder) DeleteThingWithMultiUseCompositeAttribute(ctx, one interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithMultiUseCompositeAttribute", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithMultiUseCompositeAttribute), ctx, one)
}

// DeleteThingWithRequiredCompositePropertiesAndKeysOnly mocks base method.
func (m *MockInterface) DeleteThingWithRequiredCompositePropertiesAndKeysOnly(ctx context.Context, propertyThree string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithRequiredCompositePropertiesAndKeysOnly", ctx, propertyThree)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithRequiredCompositePropertiesAndKeysOnly indicates an expected call of DeleteThingWithRequiredCompositePropertiesAndKeysOnly.
func (mr *MockInterfaceMockRecorder) DeleteThingWithRequiredCompositePropertiesAndKeysOnly(ctx, propertyThree interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithRequiredCompositePropertiesAndKeysOnly", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithRequiredCompositePropertiesAndKeysOnly), ctx, propertyThree)
}

// DeleteThingWithRequiredFields mocks base method.
func (m *MockInterface) DeleteThingWithRequiredFields(ctx context.Context, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithRequiredFields", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithRequiredFields indicates an expected call of DeleteThingWithRequiredFields.
func (mr *MockInterfaceMockRecorder) DeleteThingWithRequiredFields(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithRequiredFields", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithRequiredFields), ctx, name)
}

// DeleteThingWithRequiredFields2 mocks base method.
func (m *MockInterface) DeleteThingWithRequiredFields2(ctx context.Context, name, id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithRequiredFields2", ctx, name, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithRequiredFields2 indicates an expected call of DeleteThingWithRequiredFields2.
func (mr *MockInterfaceMockRecorder) DeleteThingWithRequiredFields2(ctx, name, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithRequiredFields2", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithRequiredFields2), ctx, name, id)
}

// DeleteThingWithTransactMultipleGSI mocks base method.
func (m *MockInterface) DeleteThingWithTransactMultipleGSI(ctx context.Context, dateH strfmt.Date) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithTransactMultipleGSI", ctx, dateH)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithTransactMultipleGSI indicates an expected call of DeleteThingWithTransactMultipleGSI.
func (mr *MockInterfaceMockRecorder) DeleteThingWithTransactMultipleGSI(ctx, dateH interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithTransactMultipleGSI", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithTransactMultipleGSI), ctx, dateH)
}

// DeleteThingWithTransaction mocks base method.
func (m *MockInterface) DeleteThingWithTransaction(ctx context.Context, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithTransaction", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithTransaction indicates an expected call of DeleteThingWithTransaction.
func (mr *MockInterfaceMockRecorder) DeleteThingWithTransaction(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithTransaction", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithTransaction), ctx, name)
}

// DeleteThingWithTransactionWithSimpleThing mocks base method.
func (m *MockInterface) DeleteThingWithTransactionWithSimpleThing(ctx context.Context, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithTransactionWithSimpleThing", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithTransactionWithSimpleThing indicates an expected call of DeleteThingWithTransactionWithSimpleThing.
func (mr *MockInterfaceMockRecorder) DeleteThingWithTransactionWithSimpleThing(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithTransactionWithSimpleThing", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithTransactionWithSimpleThing), ctx, name)
}

// DeleteThingWithUnderscores mocks base method.
func (m *MockInterface) DeleteThingWithUnderscores(ctx context.Context, iDApp string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteThingWithUnderscores", ctx, iDApp)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteThingWithUnderscores indicates an expected call of DeleteThingWithUnderscores.
func (mr *MockInterfaceMockRecorder) DeleteThingWithUnderscores(ctx, iDApp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteThingWithUnderscores", reflect.TypeOf((*MockInterface)(nil).DeleteThingWithUnderscores), ctx, iDApp)
}

// GetDeployment mocks base method.
func (m *MockInterface) GetDeployment(ctx context.Context, environment, application, version string) (*v9.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeployment", ctx, environment, application, version)
	ret0, _ := ret[0].(*v9.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDeployment indicates an expected call of GetDeployment.
func (mr *MockInterfaceMockRecorder) GetDeployment(ctx, environment, application, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeployment", reflect.TypeOf((*MockInterface)(nil).GetDeployment), ctx, environment, application, version)
}

// GetDeploymentByVersion mocks base method.
func (m *MockInterface) GetDeploymentByVersion(ctx context.Context, version string) (*v9.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentByVersion", ctx, version)
	ret0, _ := ret[0].(*v9.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDeploymentByVersion indicates an expected call of GetDeploymentByVersion.
func (mr *MockInterfaceMockRecorder) GetDeploymentByVersion(ctx, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentByVersion", reflect.TypeOf((*MockInterface)(nil).GetDeploymentByVersion), ctx, version)
}

// GetDeploymentsByEnvAppAndDate mocks base method.
func (m *MockInterface) GetDeploymentsByEnvAppAndDate(ctx context.Context, input GetDeploymentsByEnvAppAndDateInput, fn func(*v9.Deployment, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentsByEnvAppAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetDeploymentsByEnvAppAndDate indicates an expected call of GetDeploymentsByEnvAppAndDate.
func (mr *MockInterfaceMockRecorder) GetDeploymentsByEnvAppAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentsByEnvAppAndDate", reflect.TypeOf((*MockInterface)(nil).GetDeploymentsByEnvAppAndDate), ctx, input, fn)
}

// GetDeploymentsByEnvAppAndVersion mocks base method.
func (m *MockInterface) GetDeploymentsByEnvAppAndVersion(ctx context.Context, input GetDeploymentsByEnvAppAndVersionInput, fn func(*v9.Deployment, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentsByEnvAppAndVersion", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetDeploymentsByEnvAppAndVersion indicates an expected call of GetDeploymentsByEnvAppAndVersion.
func (mr *MockInterfaceMockRecorder) GetDeploymentsByEnvAppAndVersion(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentsByEnvAppAndVersion", reflect.TypeOf((*MockInterface)(nil).GetDeploymentsByEnvAppAndVersion), ctx, input, fn)
}

// GetDeploymentsByEnvironmentAndDate mocks base method.
func (m *MockInterface) GetDeploymentsByEnvironmentAndDate(ctx context.Context, input GetDeploymentsByEnvironmentAndDateInput, fn func(*v9.Deployment, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentsByEnvironmentAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetDeploymentsByEnvironmentAndDate indicates an expected call of GetDeploymentsByEnvironmentAndDate.
func (mr *MockInterfaceMockRecorder) GetDeploymentsByEnvironmentAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentsByEnvironmentAndDate", reflect.TypeOf((*MockInterface)(nil).GetDeploymentsByEnvironmentAndDate), ctx, input, fn)
}

// GetEvent mocks base method.
func (m *MockInterface) GetEvent(ctx context.Context, pk, sk string) (*v9.Event, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEvent", ctx, pk, sk)
	ret0, _ := ret[0].(*v9.Event)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEvent indicates an expected call of GetEvent.
func (mr *MockInterfaceMockRecorder) GetEvent(ctx, pk, sk interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEvent", reflect.TypeOf((*MockInterface)(nil).GetEvent), ctx, pk, sk)
}

// GetEventsByPkAndSk mocks base method.
func (m *MockInterface) GetEventsByPkAndSk(ctx context.Context, input GetEventsByPkAndSkInput, fn func(*v9.Event, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEventsByPkAndSk", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetEventsByPkAndSk indicates an expected call of GetEventsByPkAndSk.
func (mr *MockInterfaceMockRecorder) GetEventsByPkAndSk(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsByPkAndSk", reflect.TypeOf((*MockInterface)(nil).GetEventsByPkAndSk), ctx, input, fn)
}

// GetEventsBySkAndData mocks base method.
func (m *MockInterface) GetEventsBySkAndData(ctx context.Context, input GetEventsBySkAndDataInput, fn func(*v9.Event, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEventsBySkAndData", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetEventsBySkAndData indicates an expected call of GetEventsBySkAndData.
func (mr *MockInterfaceMockRecorder) GetEventsBySkAndData(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsBySkAndData", reflect.TypeOf((*MockInterface)(nil).GetEventsBySkAndData), ctx, input, fn)
}

// GetNoRangeThingWithCompositeAttributes mocks base method.
func (m *MockInterface) GetNoRangeThingWithCompositeAttributes(ctx context.Context, name, branch string) (*v9.NoRangeThingWithCompositeAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNoRangeThingWithCompositeAttributes", ctx, name, branch)
	ret0, _ := ret[0].(*v9.NoRangeThingWithCompositeAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNoRangeThingWithCompositeAttributes indicates an expected call of GetNoRangeThingWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) GetNoRangeThingWithCompositeAttributes(ctx, name, branch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNoRangeThingWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).GetNoRangeThingWithCompositeAttributes), ctx, name, branch)
}

// GetNoRangeThingWithCompositeAttributesByNameBranchCommit mocks base method.
func (m *MockInterface) GetNoRangeThingWithCompositeAttributesByNameBranchCommit(ctx context.Context, name, branch, commit string) (*v9.NoRangeThingWithCompositeAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNoRangeThingWithCompositeAttributesByNameBranchCommit", ctx, name, branch, commit)
	ret0, _ := ret[0].(*v9.NoRangeThingWithCompositeAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNoRangeThingWithCompositeAttributesByNameBranchCommit indicates an expected call of GetNoRangeThingWithCompositeAttributesByNameBranchCommit.
func (mr *MockInterfaceMockRecorder) GetNoRangeThingWithCompositeAttributesByNameBranchCommit(ctx, name, branch, commit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNoRangeThingWithCompositeAttributesByNameBranchCommit", reflect.TypeOf((*MockInterface)(nil).GetNoRangeThingWithCompositeAttributesByNameBranchCommit), ctx, name, branch, commit)
}

// GetNoRangeThingWithCompositeAttributessByNameVersionAndDate mocks base method.
func (m *MockInterface) GetNoRangeThingWithCompositeAttributessByNameVersionAndDate(ctx context.Context, input GetNoRangeThingWithCompositeAttributessByNameVersionAndDateInput, fn func(*v9.NoRangeThingWithCompositeAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNoRangeThingWithCompositeAttributessByNameVersionAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetNoRangeThingWithCompositeAttributessByNameVersionAndDate indicates an expected call of GetNoRangeThingWithCompositeAttributessByNameVersionAndDate.
func (mr *MockInterfaceMockRecorder) GetNoRangeThingWithCompositeAttributessByNameVersionAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNoRangeThingWithCompositeAttributessByNameVersionAndDate", reflect.TypeOf((*MockInterface)(nil).GetNoRangeThingWithCompositeAttributessByNameVersionAndDate), ctx, input, fn)
}

// GetSimpleThing mocks base method.
func (m *MockInterface) GetSimpleThing(ctx context.Context, name string) (*v9.SimpleThing, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSimpleThing", ctx, name)
	ret0, _ := ret[0].(*v9.SimpleThing)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSimpleThing indicates an expected call of GetSimpleThing.
func (mr *MockInterfaceMockRecorder) GetSimpleThing(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSimpleThing", reflect.TypeOf((*MockInterface)(nil).GetSimpleThing), ctx, name)
}

// GetTeacherSharingRule mocks base method.
func (m *MockInterface) GetTeacherSharingRule(ctx context.Context, teacher, school, app string) (*v9.TeacherSharingRule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTeacherSharingRule", ctx, teacher, school, app)
	ret0, _ := ret[0].(*v9.TeacherSharingRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeacherSharingRule indicates an expected call of GetTeacherSharingRule.
func (mr *MockInterfaceMockRecorder) GetTeacherSharingRule(ctx, teacher, school, app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeacherSharingRule", reflect.TypeOf((*MockInterface)(nil).GetTeacherSharingRule), ctx, teacher, school, app)
}

// GetTeacherSharingRulesByDistrictAndSchoolTeacherApp mocks base method.
func (m *MockInterface) GetTeacherSharingRulesByDistrictAndSchoolTeacherApp(ctx context.Context, input GetTeacherSharingRulesByDistrictAndSchoolTeacherAppInput, fn func(*v9.TeacherSharingRule, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTeacherSharingRulesByDistrictAndSchoolTeacherApp", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetTeacherSharingRulesByDistrictAndSchoolTeacherApp indicates an expected call of GetTeacherSharingRulesByDistrictAndSchoolTeacherApp.
func (mr *MockInterfaceMockRecorder) GetTeacherSharingRulesByDistrictAndSchoolTeacherApp(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeacherSharingRulesByDistrictAndSchoolTeacherApp", reflect.TypeOf((*MockInterface)(nil).GetTeacherSharingRulesByDistrictAndSchoolTeacherApp), ctx, input, fn)
}

// GetTeacherSharingRulesByTeacherAndSchoolApp mocks base method.
func (m *MockInterface) GetTeacherSharingRulesByTeacherAndSchoolApp(ctx context.Context, input GetTeacherSharingRulesByTeacherAndSchoolAppInput, fn func(*v9.TeacherSharingRule, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTeacherSharingRulesByTeacherAndSchoolApp", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetTeacherSharingRulesByTeacherAndSchoolApp indicates an expected call of GetTeacherSharingRulesByTeacherAndSchoolApp.
func (mr *MockInterfaceMockRecorder) GetTeacherSharingRulesByTeacherAndSchoolApp(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeacherSharingRulesByTeacherAndSchoolApp", reflect.TypeOf((*MockInterface)(nil).GetTeacherSharingRulesByTeacherAndSchoolApp), ctx, input, fn)
}

// GetThing mocks base method.
func (m *MockInterface) GetThing(ctx context.Context, name string, version int64) (*v9.Thing, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThing", ctx, name, version)
	ret0, _ := ret[0].(*v9.Thing)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThing indicates an expected call of GetThing.
func (mr *MockInterfaceMockRecorder) GetThing(ctx, name, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThing", reflect.TypeOf((*MockInterface)(nil).GetThing), ctx, name, version)
}

// GetThingAllowingBatchWrites mocks base method.
func (m *MockInterface) GetThingAllowingBatchWrites(ctx context.Context, name string, version int64) (*v9.ThingAllowingBatchWrites, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingAllowingBatchWrites", ctx, name, version)
	ret0, _ := ret[0].(*v9.ThingAllowingBatchWrites)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingAllowingBatchWrites indicates an expected call of GetThingAllowingBatchWrites.
func (mr *MockInterfaceMockRecorder) GetThingAllowingBatchWrites(ctx, name, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingAllowingBatchWrites", reflect.TypeOf((*MockInterface)(nil).GetThingAllowingBatchWrites), ctx, name, version)
}

// GetThingAllowingBatchWritesWithCompositeAttributes mocks base method.
func (m *MockInterface) GetThingAllowingBatchWritesWithCompositeAttributes(ctx context.Context, name, id string, date strfmt.DateTime) (*v9.ThingAllowingBatchWritesWithCompositeAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingAllowingBatchWritesWithCompositeAttributes", ctx, name, id, date)
	ret0, _ := ret[0].(*v9.ThingAllowingBatchWritesWithCompositeAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingAllowingBatchWritesWithCompositeAttributes indicates an expected call of GetThingAllowingBatchWritesWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) GetThingAllowingBatchWritesWithCompositeAttributes(ctx, name, id, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingAllowingBatchWritesWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).GetThingAllowingBatchWritesWithCompositeAttributes), ctx, name, id, date)
}

// GetThingAllowingBatchWritesWithCompositeAttributessByNameIDAndDate mocks base method.
func (m *MockInterface) GetThingAllowingBatchWritesWithCompositeAttributessByNameIDAndDate(ctx context.Context, input GetThingAllowingBatchWritesWithCompositeAttributessByNameIDAndDateInput, fn func(*v9.ThingAllowingBatchWritesWithCompositeAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingAllowingBatchWritesWithCompositeAttributessByNameIDAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingAllowingBatchWritesWithCompositeAttributessByNameIDAndDate indicates an expected call of GetThingAllowingBatchWritesWithCompositeAttributessByNameIDAndDate.
func (mr *MockInterfaceMockRecorder) GetThingAllowingBatchWritesWithCompositeAttributessByNameIDAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingAllowingBatchWritesWithCompositeAttributessByNameIDAndDate", reflect.TypeOf((*MockInterface)(nil).GetThingAllowingBatchWritesWithCompositeAttributessByNameIDAndDate), ctx, input, fn)
}

// GetThingAllowingBatchWritessByNameAndVersion mocks base method.
func (m *MockInterface) GetThingAllowingBatchWritessByNameAndVersion(ctx context.Context, input GetThingAllowingBatchWritessByNameAndVersionInput, fn func(*v9.ThingAllowingBatchWrites, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingAllowingBatchWritessByNameAndVersion", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingAllowingBatchWritessByNameAndVersion indicates an expected call of GetThingAllowingBatchWritessByNameAndVersion.
func (mr *MockInterfaceMockRecorder) GetThingAllowingBatchWritessByNameAndVersion(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingAllowingBatchWritessByNameAndVersion", reflect.TypeOf((*MockInterface)(nil).GetThingAllowingBatchWritessByNameAndVersion), ctx, input, fn)
}

// GetThingByID mocks base method.
func (m *MockInterface) GetThingByID(ctx context.Context, id string) (*v9.Thing, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingByID", ctx, id)
	ret0, _ := ret[0].(*v9.Thing)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingByID indicates an expected call of GetThingByID.
func (mr *MockInterfaceMockRecorder) GetThingByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingByID", reflect.TypeOf((*MockInterface)(nil).GetThingByID), ctx, id)
}

// GetThingWithAdditionalAttributes mocks base method.
func (m *MockInterface) GetThingWithAdditionalAttributes(ctx context.Context, name string, version int64) (*v9.ThingWithAdditionalAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithAdditionalAttributes", ctx, name, version)
	ret0, _ := ret[0].(*v9.ThingWithAdditionalAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithAdditionalAttributes indicates an expected call of GetThingWithAdditionalAttributes.
func (mr *MockInterfaceMockRecorder) GetThingWithAdditionalAttributes(ctx, name, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithAdditionalAttributes", reflect.TypeOf((*MockInterface)(nil).GetThingWithAdditionalAttributes), ctx, name, version)
}

// GetThingWithAdditionalAttributesByID mocks base method.
func (m *MockInterface) GetThingWithAdditionalAttributesByID(ctx context.Context, id string) (*v9.ThingWithAdditionalAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithAdditionalAttributesByID", ctx, id)
	ret0, _ := ret[0].(*v9.ThingWithAdditionalAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithAdditionalAttributesByID indicates an expected call of GetThingWithAdditionalAttributesByID.
func (mr *MockInterfaceMockRecorder) GetThingWithAdditionalAttributesByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithAdditionalAttributesByID", reflect.TypeOf((*MockInterface)(nil).GetThingWithAdditionalAttributesByID), ctx, id)
}

// GetThingWithAdditionalAttributessByHashNullableAndName mocks base method.
func (m *MockInterface) GetThingWithAdditionalAttributessByHashNullableAndName(ctx context.Context, input GetThingWithAdditionalAttributessByHashNullableAndNameInput, fn func(*v9.ThingWithAdditionalAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithAdditionalAttributessByHashNullableAndName", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithAdditionalAttributessByHashNullableAndName indicates an expected call of GetThingWithAdditionalAttributessByHashNullableAndName.
func (mr *MockInterfaceMockRecorder) GetThingWithAdditionalAttributessByHashNullableAndName(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithAdditionalAttributessByHashNullableAndName", reflect.TypeOf((*MockInterface)(nil).GetThingWithAdditionalAttributessByHashNullableAndName), ctx, input, fn)
}

// GetThingWithAdditionalAttributessByNameAndCreatedAt mocks base method.
func (m *MockInterface) GetThingWithAdditionalAttributessByNameAndCreatedAt(ctx context.Context, input GetThingWithAdditionalAttributessByNameAndCreatedAtInput, fn func(*v9.ThingWithAdditionalAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithAdditionalAttributessByNameAndCreatedAt", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithAdditionalAttributessByNameAndCreatedAt indicates an expected call of GetThingWithAdditionalAttributessByNameAndCreatedAt.
func (mr *MockInterfaceMockRecorder) GetThingWithAdditionalAttributessByNameAndCreatedAt(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithAdditionalAttributessByNameAndCreatedAt", reflect.TypeOf((*MockInterface)(nil).GetThingWithAdditionalAttributessByNameAndCreatedAt), ctx, input, fn)
}

// GetThingWithAdditionalAttributessByNameAndRangeNullable mocks base method.
func (m *MockInterface) GetThingWithAdditionalAttributessByNameAndRangeNullable(ctx context.Context, input GetThingWithAdditionalAttributessByNameAndRangeNullableInput, fn func(*v9.ThingWithAdditionalAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithAdditionalAttributessByNameAndRangeNullable", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithAdditionalAttributessByNameAndRangeNullable indicates an expected call of GetThingWithAdditionalAttributessByNameAndRangeNullable.
func (mr *MockInterfaceMockRecorder) GetThingWithAdditionalAttributessByNameAndRangeNullable(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithAdditionalAttributessByNameAndRangeNullable", reflect.TypeOf((*MockInterface)(nil).GetThingWithAdditionalAttributessByNameAndRangeNullable), ctx, input, fn)
}

// GetThingWithAdditionalAttributessByNameAndVersion mocks base method.
func (m *MockInterface) GetThingWithAdditionalAttributessByNameAndVersion(ctx context.Context, input GetThingWithAdditionalAttributessByNameAndVersionInput, fn func(*v9.ThingWithAdditionalAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithAdditionalAttributessByNameAndVersion", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithAdditionalAttributessByNameAndVersion indicates an expected call of GetThingWithAdditionalAttributessByNameAndVersion.
func (mr *MockInterfaceMockRecorder) GetThingWithAdditionalAttributessByNameAndVersion(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithAdditionalAttributessByNameAndVersion", reflect.TypeOf((*MockInterface)(nil).GetThingWithAdditionalAttributessByNameAndVersion), ctx, input, fn)
}

// GetThingWithCompositeAttributes mocks base method.
func (m *MockInterface) GetThingWithCompositeAttributes(ctx context.Context, name, branch string, date strfmt.DateTime) (*v9.ThingWithCompositeAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithCompositeAttributes", ctx, name, branch, date)
	ret0, _ := ret[0].(*v9.ThingWithCompositeAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithCompositeAttributes indicates an expected call of GetThingWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) GetThingWithCompositeAttributes(ctx, name, branch, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).GetThingWithCompositeAttributes), ctx, name, branch, date)
}

// GetThingWithCompositeAttributessByNameBranchAndDate mocks base method.
func (m *MockInterface) GetThingWithCompositeAttributessByNameBranchAndDate(ctx context.Context, input GetThingWithCompositeAttributessByNameBranchAndDateInput, fn func(*v9.ThingWithCompositeAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithCompositeAttributessByNameBranchAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithCompositeAttributessByNameBranchAndDate indicates an expected call of GetThingWithCompositeAttributessByNameBranchAndDate.
func (mr *MockInterfaceMockRecorder) GetThingWithCompositeAttributessByNameBranchAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithCompositeAttributessByNameBranchAndDate", reflect.TypeOf((*MockInterface)(nil).GetThingWithCompositeAttributessByNameBranchAndDate), ctx, input, fn)
}

// GetThingWithCompositeAttributessByNameVersionAndDate mocks base method.
func (m *MockInterface) GetThingWithCompositeAttributessByNameVersionAndDate(ctx context.Context, input GetThingWithCompositeAttributessByNameVersionAndDateInput, fn func(*v9.ThingWithCompositeAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithCompositeAttributessByNameVersionAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithCompositeAttributessByNameVersionAndDate indicates an expected call of GetThingWithCompositeAttributessByNameVersionAndDate.
func (mr *MockInterfaceMockRecorder) GetThingWithCompositeAttributessByNameVersionAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithCompositeAttributessByNameVersionAndDate", reflect.TypeOf((*MockInterface)(nil).GetThingWithCompositeAttributessByNameVersionAndDate), ctx, input, fn)
}

// GetThingWithCompositeEnumAttributes mocks base method.
func (m *MockInterface) GetThingWithCompositeEnumAttributes(ctx context.Context, name string, branchID v9.Branch, date strfmt.DateTime) (*v9.ThingWithCompositeEnumAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithCompositeEnumAttributes", ctx, name, branchID, date)
	ret0, _ := ret[0].(*v9.ThingWithCompositeEnumAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithCompositeEnumAttributes indicates an expected call of GetThingWithCompositeEnumAttributes.
func (mr *MockInterfaceMockRecorder) GetThingWithCompositeEnumAttributes(ctx, name, branchID, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithCompositeEnumAttributes", reflect.TypeOf((*MockInterface)(nil).GetThingWithCompositeEnumAttributes), ctx, name, branchID, date)
}

// GetThingWithCompositeEnumAttributessByNameBranchAndDate mocks base method.
func (m *MockInterface) GetThingWithCompositeEnumAttributessByNameBranchAndDate(ctx context.Context, input GetThingWithCompositeEnumAttributessByNameBranchAndDateInput, fn func(*v9.ThingWithCompositeEnumAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithCompositeEnumAttributessByNameBranchAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithCompositeEnumAttributessByNameBranchAndDate indicates an expected call of GetThingWithCompositeEnumAttributessByNameBranchAndDate.
func (mr *MockInterfaceMockRecorder) GetThingWithCompositeEnumAttributessByNameBranchAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithCompositeEnumAttributessByNameBranchAndDate", reflect.TypeOf((*MockInterface)(nil).GetThingWithCompositeEnumAttributessByNameBranchAndDate), ctx, input, fn)
}

// GetThingWithDateGSI mocks base method.
func (m *MockInterface) GetThingWithDateGSI(ctx context.Context, dateH strfmt.Date) (*v9.ThingWithDateGSI, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDateGSI", ctx, dateH)
	ret0, _ := ret[0].(*v9.ThingWithDateGSI)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithDateGSI indicates an expected call of GetThingWithDateGSI.
func (mr *MockInterfaceMockRecorder) GetThingWithDateGSI(ctx, dateH interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDateGSI", reflect.TypeOf((*MockInterface)(nil).GetThingWithDateGSI), ctx, dateH)
}

// GetThingWithDateGSIsByDateHAndID mocks base method.
func (m *MockInterface) GetThingWithDateGSIsByDateHAndID(ctx context.Context, input GetThingWithDateGSIsByDateHAndIDInput, fn func(*v9.ThingWithDateGSI, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDateGSIsByDateHAndID", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithDateGSIsByDateHAndID indicates an expected call of GetThingWithDateGSIsByDateHAndID.
func (mr *MockInterfaceMockRecorder) GetThingWithDateGSIsByDateHAndID(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDateGSIsByDateHAndID", reflect.TypeOf((*MockInterface)(nil).GetThingWithDateGSIsByDateHAndID), ctx, input, fn)
}

// GetThingWithDateGSIsByIDAndDateR mocks base method.
func (m *MockInterface) GetThingWithDateGSIsByIDAndDateR(ctx context.Context, input GetThingWithDateGSIsByIDAndDateRInput, fn func(*v9.ThingWithDateGSI, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDateGSIsByIDAndDateR", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithDateGSIsByIDAndDateR indicates an expected call of GetThingWithDateGSIsByIDAndDateR.
func (mr *MockInterfaceMockRecorder) GetThingWithDateGSIsByIDAndDateR(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDateGSIsByIDAndDateR", reflect.TypeOf((*MockInterface)(nil).GetThingWithDateGSIsByIDAndDateR), ctx, input, fn)
}

// GetThingWithDateRange mocks base method.
func (m *MockInterface) GetThingWithDateRange(ctx context.Context, name string, date strfmt.DateTime) (*v9.ThingWithDateRange, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDateRange", ctx, name, date)
	ret0, _ := ret[0].(*v9.ThingWithDateRange)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithDateRange indicates an expected call of GetThingWithDateRange.
func (mr *MockInterfaceMockRecorder) GetThingWithDateRange(ctx, name, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDateRange", reflect.TypeOf((*MockInterface)(nil).GetThingWithDateRange), ctx, name, date)
}

// GetThingWithDateRangeKey mocks base method.
func (m *MockInterface) GetThingWithDateRangeKey(ctx context.Context, id string, date strfmt.Date) (*v9.ThingWithDateRangeKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDateRangeKey", ctx, id, date)
	ret0, _ := ret[0].(*v9.ThingWithDateRangeKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithDateRangeKey indicates an expected call of GetThingWithDateRangeKey.
func (mr *MockInterfaceMockRecorder) GetThingWithDateRangeKey(ctx, id, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDateRangeKey", reflect.TypeOf((*MockInterface)(nil).GetThingWithDateRangeKey), ctx, id, date)
}

// GetThingWithDateRangeKeysByIDAndDate mocks base method.
func (m *MockInterface) GetThingWithDateRangeKeysByIDAndDate(ctx context.Context, input GetThingWithDateRangeKeysByIDAndDateInput, fn func(*v9.ThingWithDateRangeKey, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDateRangeKeysByIDAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithDateRangeKeysByIDAndDate indicates an expected call of GetThingWithDateRangeKeysByIDAndDate.
func (mr *MockInterfaceMockRecorder) GetThingWithDateRangeKeysByIDAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDateRangeKeysByIDAndDate", reflect.TypeOf((*MockInterface)(nil).GetThingWithDateRangeKeysByIDAndDate), ctx, input, fn)
}

// GetThingWithDateRangesByNameAndDate mocks base method.
func (m *MockInterface) GetThingWithDateRangesByNameAndDate(ctx context.Context, input GetThingWithDateRangesByNameAndDateInput, fn func(*v9.ThingWithDateRange, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDateRangesByNameAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithDateRangesByNameAndDate indicates an expected call of GetThingWithDateRangesByNameAndDate.
func (mr *MockInterfaceMockRecorder) GetThingWithDateRangesByNameAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDateRangesByNameAndDate", reflect.TypeOf((*MockInterface)(nil).GetThingWithDateRangesByNameAndDate), ctx, input, fn)
}

// GetThingWithDateTimeComposite mocks base method.
func (m *MockInterface) GetThingWithDateTimeComposite(ctx context.Context, typeVar, id string, created strfmt.DateTime, resource string) (*v9.ThingWithDateTimeComposite, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDateTimeComposite", ctx, typeVar, id, created, resource)
	ret0, _ := ret[0].(*v9.ThingWithDateTimeComposite)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithDateTimeComposite indicates an expected call of GetThingWithDateTimeComposite.
func (mr *MockInterfaceMockRecorder) GetThingWithDateTimeComposite(ctx, typeVar, id, created, resource interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDateTimeComposite", reflect.TypeOf((*MockInterface)(nil).GetThingWithDateTimeComposite), ctx, typeVar, id, created, resource)
}

// GetThingWithDateTimeCompositesByTypeIDAndCreatedResource mocks base method.
func (m *MockInterface) GetThingWithDateTimeCompositesByTypeIDAndCreatedResource(ctx context.Context, input GetThingWithDateTimeCompositesByTypeIDAndCreatedResourceInput, fn func(*v9.ThingWithDateTimeComposite, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDateTimeCompositesByTypeIDAndCreatedResource", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithDateTimeCompositesByTypeIDAndCreatedResource indicates an expected call of GetThingWithDateTimeCompositesByTypeIDAndCreatedResource.
func (mr *MockInterfaceMockRecorder) GetThingWithDateTimeCompositesByTypeIDAndCreatedResource(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDateTimeCompositesByTypeIDAndCreatedResource", reflect.TypeOf((*MockInterface)(nil).GetThingWithDateTimeCompositesByTypeIDAndCreatedResource), ctx, input, fn)
}

// GetThingWithDatetimeGSI mocks base method.
func (m *MockInterface) GetThingWithDatetimeGSI(ctx context.Context, id string) (*v9.ThingWithDatetimeGSI, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDatetimeGSI", ctx, id)
	ret0, _ := ret[0].(*v9.ThingWithDatetimeGSI)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithDatetimeGSI indicates an expected call of GetThingWithDatetimeGSI.
func (mr *MockInterfaceMockRecorder) GetThingWithDatetimeGSI(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDatetimeGSI", reflect.TypeOf((*MockInterface)(nil).GetThingWithDatetimeGSI), ctx, id)
}

// GetThingWithDatetimeGSIsByDatetimeAndID mocks base method.
func (m *MockInterface) GetThingWithDatetimeGSIsByDatetimeAndID(ctx context.Context, input GetThingWithDatetimeGSIsByDatetimeAndIDInput, fn func(*v9.ThingWithDatetimeGSI, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithDatetimeGSIsByDatetimeAndID", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithDatetimeGSIsByDatetimeAndID indicates an expected call of GetThingWithDatetimeGSIsByDatetimeAndID.
func (mr *MockInterfaceMockRecorder) GetThingWithDatetimeGSIsByDatetimeAndID(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithDatetimeGSIsByDatetimeAndID", reflect.TypeOf((*MockInterface)(nil).GetThingWithDatetimeGSIsByDatetimeAndID), ctx, input, fn)
}

// GetThingWithEnumHashKey mocks base method.
func (m *MockInterface) GetThingWithEnumHashKey(ctx context.Context, branch v9.Branch, date strfmt.DateTime) (*v9.ThingWithEnumHashKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithEnumHashKey", ctx, branch, date)
	ret0, _ := ret[0].(*v9.ThingWithEnumHashKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithEnumHashKey indicates an expected call of GetThingWithEnumHashKey.
func (mr *MockInterfaceMockRecorder) GetThingWithEnumHashKey(ctx, branch, date interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithEnumHashKey", reflect.TypeOf((*MockInterface)(nil).GetThingWithEnumHashKey), ctx, branch, date)
}

// GetThingWithEnumHashKeysByBranchAndDate mocks base method.
func (m *MockInterface) GetThingWithEnumHashKeysByBranchAndDate(ctx context.Context, input GetThingWithEnumHashKeysByBranchAndDateInput, fn func(*v9.ThingWithEnumHashKey, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithEnumHashKeysByBranchAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithEnumHashKeysByBranchAndDate indicates an expected call of GetThingWithEnumHashKeysByBranchAndDate.
func (mr *MockInterfaceMockRecorder) GetThingWithEnumHashKeysByBranchAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithEnumHashKeysByBranchAndDate", reflect.TypeOf((*MockInterface)(nil).GetThingWithEnumHashKeysByBranchAndDate), ctx, input, fn)
}

// GetThingWithEnumHashKeysByBranchAndDate2 mocks base method.
func (m *MockInterface) GetThingWithEnumHashKeysByBranchAndDate2(ctx context.Context, input GetThingWithEnumHashKeysByBranchAndDate2Input, fn func(*v9.ThingWithEnumHashKey, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithEnumHashKeysByBranchAndDate2", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithEnumHashKeysByBranchAndDate2 indicates an expected call of GetThingWithEnumHashKeysByBranchAndDate2.
func (mr *MockInterfaceMockRecorder) GetThingWithEnumHashKeysByBranchAndDate2(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithEnumHashKeysByBranchAndDate2", reflect.TypeOf((*MockInterface)(nil).GetThingWithEnumHashKeysByBranchAndDate2), ctx, input, fn)
}

// GetThingWithMatchingKeys mocks base method.
func (m *MockInterface) GetThingWithMatchingKeys(ctx context.Context, bear, assocType, assocID string) (*v9.ThingWithMatchingKeys, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithMatchingKeys", ctx, bear, assocType, assocID)
	ret0, _ := ret[0].(*v9.ThingWithMatchingKeys)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithMatchingKeys indicates an expected call of GetThingWithMatchingKeys.
func (mr *MockInterfaceMockRecorder) GetThingWithMatchingKeys(ctx, bear, assocType, assocID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithMatchingKeys", reflect.TypeOf((*MockInterface)(nil).GetThingWithMatchingKeys), ctx, bear, assocType, assocID)
}

// GetThingWithMatchingKeyssByAssocTypeIDAndCreatedBear mocks base method.
func (m *MockInterface) GetThingWithMatchingKeyssByAssocTypeIDAndCreatedBear(ctx context.Context, input GetThingWithMatchingKeyssByAssocTypeIDAndCreatedBearInput, fn func(*v9.ThingWithMatchingKeys, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithMatchingKeyssByAssocTypeIDAndCreatedBear", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithMatchingKeyssByAssocTypeIDAndCreatedBear indicates an expected call of GetThingWithMatchingKeyssByAssocTypeIDAndCreatedBear.
func (mr *MockInterfaceMockRecorder) GetThingWithMatchingKeyssByAssocTypeIDAndCreatedBear(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithMatchingKeyssByAssocTypeIDAndCreatedBear", reflect.TypeOf((*MockInterface)(nil).GetThingWithMatchingKeyssByAssocTypeIDAndCreatedBear), ctx, input, fn)
}

// GetThingWithMatchingKeyssByBearAndAssocTypeID mocks base method.
func (m *MockInterface) GetThingWithMatchingKeyssByBearAndAssocTypeID(ctx context.Context, input GetThingWithMatchingKeyssByBearAndAssocTypeIDInput, fn func(*v9.ThingWithMatchingKeys, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithMatchingKeyssByBearAndAssocTypeID", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithMatchingKeyssByBearAndAssocTypeID indicates an expected call of GetThingWithMatchingKeyssByBearAndAssocTypeID.
func (mr *MockInterfaceMockRecorder) GetThingWithMatchingKeyssByBearAndAssocTypeID(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithMatchingKeyssByBearAndAssocTypeID", reflect.TypeOf((*MockInterface)(nil).GetThingWithMatchingKeyssByBearAndAssocTypeID), ctx, input, fn)
}

// GetThingWithMultiUseCompositeAttribute mocks base method.
func (m *MockInterface) GetThingWithMultiUseCompositeAttribute(ctx context.Context, one string) (*v9.ThingWithMultiUseCompositeAttribute, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithMultiUseCompositeAttribute", ctx, one)
	ret0, _ := ret[0].(*v9.ThingWithMultiUseCompositeAttribute)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithMultiUseCompositeAttribute indicates an expected call of GetThingWithMultiUseCompositeAttribute.
func (mr *MockInterfaceMockRecorder) GetThingWithMultiUseCompositeAttribute(ctx, one interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithMultiUseCompositeAttribute", reflect.TypeOf((*MockInterface)(nil).GetThingWithMultiUseCompositeAttribute), ctx, one)
}

// GetThingWithMultiUseCompositeAttributesByFourAndOneTwo mocks base method.
func (m *MockInterface) GetThingWithMultiUseCompositeAttributesByFourAndOneTwo(ctx context.Context, input GetThingWithMultiUseCompositeAttributesByFourAndOneTwoInput, fn func(*v9.ThingWithMultiUseCompositeAttribute, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithMultiUseCompositeAttributesByFourAndOneTwo", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithMultiUseCompositeAttributesByFourAndOneTwo indicates an expected call of GetThingWithMultiUseCompositeAttributesByFourAndOneTwo.
func (mr *MockInterfaceMockRecorder) GetThingWithMultiUseCompositeAttributesByFourAndOneTwo(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithMultiUseCompositeAttributesByFourAndOneTwo", reflect.TypeOf((*MockInterface)(nil).GetThingWithMultiUseCompositeAttributesByFourAndOneTwo), ctx, input, fn)
}

// GetThingWithMultiUseCompositeAttributesByThreeAndOneTwo mocks base method.
func (m *MockInterface) GetThingWithMultiUseCompositeAttributesByThreeAndOneTwo(ctx context.Context, input GetThingWithMultiUseCompositeAttributesByThreeAndOneTwoInput, fn func(*v9.ThingWithMultiUseCompositeAttribute, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithMultiUseCompositeAttributesByThreeAndOneTwo", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithMultiUseCompositeAttributesByThreeAndOneTwo indicates an expected call of GetThingWithMultiUseCompositeAttributesByThreeAndOneTwo.
func (mr *MockInterfaceMockRecorder) GetThingWithMultiUseCompositeAttributesByThreeAndOneTwo(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithMultiUseCompositeAttributesByThreeAndOneTwo", reflect.TypeOf((*MockInterface)(nil).GetThingWithMultiUseCompositeAttributesByThreeAndOneTwo), ctx, input, fn)
}

// GetThingWithRequiredCompositePropertiesAndKeysOnly mocks base method.
func (m *MockInterface) GetThingWithRequiredCompositePropertiesAndKeysOnly(ctx context.Context, propertyThree string) (*v9.ThingWithRequiredCompositePropertiesAndKeysOnly, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithRequiredCompositePropertiesAndKeysOnly", ctx, propertyThree)
	ret0, _ := ret[0].(*v9.ThingWithRequiredCompositePropertiesAndKeysOnly)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithRequiredCompositePropertiesAndKeysOnly indicates an expected call of GetThingWithRequiredCompositePropertiesAndKeysOnly.
func (mr *MockInterfaceMockRecorder) GetThingWithRequiredCompositePropertiesAndKeysOnly(ctx, propertyThree interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithRequiredCompositePropertiesAndKeysOnly", reflect.TypeOf((*MockInterface)(nil).GetThingWithRequiredCompositePropertiesAndKeysOnly), ctx, propertyThree)
}

// GetThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree mocks base method.
func (m *MockInterface) GetThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree(ctx context.Context, input GetThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThreeInput, fn func(*v9.ThingWithRequiredCompositePropertiesAndKeysOnly, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree indicates an expected call of GetThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree.
func (mr *MockInterfaceMockRecorder) GetThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree", reflect.TypeOf((*MockInterface)(nil).GetThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree), ctx, input, fn)
}

// GetThingWithRequiredFields mocks base method.
func (m *MockInterface) GetThingWithRequiredFields(ctx context.Context, name string) (*v9.ThingWithRequiredFields, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithRequiredFields", ctx, name)
	ret0, _ := ret[0].(*v9.ThingWithRequiredFields)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithRequiredFields indicates an expected call of GetThingWithRequiredFields.
func (mr *MockInterfaceMockRecorder) GetThingWithRequiredFields(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithRequiredFields", reflect.TypeOf((*MockInterface)(nil).GetThingWithRequiredFields), ctx, name)
}

// GetThingWithRequiredFields2 mocks base method.
func (m *MockInterface) GetThingWithRequiredFields2(ctx context.Context, name, id string) (*v9.ThingWithRequiredFields2, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithRequiredFields2", ctx, name, id)
	ret0, _ := ret[0].(*v9.ThingWithRequiredFields2)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithRequiredFields2 indicates an expected call of GetThingWithRequiredFields2.
func (mr *MockInterfaceMockRecorder) GetThingWithRequiredFields2(ctx, name, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithRequiredFields2", reflect.TypeOf((*MockInterface)(nil).GetThingWithRequiredFields2), ctx, name, id)
}

// GetThingWithRequiredFields2sByNameAndID mocks base method.
func (m *MockInterface) GetThingWithRequiredFields2sByNameAndID(ctx context.Context, input GetThingWithRequiredFields2sByNameAndIDInput, fn func(*v9.ThingWithRequiredFields2, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithRequiredFields2sByNameAndID", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithRequiredFields2sByNameAndID indicates an expected call of GetThingWithRequiredFields2sByNameAndID.
func (mr *MockInterfaceMockRecorder) GetThingWithRequiredFields2sByNameAndID(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithRequiredFields2sByNameAndID", reflect.TypeOf((*MockInterface)(nil).GetThingWithRequiredFields2sByNameAndID), ctx, input, fn)
}

// GetThingWithTransactMultipleGSI mocks base method.
func (m *MockInterface) GetThingWithTransactMultipleGSI(ctx context.Context, dateH strfmt.Date) (*v9.ThingWithTransactMultipleGSI, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithTransactMultipleGSI", ctx, dateH)
	ret0, _ := ret[0].(*v9.ThingWithTransactMultipleGSI)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithTransactMultipleGSI indicates an expected call of GetThingWithTransactMultipleGSI.
func (mr *MockInterfaceMockRecorder) GetThingWithTransactMultipleGSI(ctx, dateH interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithTransactMultipleGSI", reflect.TypeOf((*MockInterface)(nil).GetThingWithTransactMultipleGSI), ctx, dateH)
}

// GetThingWithTransactMultipleGSIsByDateHAndID mocks base method.
func (m *MockInterface) GetThingWithTransactMultipleGSIsByDateHAndID(ctx context.Context, input GetThingWithTransactMultipleGSIsByDateHAndIDInput, fn func(*v9.ThingWithTransactMultipleGSI, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithTransactMultipleGSIsByDateHAndID", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithTransactMultipleGSIsByDateHAndID indicates an expected call of GetThingWithTransactMultipleGSIsByDateHAndID.
func (mr *MockInterfaceMockRecorder) GetThingWithTransactMultipleGSIsByDateHAndID(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithTransactMultipleGSIsByDateHAndID", reflect.TypeOf((*MockInterface)(nil).GetThingWithTransactMultipleGSIsByDateHAndID), ctx, input, fn)
}

// GetThingWithTransactMultipleGSIsByIDAndDateR mocks base method.
func (m *MockInterface) GetThingWithTransactMultipleGSIsByIDAndDateR(ctx context.Context, input GetThingWithTransactMultipleGSIsByIDAndDateRInput, fn func(*v9.ThingWithTransactMultipleGSI, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithTransactMultipleGSIsByIDAndDateR", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingWithTransactMultipleGSIsByIDAndDateR indicates an expected call of GetThingWithTransactMultipleGSIsByIDAndDateR.
func (mr *MockInterfaceMockRecorder) GetThingWithTransactMultipleGSIsByIDAndDateR(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithTransactMultipleGSIsByIDAndDateR", reflect.TypeOf((*MockInterface)(nil).GetThingWithTransactMultipleGSIsByIDAndDateR), ctx, input, fn)
}

// GetThingWithTransaction mocks base method.
func (m *MockInterface) GetThingWithTransaction(ctx context.Context, name string) (*v9.ThingWithTransaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithTransaction", ctx, name)
	ret0, _ := ret[0].(*v9.ThingWithTransaction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithTransaction indicates an expected call of GetThingWithTransaction.
func (mr *MockInterfaceMockRecorder) GetThingWithTransaction(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithTransaction", reflect.TypeOf((*MockInterface)(nil).GetThingWithTransaction), ctx, name)
}

// GetThingWithTransactionWithSimpleThing mocks base method.
func (m *MockInterface) GetThingWithTransactionWithSimpleThing(ctx context.Context, name string) (*v9.ThingWithTransactionWithSimpleThing, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithTransactionWithSimpleThing", ctx, name)
	ret0, _ := ret[0].(*v9.ThingWithTransactionWithSimpleThing)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithTransactionWithSimpleThing indicates an expected call of GetThingWithTransactionWithSimpleThing.
func (mr *MockInterfaceMockRecorder) GetThingWithTransactionWithSimpleThing(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithTransactionWithSimpleThing", reflect.TypeOf((*MockInterface)(nil).GetThingWithTransactionWithSimpleThing), ctx, name)
}

// GetThingWithUnderscores mocks base method.
func (m *MockInterface) GetThingWithUnderscores(ctx context.Context, iDApp string) (*v9.ThingWithUnderscores, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingWithUnderscores", ctx, iDApp)
	ret0, _ := ret[0].(*v9.ThingWithUnderscores)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetThingWithUnderscores indicates an expected call of GetThingWithUnderscores.
func (mr *MockInterfaceMockRecorder) GetThingWithUnderscores(ctx, iDApp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingWithUnderscores", reflect.TypeOf((*MockInterface)(nil).GetThingWithUnderscores), ctx, iDApp)
}

// GetThingsByHashNullableAndName mocks base method.
func (m *MockInterface) GetThingsByHashNullableAndName(ctx context.Context, input GetThingsByHashNullableAndNameInput, fn func(*v9.Thing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingsByHashNullableAndName", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingsByHashNullableAndName indicates an expected call of GetThingsByHashNullableAndName.
func (mr *MockInterfaceMockRecorder) GetThingsByHashNullableAndName(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingsByHashNullableAndName", reflect.TypeOf((*MockInterface)(nil).GetThingsByHashNullableAndName), ctx, input, fn)
}

// GetThingsByNameAndCreatedAt mocks base method.
func (m *MockInterface) GetThingsByNameAndCreatedAt(ctx context.Context, input GetThingsByNameAndCreatedAtInput, fn func(*v9.Thing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingsByNameAndCreatedAt", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingsByNameAndCreatedAt indicates an expected call of GetThingsByNameAndCreatedAt.
func (mr *MockInterfaceMockRecorder) GetThingsByNameAndCreatedAt(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingsByNameAndCreatedAt", reflect.TypeOf((*MockInterface)(nil).GetThingsByNameAndCreatedAt), ctx, input, fn)
}

// GetThingsByNameAndRangeNullable mocks base method.
func (m *MockInterface) GetThingsByNameAndRangeNullable(ctx context.Context, input GetThingsByNameAndRangeNullableInput, fn func(*v9.Thing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingsByNameAndRangeNullable", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingsByNameAndRangeNullable indicates an expected call of GetThingsByNameAndRangeNullable.
func (mr *MockInterfaceMockRecorder) GetThingsByNameAndRangeNullable(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingsByNameAndRangeNullable", reflect.TypeOf((*MockInterface)(nil).GetThingsByNameAndRangeNullable), ctx, input, fn)
}

// GetThingsByNameAndVersion mocks base method.
func (m *MockInterface) GetThingsByNameAndVersion(ctx context.Context, input GetThingsByNameAndVersionInput, fn func(*v9.Thing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThingsByNameAndVersion", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetThingsByNameAndVersion indicates an expected call of GetThingsByNameAndVersion.
func (mr *MockInterfaceMockRecorder) GetThingsByNameAndVersion(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThingsByNameAndVersion", reflect.TypeOf((*MockInterface)(nil).GetThingsByNameAndVersion), ctx, input, fn)
}

// SaveArrayOfThingAllowingBatchWrites mocks base method.
func (m *MockInterface) SaveArrayOfThingAllowingBatchWrites(ctx context.Context, ms []v9.ThingAllowingBatchWrites) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveArrayOfThingAllowingBatchWrites", ctx, ms)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveArrayOfThingAllowingBatchWrites indicates an expected call of SaveArrayOfThingAllowingBatchWrites.
func (mr *MockInterfaceMockRecorder) SaveArrayOfThingAllowingBatchWrites(ctx, ms interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveArrayOfThingAllowingBatchWrites", reflect.TypeOf((*MockInterface)(nil).SaveArrayOfThingAllowingBatchWrites), ctx, ms)
}

// SaveArrayOfThingAllowingBatchWritesWithCompositeAttributes mocks base method.
func (m *MockInterface) SaveArrayOfThingAllowingBatchWritesWithCompositeAttributes(ctx context.Context, ms []v9.ThingAllowingBatchWritesWithCompositeAttributes) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveArrayOfThingAllowingBatchWritesWithCompositeAttributes", ctx, ms)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveArrayOfThingAllowingBatchWritesWithCompositeAttributes indicates an expected call of SaveArrayOfThingAllowingBatchWritesWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) SaveArrayOfThingAllowingBatchWritesWithCompositeAttributes(ctx, ms interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveArrayOfThingAllowingBatchWritesWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).SaveArrayOfThingAllowingBatchWritesWithCompositeAttributes), ctx, ms)
}

// SaveDeployment mocks base method.
func (m_2 *MockInterface) SaveDeployment(ctx context.Context, m v9.Deployment) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveDeployment", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveDeployment indicates an expected call of SaveDeployment.
func (mr *MockInterfaceMockRecorder) SaveDeployment(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveDeployment", reflect.TypeOf((*MockInterface)(nil).SaveDeployment), ctx, m)
}

// SaveEvent mocks base method.
func (m_2 *MockInterface) SaveEvent(ctx context.Context, m v9.Event) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveEvent", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveEvent indicates an expected call of SaveEvent.
func (mr *MockInterfaceMockRecorder) SaveEvent(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveEvent", reflect.TypeOf((*MockInterface)(nil).SaveEvent), ctx, m)
}

// SaveNoRangeThingWithCompositeAttributes mocks base method.
func (m_2 *MockInterface) SaveNoRangeThingWithCompositeAttributes(ctx context.Context, m v9.NoRangeThingWithCompositeAttributes) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveNoRangeThingWithCompositeAttributes", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveNoRangeThingWithCompositeAttributes indicates an expected call of SaveNoRangeThingWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) SaveNoRangeThingWithCompositeAttributes(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveNoRangeThingWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).SaveNoRangeThingWithCompositeAttributes), ctx, m)
}

// SaveSimpleThing mocks base method.
func (m_2 *MockInterface) SaveSimpleThing(ctx context.Context, m v9.SimpleThing) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveSimpleThing", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveSimpleThing indicates an expected call of SaveSimpleThing.
func (mr *MockInterfaceMockRecorder) SaveSimpleThing(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSimpleThing", reflect.TypeOf((*MockInterface)(nil).SaveSimpleThing), ctx, m)
}

// SaveTeacherSharingRule mocks base method.
func (m_2 *MockInterface) SaveTeacherSharingRule(ctx context.Context, m v9.TeacherSharingRule) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveTeacherSharingRule", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveTeacherSharingRule indicates an expected call of SaveTeacherSharingRule.
func (mr *MockInterfaceMockRecorder) SaveTeacherSharingRule(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTeacherSharingRule", reflect.TypeOf((*MockInterface)(nil).SaveTeacherSharingRule), ctx, m)
}

// SaveThing mocks base method.
func (m_2 *MockInterface) SaveThing(ctx context.Context, m v9.Thing) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThing", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThing indicates an expected call of SaveThing.
func (mr *MockInterfaceMockRecorder) SaveThing(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThing", reflect.TypeOf((*MockInterface)(nil).SaveThing), ctx, m)
}

// SaveThingAllowingBatchWrites mocks base method.
func (m_2 *MockInterface) SaveThingAllowingBatchWrites(ctx context.Context, m v9.ThingAllowingBatchWrites) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingAllowingBatchWrites", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingAllowingBatchWrites indicates an expected call of SaveThingAllowingBatchWrites.
func (mr *MockInterfaceMockRecorder) SaveThingAllowingBatchWrites(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingAllowingBatchWrites", reflect.TypeOf((*MockInterface)(nil).SaveThingAllowingBatchWrites), ctx, m)
}

// SaveThingAllowingBatchWritesWithCompositeAttributes mocks base method.
func (m_2 *MockInterface) SaveThingAllowingBatchWritesWithCompositeAttributes(ctx context.Context, m v9.ThingAllowingBatchWritesWithCompositeAttributes) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingAllowingBatchWritesWithCompositeAttributes", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingAllowingBatchWritesWithCompositeAttributes indicates an expected call of SaveThingAllowingBatchWritesWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) SaveThingAllowingBatchWritesWithCompositeAttributes(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingAllowingBatchWritesWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).SaveThingAllowingBatchWritesWithCompositeAttributes), ctx, m)
}

// SaveThingWithAdditionalAttributes mocks base method.
func (m_2 *MockInterface) SaveThingWithAdditionalAttributes(ctx context.Context, m v9.ThingWithAdditionalAttributes) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithAdditionalAttributes", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithAdditionalAttributes indicates an expected call of SaveThingWithAdditionalAttributes.
func (mr *MockInterfaceMockRecorder) SaveThingWithAdditionalAttributes(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithAdditionalAttributes", reflect.TypeOf((*MockInterface)(nil).SaveThingWithAdditionalAttributes), ctx, m)
}

// SaveThingWithCompositeAttributes mocks base method.
func (m_2 *MockInterface) SaveThingWithCompositeAttributes(ctx context.Context, m v9.ThingWithCompositeAttributes) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithCompositeAttributes", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithCompositeAttributes indicates an expected call of SaveThingWithCompositeAttributes.
func (mr *MockInterfaceMockRecorder) SaveThingWithCompositeAttributes(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).SaveThingWithCompositeAttributes), ctx, m)
}

// SaveThingWithCompositeEnumAttributes mocks base method.
func (m_2 *MockInterface) SaveThingWithCompositeEnumAttributes(ctx context.Context, m v9.ThingWithCompositeEnumAttributes) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithCompositeEnumAttributes", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithCompositeEnumAttributes indicates an expected call of SaveThingWithCompositeEnumAttributes.
func (mr *MockInterfaceMockRecorder) SaveThingWithCompositeEnumAttributes(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithCompositeEnumAttributes", reflect.TypeOf((*MockInterface)(nil).SaveThingWithCompositeEnumAttributes), ctx, m)
}

// SaveThingWithDateGSI mocks base method.
func (m_2 *MockInterface) SaveThingWithDateGSI(ctx context.Context, m v9.ThingWithDateGSI) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithDateGSI", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithDateGSI indicates an expected call of SaveThingWithDateGSI.
func (mr *MockInterfaceMockRecorder) SaveThingWithDateGSI(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithDateGSI", reflect.TypeOf((*MockInterface)(nil).SaveThingWithDateGSI), ctx, m)
}

// SaveThingWithDateRange mocks base method.
func (m_2 *MockInterface) SaveThingWithDateRange(ctx context.Context, m v9.ThingWithDateRange) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithDateRange", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithDateRange indicates an expected call of SaveThingWithDateRange.
func (mr *MockInterfaceMockRecorder) SaveThingWithDateRange(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithDateRange", reflect.TypeOf((*MockInterface)(nil).SaveThingWithDateRange), ctx, m)
}

// SaveThingWithDateRangeKey mocks base method.
func (m_2 *MockInterface) SaveThingWithDateRangeKey(ctx context.Context, m v9.ThingWithDateRangeKey) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithDateRangeKey", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithDateRangeKey indicates an expected call of SaveThingWithDateRangeKey.
func (mr *MockInterfaceMockRecorder) SaveThingWithDateRangeKey(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithDateRangeKey", reflect.TypeOf((*MockInterface)(nil).SaveThingWithDateRangeKey), ctx, m)
}

// SaveThingWithDateTimeComposite mocks base method.
func (m_2 *MockInterface) SaveThingWithDateTimeComposite(ctx context.Context, m v9.ThingWithDateTimeComposite) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithDateTimeComposite", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithDateTimeComposite indicates an expected call of SaveThingWithDateTimeComposite.
func (mr *MockInterfaceMockRecorder) SaveThingWithDateTimeComposite(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithDateTimeComposite", reflect.TypeOf((*MockInterface)(nil).SaveThingWithDateTimeComposite), ctx, m)
}

// SaveThingWithDatetimeGSI mocks base method.
func (m_2 *MockInterface) SaveThingWithDatetimeGSI(ctx context.Context, m v9.ThingWithDatetimeGSI) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithDatetimeGSI", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithDatetimeGSI indicates an expected call of SaveThingWithDatetimeGSI.
func (mr *MockInterfaceMockRecorder) SaveThingWithDatetimeGSI(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithDatetimeGSI", reflect.TypeOf((*MockInterface)(nil).SaveThingWithDatetimeGSI), ctx, m)
}

// SaveThingWithEnumHashKey mocks base method.
func (m_2 *MockInterface) SaveThingWithEnumHashKey(ctx context.Context, m v9.ThingWithEnumHashKey) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithEnumHashKey", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithEnumHashKey indicates an expected call of SaveThingWithEnumHashKey.
func (mr *MockInterfaceMockRecorder) SaveThingWithEnumHashKey(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithEnumHashKey", reflect.TypeOf((*MockInterface)(nil).SaveThingWithEnumHashKey), ctx, m)
}

// SaveThingWithMatchingKeys mocks base method.
func (m_2 *MockInterface) SaveThingWithMatchingKeys(ctx context.Context, m v9.ThingWithMatchingKeys) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithMatchingKeys", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithMatchingKeys indicates an expected call of SaveThingWithMatchingKeys.
func (mr *MockInterfaceMockRecorder) SaveThingWithMatchingKeys(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithMatchingKeys", reflect.TypeOf((*MockInterface)(nil).SaveThingWithMatchingKeys), ctx, m)
}

// SaveThingWithMultiUseCompositeAttribute mocks base method.
func (m_2 *MockInterface) SaveThingWithMultiUseCompositeAttribute(ctx context.Context, m v9.ThingWithMultiUseCompositeAttribute) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithMultiUseCompositeAttribute", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithMultiUseCompositeAttribute indicates an expected call of SaveThingWithMultiUseCompositeAttribute.
func (mr *MockInterfaceMockRecorder) SaveThingWithMultiUseCompositeAttribute(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithMultiUseCompositeAttribute", reflect.TypeOf((*MockInterface)(nil).SaveThingWithMultiUseCompositeAttribute), ctx, m)
}

// SaveThingWithRequiredCompositePropertiesAndKeysOnly mocks base method.
func (m_2 *MockInterface) SaveThingWithRequiredCompositePropertiesAndKeysOnly(ctx context.Context, m v9.ThingWithRequiredCompositePropertiesAndKeysOnly) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithRequiredCompositePropertiesAndKeysOnly", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithRequiredCompositePropertiesAndKeysOnly indicates an expected call of SaveThingWithRequiredCompositePropertiesAndKeysOnly.
func (mr *MockInterfaceMockRecorder) SaveThingWithRequiredCompositePropertiesAndKeysOnly(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithRequiredCompositePropertiesAndKeysOnly", reflect.TypeOf((*MockInterface)(nil).SaveThingWithRequiredCompositePropertiesAndKeysOnly), ctx, m)
}

// SaveThingWithRequiredFields mocks base method.
func (m_2 *MockInterface) SaveThingWithRequiredFields(ctx context.Context, m v9.ThingWithRequiredFields) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithRequiredFields", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithRequiredFields indicates an expected call of SaveThingWithRequiredFields.
func (mr *MockInterfaceMockRecorder) SaveThingWithRequiredFields(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithRequiredFields", reflect.TypeOf((*MockInterface)(nil).SaveThingWithRequiredFields), ctx, m)
}

// SaveThingWithRequiredFields2 mocks base method.
func (m_2 *MockInterface) SaveThingWithRequiredFields2(ctx context.Context, m v9.ThingWithRequiredFields2) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithRequiredFields2", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithRequiredFields2 indicates an expected call of SaveThingWithRequiredFields2.
func (mr *MockInterfaceMockRecorder) SaveThingWithRequiredFields2(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithRequiredFields2", reflect.TypeOf((*MockInterface)(nil).SaveThingWithRequiredFields2), ctx, m)
}

// SaveThingWithTransactMultipleGSI mocks base method.
func (m_2 *MockInterface) SaveThingWithTransactMultipleGSI(ctx context.Context, m v9.ThingWithTransactMultipleGSI) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithTransactMultipleGSI", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithTransactMultipleGSI indicates an expected call of SaveThingWithTransactMultipleGSI.
func (mr *MockInterfaceMockRecorder) SaveThingWithTransactMultipleGSI(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithTransactMultipleGSI", reflect.TypeOf((*MockInterface)(nil).SaveThingWithTransactMultipleGSI), ctx, m)
}

// SaveThingWithTransaction mocks base method.
func (m_2 *MockInterface) SaveThingWithTransaction(ctx context.Context, m v9.ThingWithTransaction) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithTransaction", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithTransaction indicates an expected call of SaveThingWithTransaction.
func (mr *MockInterfaceMockRecorder) SaveThingWithTransaction(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithTransaction", reflect.TypeOf((*MockInterface)(nil).SaveThingWithTransaction), ctx, m)
}

// SaveThingWithTransactionWithSimpleThing mocks base method.
func (m_2 *MockInterface) SaveThingWithTransactionWithSimpleThing(ctx context.Context, m v9.ThingWithTransactionWithSimpleThing) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithTransactionWithSimpleThing", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithTransactionWithSimpleThing indicates an expected call of SaveThingWithTransactionWithSimpleThing.
func (mr *MockInterfaceMockRecorder) SaveThingWithTransactionWithSimpleThing(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithTransactionWithSimpleThing", reflect.TypeOf((*MockInterface)(nil).SaveThingWithTransactionWithSimpleThing), ctx, m)
}

// SaveThingWithUnderscores mocks base method.
func (m_2 *MockInterface) SaveThingWithUnderscores(ctx context.Context, m v9.ThingWithUnderscores) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SaveThingWithUnderscores", ctx, m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveThingWithUnderscores indicates an expected call of SaveThingWithUnderscores.
func (mr *MockInterfaceMockRecorder) SaveThingWithUnderscores(ctx, m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveThingWithUnderscores", reflect.TypeOf((*MockInterface)(nil).SaveThingWithUnderscores), ctx, m)
}

// ScanDeployments mocks base method.
func (m *MockInterface) ScanDeployments(ctx context.Context, input ScanDeploymentsInput, fn func(*v9.Deployment, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanDeployments", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanDeployments indicates an expected call of ScanDeployments.
func (mr *MockInterfaceMockRecorder) ScanDeployments(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanDeployments", reflect.TypeOf((*MockInterface)(nil).ScanDeployments), ctx, input, fn)
}

// ScanDeploymentsByEnvAppAndDate mocks base method.
func (m *MockInterface) ScanDeploymentsByEnvAppAndDate(ctx context.Context, input ScanDeploymentsByEnvAppAndDateInput, fn func(*v9.Deployment, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanDeploymentsByEnvAppAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanDeploymentsByEnvAppAndDate indicates an expected call of ScanDeploymentsByEnvAppAndDate.
func (mr *MockInterfaceMockRecorder) ScanDeploymentsByEnvAppAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanDeploymentsByEnvAppAndDate", reflect.TypeOf((*MockInterface)(nil).ScanDeploymentsByEnvAppAndDate), ctx, input, fn)
}

// ScanDeploymentsByVersion mocks base method.
func (m *MockInterface) ScanDeploymentsByVersion(ctx context.Context, input ScanDeploymentsByVersionInput, fn func(*v9.Deployment, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanDeploymentsByVersion", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanDeploymentsByVersion indicates an expected call of ScanDeploymentsByVersion.
func (mr *MockInterfaceMockRecorder) ScanDeploymentsByVersion(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanDeploymentsByVersion", reflect.TypeOf((*MockInterface)(nil).ScanDeploymentsByVersion), ctx, input, fn)
}

// ScanEvents mocks base method.
func (m *MockInterface) ScanEvents(ctx context.Context, input ScanEventsInput, fn func(*v9.Event, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanEvents", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanEvents indicates an expected call of ScanEvents.
func (mr *MockInterfaceMockRecorder) ScanEvents(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanEvents", reflect.TypeOf((*MockInterface)(nil).ScanEvents), ctx, input, fn)
}

// ScanEventsBySkAndData mocks base method.
func (m *MockInterface) ScanEventsBySkAndData(ctx context.Context, input ScanEventsBySkAndDataInput, fn func(*v9.Event, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanEventsBySkAndData", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanEventsBySkAndData indicates an expected call of ScanEventsBySkAndData.
func (mr *MockInterfaceMockRecorder) ScanEventsBySkAndData(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanEventsBySkAndData", reflect.TypeOf((*MockInterface)(nil).ScanEventsBySkAndData), ctx, input, fn)
}

// ScanNoRangeThingWithCompositeAttributess mocks base method.
func (m *MockInterface) ScanNoRangeThingWithCompositeAttributess(ctx context.Context, input ScanNoRangeThingWithCompositeAttributessInput, fn func(*v9.NoRangeThingWithCompositeAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanNoRangeThingWithCompositeAttributess", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanNoRangeThingWithCompositeAttributess indicates an expected call of ScanNoRangeThingWithCompositeAttributess.
func (mr *MockInterfaceMockRecorder) ScanNoRangeThingWithCompositeAttributess(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanNoRangeThingWithCompositeAttributess", reflect.TypeOf((*MockInterface)(nil).ScanNoRangeThingWithCompositeAttributess), ctx, input, fn)
}

// ScanNoRangeThingWithCompositeAttributessByNameVersionAndDate mocks base method.
func (m *MockInterface) ScanNoRangeThingWithCompositeAttributessByNameVersionAndDate(ctx context.Context, input ScanNoRangeThingWithCompositeAttributessByNameVersionAndDateInput, fn func(*v9.NoRangeThingWithCompositeAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanNoRangeThingWithCompositeAttributessByNameVersionAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanNoRangeThingWithCompositeAttributessByNameVersionAndDate indicates an expected call of ScanNoRangeThingWithCompositeAttributessByNameVersionAndDate.
func (mr *MockInterfaceMockRecorder) ScanNoRangeThingWithCompositeAttributessByNameVersionAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanNoRangeThingWithCompositeAttributessByNameVersionAndDate", reflect.TypeOf((*MockInterface)(nil).ScanNoRangeThingWithCompositeAttributessByNameVersionAndDate), ctx, input, fn)
}

// ScanSimpleThings mocks base method.
func (m *MockInterface) ScanSimpleThings(ctx context.Context, input ScanSimpleThingsInput, fn func(*v9.SimpleThing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanSimpleThings", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanSimpleThings indicates an expected call of ScanSimpleThings.
func (mr *MockInterfaceMockRecorder) ScanSimpleThings(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanSimpleThings", reflect.TypeOf((*MockInterface)(nil).ScanSimpleThings), ctx, input, fn)
}

// ScanTeacherSharingRules mocks base method.
func (m *MockInterface) ScanTeacherSharingRules(ctx context.Context, input ScanTeacherSharingRulesInput, fn func(*v9.TeacherSharingRule, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanTeacherSharingRules", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanTeacherSharingRules indicates an expected call of ScanTeacherSharingRules.
func (mr *MockInterfaceMockRecorder) ScanTeacherSharingRules(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanTeacherSharingRules", reflect.TypeOf((*MockInterface)(nil).ScanTeacherSharingRules), ctx, input, fn)
}

// ScanTeacherSharingRulesByDistrictAndSchoolTeacherApp mocks base method.
func (m *MockInterface) ScanTeacherSharingRulesByDistrictAndSchoolTeacherApp(ctx context.Context, input ScanTeacherSharingRulesByDistrictAndSchoolTeacherAppInput, fn func(*v9.TeacherSharingRule, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanTeacherSharingRulesByDistrictAndSchoolTeacherApp", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanTeacherSharingRulesByDistrictAndSchoolTeacherApp indicates an expected call of ScanTeacherSharingRulesByDistrictAndSchoolTeacherApp.
func (mr *MockInterfaceMockRecorder) ScanTeacherSharingRulesByDistrictAndSchoolTeacherApp(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanTeacherSharingRulesByDistrictAndSchoolTeacherApp", reflect.TypeOf((*MockInterface)(nil).ScanTeacherSharingRulesByDistrictAndSchoolTeacherApp), ctx, input, fn)
}

// ScanThingAllowingBatchWritesWithCompositeAttributess mocks base method.
func (m *MockInterface) ScanThingAllowingBatchWritesWithCompositeAttributess(ctx context.Context, input ScanThingAllowingBatchWritesWithCompositeAttributessInput, fn func(*v9.ThingAllowingBatchWritesWithCompositeAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingAllowingBatchWritesWithCompositeAttributess", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingAllowingBatchWritesWithCompositeAttributess indicates an expected call of ScanThingAllowingBatchWritesWithCompositeAttributess.
func (mr *MockInterfaceMockRecorder) ScanThingAllowingBatchWritesWithCompositeAttributess(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingAllowingBatchWritesWithCompositeAttributess", reflect.TypeOf((*MockInterface)(nil).ScanThingAllowingBatchWritesWithCompositeAttributess), ctx, input, fn)
}

// ScanThingAllowingBatchWritess mocks base method.
func (m *MockInterface) ScanThingAllowingBatchWritess(ctx context.Context, input ScanThingAllowingBatchWritessInput, fn func(*v9.ThingAllowingBatchWrites, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingAllowingBatchWritess", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingAllowingBatchWritess indicates an expected call of ScanThingAllowingBatchWritess.
func (mr *MockInterfaceMockRecorder) ScanThingAllowingBatchWritess(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingAllowingBatchWritess", reflect.TypeOf((*MockInterface)(nil).ScanThingAllowingBatchWritess), ctx, input, fn)
}

// ScanThingWithAdditionalAttributess mocks base method.
func (m *MockInterface) ScanThingWithAdditionalAttributess(ctx context.Context, input ScanThingWithAdditionalAttributessInput, fn func(*v9.ThingWithAdditionalAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithAdditionalAttributess", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithAdditionalAttributess indicates an expected call of ScanThingWithAdditionalAttributess.
func (mr *MockInterfaceMockRecorder) ScanThingWithAdditionalAttributess(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithAdditionalAttributess", reflect.TypeOf((*MockInterface)(nil).ScanThingWithAdditionalAttributess), ctx, input, fn)
}

// ScanThingWithAdditionalAttributessByID mocks base method.
func (m *MockInterface) ScanThingWithAdditionalAttributessByID(ctx context.Context, input ScanThingWithAdditionalAttributessByIDInput, fn func(*v9.ThingWithAdditionalAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithAdditionalAttributessByID", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithAdditionalAttributessByID indicates an expected call of ScanThingWithAdditionalAttributessByID.
func (mr *MockInterfaceMockRecorder) ScanThingWithAdditionalAttributessByID(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithAdditionalAttributessByID", reflect.TypeOf((*MockInterface)(nil).ScanThingWithAdditionalAttributessByID), ctx, input, fn)
}

// ScanThingWithAdditionalAttributessByNameAndCreatedAt mocks base method.
func (m *MockInterface) ScanThingWithAdditionalAttributessByNameAndCreatedAt(ctx context.Context, input ScanThingWithAdditionalAttributessByNameAndCreatedAtInput, fn func(*v9.ThingWithAdditionalAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithAdditionalAttributessByNameAndCreatedAt", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithAdditionalAttributessByNameAndCreatedAt indicates an expected call of ScanThingWithAdditionalAttributessByNameAndCreatedAt.
func (mr *MockInterfaceMockRecorder) ScanThingWithAdditionalAttributessByNameAndCreatedAt(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithAdditionalAttributessByNameAndCreatedAt", reflect.TypeOf((*MockInterface)(nil).ScanThingWithAdditionalAttributessByNameAndCreatedAt), ctx, input, fn)
}

// ScanThingWithAdditionalAttributessByNameAndRangeNullable mocks base method.
func (m *MockInterface) ScanThingWithAdditionalAttributessByNameAndRangeNullable(ctx context.Context, input ScanThingWithAdditionalAttributessByNameAndRangeNullableInput, fn func(*v9.ThingWithAdditionalAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithAdditionalAttributessByNameAndRangeNullable", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithAdditionalAttributessByNameAndRangeNullable indicates an expected call of ScanThingWithAdditionalAttributessByNameAndRangeNullable.
func (mr *MockInterfaceMockRecorder) ScanThingWithAdditionalAttributessByNameAndRangeNullable(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithAdditionalAttributessByNameAndRangeNullable", reflect.TypeOf((*MockInterface)(nil).ScanThingWithAdditionalAttributessByNameAndRangeNullable), ctx, input, fn)
}

// ScanThingWithCompositeAttributess mocks base method.
func (m *MockInterface) ScanThingWithCompositeAttributess(ctx context.Context, input ScanThingWithCompositeAttributessInput, fn func(*v9.ThingWithCompositeAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithCompositeAttributess", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithCompositeAttributess indicates an expected call of ScanThingWithCompositeAttributess.
func (mr *MockInterfaceMockRecorder) ScanThingWithCompositeAttributess(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithCompositeAttributess", reflect.TypeOf((*MockInterface)(nil).ScanThingWithCompositeAttributess), ctx, input, fn)
}

// ScanThingWithCompositeAttributessByNameVersionAndDate mocks base method.
func (m *MockInterface) ScanThingWithCompositeAttributessByNameVersionAndDate(ctx context.Context, input ScanThingWithCompositeAttributessByNameVersionAndDateInput, fn func(*v9.ThingWithCompositeAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithCompositeAttributessByNameVersionAndDate", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithCompositeAttributessByNameVersionAndDate indicates an expected call of ScanThingWithCompositeAttributessByNameVersionAndDate.
func (mr *MockInterfaceMockRecorder) ScanThingWithCompositeAttributessByNameVersionAndDate(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithCompositeAttributessByNameVersionAndDate", reflect.TypeOf((*MockInterface)(nil).ScanThingWithCompositeAttributessByNameVersionAndDate), ctx, input, fn)
}

// ScanThingWithCompositeEnumAttributess mocks base method.
func (m *MockInterface) ScanThingWithCompositeEnumAttributess(ctx context.Context, input ScanThingWithCompositeEnumAttributessInput, fn func(*v9.ThingWithCompositeEnumAttributes, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithCompositeEnumAttributess", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithCompositeEnumAttributess indicates an expected call of ScanThingWithCompositeEnumAttributess.
func (mr *MockInterfaceMockRecorder) ScanThingWithCompositeEnumAttributess(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithCompositeEnumAttributess", reflect.TypeOf((*MockInterface)(nil).ScanThingWithCompositeEnumAttributess), ctx, input, fn)
}

// ScanThingWithDateGSIs mocks base method.
func (m *MockInterface) ScanThingWithDateGSIs(ctx context.Context, input ScanThingWithDateGSIsInput, fn func(*v9.ThingWithDateGSI, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithDateGSIs", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithDateGSIs indicates an expected call of ScanThingWithDateGSIs.
func (mr *MockInterfaceMockRecorder) ScanThingWithDateGSIs(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithDateGSIs", reflect.TypeOf((*MockInterface)(nil).ScanThingWithDateGSIs), ctx, input, fn)
}

// ScanThingWithDateRangeKeys mocks base method.
func (m *MockInterface) ScanThingWithDateRangeKeys(ctx context.Context, input ScanThingWithDateRangeKeysInput, fn func(*v9.ThingWithDateRangeKey, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithDateRangeKeys", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithDateRangeKeys indicates an expected call of ScanThingWithDateRangeKeys.
func (mr *MockInterfaceMockRecorder) ScanThingWithDateRangeKeys(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithDateRangeKeys", reflect.TypeOf((*MockInterface)(nil).ScanThingWithDateRangeKeys), ctx, input, fn)
}

// ScanThingWithDateRanges mocks base method.
func (m *MockInterface) ScanThingWithDateRanges(ctx context.Context, input ScanThingWithDateRangesInput, fn func(*v9.ThingWithDateRange, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithDateRanges", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithDateRanges indicates an expected call of ScanThingWithDateRanges.
func (mr *MockInterfaceMockRecorder) ScanThingWithDateRanges(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithDateRanges", reflect.TypeOf((*MockInterface)(nil).ScanThingWithDateRanges), ctx, input, fn)
}

// ScanThingWithDateTimeComposites mocks base method.
func (m *MockInterface) ScanThingWithDateTimeComposites(ctx context.Context, input ScanThingWithDateTimeCompositesInput, fn func(*v9.ThingWithDateTimeComposite, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithDateTimeComposites", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithDateTimeComposites indicates an expected call of ScanThingWithDateTimeComposites.
func (mr *MockInterfaceMockRecorder) ScanThingWithDateTimeComposites(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithDateTimeComposites", reflect.TypeOf((*MockInterface)(nil).ScanThingWithDateTimeComposites), ctx, input, fn)
}

// ScanThingWithDatetimeGSIs mocks base method.
func (m *MockInterface) ScanThingWithDatetimeGSIs(ctx context.Context, input ScanThingWithDatetimeGSIsInput, fn func(*v9.ThingWithDatetimeGSI, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithDatetimeGSIs", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithDatetimeGSIs indicates an expected call of ScanThingWithDatetimeGSIs.
func (mr *MockInterfaceMockRecorder) ScanThingWithDatetimeGSIs(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithDatetimeGSIs", reflect.TypeOf((*MockInterface)(nil).ScanThingWithDatetimeGSIs), ctx, input, fn)
}

// ScanThingWithDatetimeGSIsByDatetimeAndID mocks base method.
func (m *MockInterface) ScanThingWithDatetimeGSIsByDatetimeAndID(ctx context.Context, input ScanThingWithDatetimeGSIsByDatetimeAndIDInput, fn func(*v9.ThingWithDatetimeGSI, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithDatetimeGSIsByDatetimeAndID", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithDatetimeGSIsByDatetimeAndID indicates an expected call of ScanThingWithDatetimeGSIsByDatetimeAndID.
func (mr *MockInterfaceMockRecorder) ScanThingWithDatetimeGSIsByDatetimeAndID(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithDatetimeGSIsByDatetimeAndID", reflect.TypeOf((*MockInterface)(nil).ScanThingWithDatetimeGSIsByDatetimeAndID), ctx, input, fn)
}

// ScanThingWithEnumHashKeys mocks base method.
func (m *MockInterface) ScanThingWithEnumHashKeys(ctx context.Context, input ScanThingWithEnumHashKeysInput, fn func(*v9.ThingWithEnumHashKey, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithEnumHashKeys", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithEnumHashKeys indicates an expected call of ScanThingWithEnumHashKeys.
func (mr *MockInterfaceMockRecorder) ScanThingWithEnumHashKeys(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithEnumHashKeys", reflect.TypeOf((*MockInterface)(nil).ScanThingWithEnumHashKeys), ctx, input, fn)
}

// ScanThingWithEnumHashKeysByBranchAndDate2 mocks base method.
func (m *MockInterface) ScanThingWithEnumHashKeysByBranchAndDate2(ctx context.Context, input ScanThingWithEnumHashKeysByBranchAndDate2Input, fn func(*v9.ThingWithEnumHashKey, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithEnumHashKeysByBranchAndDate2", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithEnumHashKeysByBranchAndDate2 indicates an expected call of ScanThingWithEnumHashKeysByBranchAndDate2.
func (mr *MockInterfaceMockRecorder) ScanThingWithEnumHashKeysByBranchAndDate2(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithEnumHashKeysByBranchAndDate2", reflect.TypeOf((*MockInterface)(nil).ScanThingWithEnumHashKeysByBranchAndDate2), ctx, input, fn)
}

// ScanThingWithMatchingKeyss mocks base method.
func (m *MockInterface) ScanThingWithMatchingKeyss(ctx context.Context, input ScanThingWithMatchingKeyssInput, fn func(*v9.ThingWithMatchingKeys, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithMatchingKeyss", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithMatchingKeyss indicates an expected call of ScanThingWithMatchingKeyss.
func (mr *MockInterfaceMockRecorder) ScanThingWithMatchingKeyss(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithMatchingKeyss", reflect.TypeOf((*MockInterface)(nil).ScanThingWithMatchingKeyss), ctx, input, fn)
}

// ScanThingWithMatchingKeyssByAssocTypeIDAndCreatedBear mocks base method.
func (m *MockInterface) ScanThingWithMatchingKeyssByAssocTypeIDAndCreatedBear(ctx context.Context, input ScanThingWithMatchingKeyssByAssocTypeIDAndCreatedBearInput, fn func(*v9.ThingWithMatchingKeys, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithMatchingKeyssByAssocTypeIDAndCreatedBear", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithMatchingKeyssByAssocTypeIDAndCreatedBear indicates an expected call of ScanThingWithMatchingKeyssByAssocTypeIDAndCreatedBear.
func (mr *MockInterfaceMockRecorder) ScanThingWithMatchingKeyssByAssocTypeIDAndCreatedBear(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithMatchingKeyssByAssocTypeIDAndCreatedBear", reflect.TypeOf((*MockInterface)(nil).ScanThingWithMatchingKeyssByAssocTypeIDAndCreatedBear), ctx, input, fn)
}

// ScanThingWithMultiUseCompositeAttributes mocks base method.
func (m *MockInterface) ScanThingWithMultiUseCompositeAttributes(ctx context.Context, input ScanThingWithMultiUseCompositeAttributesInput, fn func(*v9.ThingWithMultiUseCompositeAttribute, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithMultiUseCompositeAttributes", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithMultiUseCompositeAttributes indicates an expected call of ScanThingWithMultiUseCompositeAttributes.
func (mr *MockInterfaceMockRecorder) ScanThingWithMultiUseCompositeAttributes(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithMultiUseCompositeAttributes", reflect.TypeOf((*MockInterface)(nil).ScanThingWithMultiUseCompositeAttributes), ctx, input, fn)
}

// ScanThingWithMultiUseCompositeAttributesByFourAndOneTwo mocks base method.
func (m *MockInterface) ScanThingWithMultiUseCompositeAttributesByFourAndOneTwo(ctx context.Context, input ScanThingWithMultiUseCompositeAttributesByFourAndOneTwoInput, fn func(*v9.ThingWithMultiUseCompositeAttribute, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithMultiUseCompositeAttributesByFourAndOneTwo", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithMultiUseCompositeAttributesByFourAndOneTwo indicates an expected call of ScanThingWithMultiUseCompositeAttributesByFourAndOneTwo.
func (mr *MockInterfaceMockRecorder) ScanThingWithMultiUseCompositeAttributesByFourAndOneTwo(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithMultiUseCompositeAttributesByFourAndOneTwo", reflect.TypeOf((*MockInterface)(nil).ScanThingWithMultiUseCompositeAttributesByFourAndOneTwo), ctx, input, fn)
}

// ScanThingWithMultiUseCompositeAttributesByThreeAndOneTwo mocks base method.
func (m *MockInterface) ScanThingWithMultiUseCompositeAttributesByThreeAndOneTwo(ctx context.Context, input ScanThingWithMultiUseCompositeAttributesByThreeAndOneTwoInput, fn func(*v9.ThingWithMultiUseCompositeAttribute, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithMultiUseCompositeAttributesByThreeAndOneTwo", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithMultiUseCompositeAttributesByThreeAndOneTwo indicates an expected call of ScanThingWithMultiUseCompositeAttributesByThreeAndOneTwo.
func (mr *MockInterfaceMockRecorder) ScanThingWithMultiUseCompositeAttributesByThreeAndOneTwo(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithMultiUseCompositeAttributesByThreeAndOneTwo", reflect.TypeOf((*MockInterface)(nil).ScanThingWithMultiUseCompositeAttributesByThreeAndOneTwo), ctx, input, fn)
}

// ScanThingWithRequiredCompositePropertiesAndKeysOnlys mocks base method.
func (m *MockInterface) ScanThingWithRequiredCompositePropertiesAndKeysOnlys(ctx context.Context, input ScanThingWithRequiredCompositePropertiesAndKeysOnlysInput, fn func(*v9.ThingWithRequiredCompositePropertiesAndKeysOnly, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithRequiredCompositePropertiesAndKeysOnlys", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithRequiredCompositePropertiesAndKeysOnlys indicates an expected call of ScanThingWithRequiredCompositePropertiesAndKeysOnlys.
func (mr *MockInterfaceMockRecorder) ScanThingWithRequiredCompositePropertiesAndKeysOnlys(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithRequiredCompositePropertiesAndKeysOnlys", reflect.TypeOf((*MockInterface)(nil).ScanThingWithRequiredCompositePropertiesAndKeysOnlys), ctx, input, fn)
}

// ScanThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree mocks base method.
func (m *MockInterface) ScanThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree(ctx context.Context, input ScanThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThreeInput, fn func(*v9.ThingWithRequiredCompositePropertiesAndKeysOnly, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree indicates an expected call of ScanThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree.
func (mr *MockInterfaceMockRecorder) ScanThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree", reflect.TypeOf((*MockInterface)(nil).ScanThingWithRequiredCompositePropertiesAndKeysOnlysByPropertyOneAndTwoAndPropertyThree), ctx, input, fn)
}

// ScanThingWithRequiredFields2s mocks base method.
func (m *MockInterface) ScanThingWithRequiredFields2s(ctx context.Context, input ScanThingWithRequiredFields2sInput, fn func(*v9.ThingWithRequiredFields2, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithRequiredFields2s", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithRequiredFields2s indicates an expected call of ScanThingWithRequiredFields2s.
func (mr *MockInterfaceMockRecorder) ScanThingWithRequiredFields2s(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithRequiredFields2s", reflect.TypeOf((*MockInterface)(nil).ScanThingWithRequiredFields2s), ctx, input, fn)
}

// ScanThingWithRequiredFieldss mocks base method.
func (m *MockInterface) ScanThingWithRequiredFieldss(ctx context.Context, input ScanThingWithRequiredFieldssInput, fn func(*v9.ThingWithRequiredFields, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithRequiredFieldss", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithRequiredFieldss indicates an expected call of ScanThingWithRequiredFieldss.
func (mr *MockInterfaceMockRecorder) ScanThingWithRequiredFieldss(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithRequiredFieldss", reflect.TypeOf((*MockInterface)(nil).ScanThingWithRequiredFieldss), ctx, input, fn)
}

// ScanThingWithTransactMultipleGSIs mocks base method.
func (m *MockInterface) ScanThingWithTransactMultipleGSIs(ctx context.Context, input ScanThingWithTransactMultipleGSIsInput, fn func(*v9.ThingWithTransactMultipleGSI, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithTransactMultipleGSIs", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithTransactMultipleGSIs indicates an expected call of ScanThingWithTransactMultipleGSIs.
func (mr *MockInterfaceMockRecorder) ScanThingWithTransactMultipleGSIs(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithTransactMultipleGSIs", reflect.TypeOf((*MockInterface)(nil).ScanThingWithTransactMultipleGSIs), ctx, input, fn)
}

// ScanThingWithTransactionWithSimpleThings mocks base method.
func (m *MockInterface) ScanThingWithTransactionWithSimpleThings(ctx context.Context, input ScanThingWithTransactionWithSimpleThingsInput, fn func(*v9.ThingWithTransactionWithSimpleThing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithTransactionWithSimpleThings", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithTransactionWithSimpleThings indicates an expected call of ScanThingWithTransactionWithSimpleThings.
func (mr *MockInterfaceMockRecorder) ScanThingWithTransactionWithSimpleThings(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithTransactionWithSimpleThings", reflect.TypeOf((*MockInterface)(nil).ScanThingWithTransactionWithSimpleThings), ctx, input, fn)
}

// ScanThingWithTransactions mocks base method.
func (m *MockInterface) ScanThingWithTransactions(ctx context.Context, input ScanThingWithTransactionsInput, fn func(*v9.ThingWithTransaction, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingWithTransactions", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingWithTransactions indicates an expected call of ScanThingWithTransactions.
func (mr *MockInterfaceMockRecorder) ScanThingWithTransactions(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingWithTransactions", reflect.TypeOf((*MockInterface)(nil).ScanThingWithTransactions), ctx, input, fn)
}

// ScanThings mocks base method.
func (m *MockInterface) ScanThings(ctx context.Context, input ScanThingsInput, fn func(*v9.Thing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThings", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThings indicates an expected call of ScanThings.
func (mr *MockInterfaceMockRecorder) ScanThings(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThings", reflect.TypeOf((*MockInterface)(nil).ScanThings), ctx, input, fn)
}

// ScanThingsByID mocks base method.
func (m *MockInterface) ScanThingsByID(ctx context.Context, input ScanThingsByIDInput, fn func(*v9.Thing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingsByID", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingsByID indicates an expected call of ScanThingsByID.
func (mr *MockInterfaceMockRecorder) ScanThingsByID(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingsByID", reflect.TypeOf((*MockInterface)(nil).ScanThingsByID), ctx, input, fn)
}

// ScanThingsByNameAndCreatedAt mocks base method.
func (m *MockInterface) ScanThingsByNameAndCreatedAt(ctx context.Context, input ScanThingsByNameAndCreatedAtInput, fn func(*v9.Thing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingsByNameAndCreatedAt", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingsByNameAndCreatedAt indicates an expected call of ScanThingsByNameAndCreatedAt.
func (mr *MockInterfaceMockRecorder) ScanThingsByNameAndCreatedAt(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingsByNameAndCreatedAt", reflect.TypeOf((*MockInterface)(nil).ScanThingsByNameAndCreatedAt), ctx, input, fn)
}

// ScanThingsByNameAndRangeNullable mocks base method.
func (m *MockInterface) ScanThingsByNameAndRangeNullable(ctx context.Context, input ScanThingsByNameAndRangeNullableInput, fn func(*v9.Thing, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanThingsByNameAndRangeNullable", ctx, input, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanThingsByNameAndRangeNullable indicates an expected call of ScanThingsByNameAndRangeNullable.
func (mr *MockInterfaceMockRecorder) ScanThingsByNameAndRangeNullable(ctx, input, fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanThingsByNameAndRangeNullable", reflect.TypeOf((*MockInterface)(nil).ScanThingsByNameAndRangeNullable), ctx, input, fn)
}

// TransactSaveThingWithTransactMultipleGSIAndThing mocks base method.
func (m *MockInterface) TransactSaveThingWithTransactMultipleGSIAndThing(ctx context.Context, m1 v9.ThingWithTransactMultipleGSI, m1Conditions *expression.ConditionBuilder, m2 v9.Thing, m2Conditions *expression.ConditionBuilder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactSaveThingWithTransactMultipleGSIAndThing", ctx, m1, m1Conditions, m2, m2Conditions)
	ret0, _ := ret[0].(error)
	return ret0
}

// TransactSaveThingWithTransactMultipleGSIAndThing indicates an expected call of TransactSaveThingWithTransactMultipleGSIAndThing.
func (mr *MockInterfaceMockRecorder) TransactSaveThingWithTransactMultipleGSIAndThing(ctx, m1, m1Conditions, m2, m2Conditions interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactSaveThingWithTransactMultipleGSIAndThing", reflect.TypeOf((*MockInterface)(nil).TransactSaveThingWithTransactMultipleGSIAndThing), ctx, m1, m1Conditions, m2, m2Conditions)
}

// TransactSaveThingWithTransactionAndThing mocks base method.
func (m *MockInterface) TransactSaveThingWithTransactionAndThing(ctx context.Context, m1 v9.ThingWithTransaction, m1Conditions *expression.ConditionBuilder, m2 v9.Thing, m2Conditions *expression.ConditionBuilder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactSaveThingWithTransactionAndThing", ctx, m1, m1Conditions, m2, m2Conditions)
	ret0, _ := ret[0].(error)
	return ret0
}

// TransactSaveThingWithTransactionAndThing indicates an expected call of TransactSaveThingWithTransactionAndThing.
func (mr *MockInterfaceMockRecorder) TransactSaveThingWithTransactionAndThing(ctx, m1, m1Conditions, m2, m2Conditions interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactSaveThingWithTransactionAndThing", reflect.TypeOf((*MockInterface)(nil).TransactSaveThingWithTransactionAndThing), ctx, m1, m1Conditions, m2, m2Conditions)
}

// TransactSaveThingWithTransactionWithSimpleThingAndSimpleThing mocks base method.
func (m *MockInterface) TransactSaveThingWithTransactionWithSimpleThingAndSimpleThing(ctx context.Context, m1 v9.ThingWithTransactionWithSimpleThing, m1Conditions *expression.ConditionBuilder, m2 v9.SimpleThing, m2Conditions *expression.ConditionBuilder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactSaveThingWithTransactionWithSimpleThingAndSimpleThing", ctx, m1, m1Conditions, m2, m2Conditions)
	ret0, _ := ret[0].(error)
	return ret0
}

// TransactSaveThingWithTransactionWithSimpleThingAndSimpleThing indicates an expected call of TransactSaveThingWithTransactionWithSimpleThingAndSimpleThing.
func (mr *MockInterfaceMockRecorder) TransactSaveThingWithTransactionWithSimpleThingAndSimpleThing(ctx, m1, m1Conditions, m2, m2Conditions interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactSaveThingWithTransactionWithSimpleThingAndSimpleThing", reflect.TypeOf((*MockInterface)(nil).TransactSaveThingWithTransactionWithSimpleThingAndSimpleThing), ctx, m1, m1Conditions, m2, m2Conditions)
}
