mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/mediapackagevod/mediapackagevodiface (interfaces: MediaPackageVodAPI)

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

import (
	context "context"
	reflect "reflect"

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

// MockMediaPackageVodAPI is a mock of MediaPackageVodAPI interface.
type MockMediaPackageVodAPI struct {
	ctrl     *gomock.Controller
	recorder *MockMediaPackageVodAPIMockRecorder
}

// MockMediaPackageVodAPIMockRecorder is the mock recorder for MockMediaPackageVodAPI.
type MockMediaPackageVodAPIMockRecorder struct {
	mock *MockMediaPackageVodAPI
}

// NewMockMediaPackageVodAPI creates a new mock instance.
func NewMockMediaPackageVodAPI(ctrl *gomock.Controller) *MockMediaPackageVodAPI {
	mock := &MockMediaPackageVodAPI{ctrl: ctrl}
	mock.recorder = &MockMediaPackageVodAPIMockRecorder{mock}
	return mock
}

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

// ConfigureLogs mocks base method.
func (m *MockMediaPackageVodAPI) ConfigureLogs(arg0 *mediapackagevod.ConfigureLogsInput) (*mediapackagevod.ConfigureLogsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigureLogs", arg0)
	ret0, _ := ret[0].(*mediapackagevod.ConfigureLogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ConfigureLogsRequest mocks base method.
func (m *MockMediaPackageVodAPI) ConfigureLogsRequest(arg0 *mediapackagevod.ConfigureLogsInput) (*request.Request, *mediapackagevod.ConfigureLogsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigureLogsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.ConfigureLogsOutput)
	return ret0, ret1
}

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

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

// ConfigureLogsWithContext indicates an expected call of ConfigureLogsWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) ConfigureLogsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureLogsWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).ConfigureLogsWithContext), varargs...)
}

// CreateAsset mocks base method.
func (m *MockMediaPackageVodAPI) CreateAsset(arg0 *mediapackagevod.CreateAssetInput) (*mediapackagevod.CreateAssetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAsset", arg0)
	ret0, _ := ret[0].(*mediapackagevod.CreateAssetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAssetRequest mocks base method.
func (m *MockMediaPackageVodAPI) CreateAssetRequest(arg0 *mediapackagevod.CreateAssetInput) (*request.Request, *mediapackagevod.CreateAssetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAssetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.CreateAssetOutput)
	return ret0, ret1
}

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

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

// CreateAssetWithContext indicates an expected call of CreateAssetWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) CreateAssetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssetWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).CreateAssetWithContext), varargs...)
}

// CreatePackagingConfiguration mocks base method.
func (m *MockMediaPackageVodAPI) CreatePackagingConfiguration(arg0 *mediapackagevod.CreatePackagingConfigurationInput) (*mediapackagevod.CreatePackagingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePackagingConfiguration", arg0)
	ret0, _ := ret[0].(*mediapackagevod.CreatePackagingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePackagingConfigurationRequest mocks base method.
func (m *MockMediaPackageVodAPI) CreatePackagingConfigurationRequest(arg0 *mediapackagevod.CreatePackagingConfigurationInput) (*request.Request, *mediapackagevod.CreatePackagingConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePackagingConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.CreatePackagingConfigurationOutput)
	return ret0, ret1
}

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

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

// CreatePackagingConfigurationWithContext indicates an expected call of CreatePackagingConfigurationWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) CreatePackagingConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePackagingConfigurationWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).CreatePackagingConfigurationWithContext), varargs...)
}

// CreatePackagingGroup mocks base method.
func (m *MockMediaPackageVodAPI) CreatePackagingGroup(arg0 *mediapackagevod.CreatePackagingGroupInput) (*mediapackagevod.CreatePackagingGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePackagingGroup", arg0)
	ret0, _ := ret[0].(*mediapackagevod.CreatePackagingGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePackagingGroupRequest mocks base method.
func (m *MockMediaPackageVodAPI) CreatePackagingGroupRequest(arg0 *mediapackagevod.CreatePackagingGroupInput) (*request.Request, *mediapackagevod.CreatePackagingGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePackagingGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.CreatePackagingGroupOutput)
	return ret0, ret1
}

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

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

// CreatePackagingGroupWithContext indicates an expected call of CreatePackagingGroupWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) CreatePackagingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePackagingGroupWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).CreatePackagingGroupWithContext), varargs...)
}

// DeleteAsset mocks base method.
func (m *MockMediaPackageVodAPI) DeleteAsset(arg0 *mediapackagevod.DeleteAssetInput) (*mediapackagevod.DeleteAssetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAsset", arg0)
	ret0, _ := ret[0].(*mediapackagevod.DeleteAssetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAssetRequest mocks base method.
func (m *MockMediaPackageVodAPI) DeleteAssetRequest(arg0 *mediapackagevod.DeleteAssetInput) (*request.Request, *mediapackagevod.DeleteAssetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAssetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.DeleteAssetOutput)
	return ret0, ret1
}

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

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

// DeleteAssetWithContext indicates an expected call of DeleteAssetWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) DeleteAssetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssetWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).DeleteAssetWithContext), varargs...)
}

// DeletePackagingConfiguration mocks base method.
func (m *MockMediaPackageVodAPI) DeletePackagingConfiguration(arg0 *mediapackagevod.DeletePackagingConfigurationInput) (*mediapackagevod.DeletePackagingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePackagingConfiguration", arg0)
	ret0, _ := ret[0].(*mediapackagevod.DeletePackagingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePackagingConfigurationRequest mocks base method.
func (m *MockMediaPackageVodAPI) DeletePackagingConfigurationRequest(arg0 *mediapackagevod.DeletePackagingConfigurationInput) (*request.Request, *mediapackagevod.DeletePackagingConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePackagingConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.DeletePackagingConfigurationOutput)
	return ret0, ret1
}

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

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

// DeletePackagingConfigurationWithContext indicates an expected call of DeletePackagingConfigurationWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) DeletePackagingConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePackagingConfigurationWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).DeletePackagingConfigurationWithContext), varargs...)
}

// DeletePackagingGroup mocks base method.
func (m *MockMediaPackageVodAPI) DeletePackagingGroup(arg0 *mediapackagevod.DeletePackagingGroupInput) (*mediapackagevod.DeletePackagingGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePackagingGroup", arg0)
	ret0, _ := ret[0].(*mediapackagevod.DeletePackagingGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePackagingGroupRequest mocks base method.
func (m *MockMediaPackageVodAPI) DeletePackagingGroupRequest(arg0 *mediapackagevod.DeletePackagingGroupInput) (*request.Request, *mediapackagevod.DeletePackagingGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePackagingGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.DeletePackagingGroupOutput)
	return ret0, ret1
}

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

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

// DeletePackagingGroupWithContext indicates an expected call of DeletePackagingGroupWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) DeletePackagingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePackagingGroupWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).DeletePackagingGroupWithContext), varargs...)
}

// DescribeAsset mocks base method.
func (m *MockMediaPackageVodAPI) DescribeAsset(arg0 *mediapackagevod.DescribeAssetInput) (*mediapackagevod.DescribeAssetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAsset", arg0)
	ret0, _ := ret[0].(*mediapackagevod.DescribeAssetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAssetRequest mocks base method.
func (m *MockMediaPackageVodAPI) DescribeAssetRequest(arg0 *mediapackagevod.DescribeAssetInput) (*request.Request, *mediapackagevod.DescribeAssetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAssetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.DescribeAssetOutput)
	return ret0, ret1
}

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

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

// DescribeAssetWithContext indicates an expected call of DescribeAssetWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) DescribeAssetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssetWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).DescribeAssetWithContext), varargs...)
}

// DescribePackagingConfiguration mocks base method.
func (m *MockMediaPackageVodAPI) DescribePackagingConfiguration(arg0 *mediapackagevod.DescribePackagingConfigurationInput) (*mediapackagevod.DescribePackagingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePackagingConfiguration", arg0)
	ret0, _ := ret[0].(*mediapackagevod.DescribePackagingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePackagingConfigurationRequest mocks base method.
func (m *MockMediaPackageVodAPI) DescribePackagingConfigurationRequest(arg0 *mediapackagevod.DescribePackagingConfigurationInput) (*request.Request, *mediapackagevod.DescribePackagingConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePackagingConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.DescribePackagingConfigurationOutput)
	return ret0, ret1
}

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

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

// DescribePackagingConfigurationWithContext indicates an expected call of DescribePackagingConfigurationWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) DescribePackagingConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePackagingConfigurationWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).DescribePackagingConfigurationWithContext), varargs...)
}

// DescribePackagingGroup mocks base method.
func (m *MockMediaPackageVodAPI) DescribePackagingGroup(arg0 *mediapackagevod.DescribePackagingGroupInput) (*mediapackagevod.DescribePackagingGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePackagingGroup", arg0)
	ret0, _ := ret[0].(*mediapackagevod.DescribePackagingGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePackagingGroupRequest mocks base method.
func (m *MockMediaPackageVodAPI) DescribePackagingGroupRequest(arg0 *mediapackagevod.DescribePackagingGroupInput) (*request.Request, *mediapackagevod.DescribePackagingGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePackagingGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.DescribePackagingGroupOutput)
	return ret0, ret1
}

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

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

// DescribePackagingGroupWithContext indicates an expected call of DescribePackagingGroupWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) DescribePackagingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePackagingGroupWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).DescribePackagingGroupWithContext), varargs...)
}

// ListAssets mocks base method.
func (m *MockMediaPackageVodAPI) ListAssets(arg0 *mediapackagevod.ListAssetsInput) (*mediapackagevod.ListAssetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssets", arg0)
	ret0, _ := ret[0].(*mediapackagevod.ListAssetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAssetsPages mocks base method.
func (m *MockMediaPackageVodAPI) ListAssetsPages(arg0 *mediapackagevod.ListAssetsInput, arg1 func(*mediapackagevod.ListAssetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAssetsPagesWithContext mocks base method.
func (m *MockMediaPackageVodAPI) ListAssetsPagesWithContext(arg0 context.Context, arg1 *mediapackagevod.ListAssetsInput, arg2 func(*mediapackagevod.ListAssetsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAssetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListAssetsPagesWithContext indicates an expected call of ListAssetsPagesWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) ListAssetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssetsPagesWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).ListAssetsPagesWithContext), varargs...)
}

// ListAssetsRequest mocks base method.
func (m *MockMediaPackageVodAPI) ListAssetsRequest(arg0 *mediapackagevod.ListAssetsInput) (*request.Request, *mediapackagevod.ListAssetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAssetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.ListAssetsOutput)
	return ret0, ret1
}

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

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

// ListAssetsWithContext indicates an expected call of ListAssetsWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) ListAssetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssetsWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).ListAssetsWithContext), varargs...)
}

// ListPackagingConfigurations mocks base method.
func (m *MockMediaPackageVodAPI) ListPackagingConfigurations(arg0 *mediapackagevod.ListPackagingConfigurationsInput) (*mediapackagevod.ListPackagingConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPackagingConfigurations", arg0)
	ret0, _ := ret[0].(*mediapackagevod.ListPackagingConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPackagingConfigurationsPages mocks base method.
func (m *MockMediaPackageVodAPI) ListPackagingConfigurationsPages(arg0 *mediapackagevod.ListPackagingConfigurationsInput, arg1 func(*mediapackagevod.ListPackagingConfigurationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPackagingConfigurationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPackagingConfigurationsPagesWithContext mocks base method.
func (m *MockMediaPackageVodAPI) ListPackagingConfigurationsPagesWithContext(arg0 context.Context, arg1 *mediapackagevod.ListPackagingConfigurationsInput, arg2 func(*mediapackagevod.ListPackagingConfigurationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPackagingConfigurationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPackagingConfigurationsPagesWithContext indicates an expected call of ListPackagingConfigurationsPagesWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) ListPackagingConfigurationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPackagingConfigurationsPagesWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).ListPackagingConfigurationsPagesWithContext), varargs...)
}

// ListPackagingConfigurationsRequest mocks base method.
func (m *MockMediaPackageVodAPI) ListPackagingConfigurationsRequest(arg0 *mediapackagevod.ListPackagingConfigurationsInput) (*request.Request, *mediapackagevod.ListPackagingConfigurationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPackagingConfigurationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.ListPackagingConfigurationsOutput)
	return ret0, ret1
}

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

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

// ListPackagingConfigurationsWithContext indicates an expected call of ListPackagingConfigurationsWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) ListPackagingConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPackagingConfigurationsWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).ListPackagingConfigurationsWithContext), varargs...)
}

// ListPackagingGroups mocks base method.
func (m *MockMediaPackageVodAPI) ListPackagingGroups(arg0 *mediapackagevod.ListPackagingGroupsInput) (*mediapackagevod.ListPackagingGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPackagingGroups", arg0)
	ret0, _ := ret[0].(*mediapackagevod.ListPackagingGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPackagingGroupsPages mocks base method.
func (m *MockMediaPackageVodAPI) ListPackagingGroupsPages(arg0 *mediapackagevod.ListPackagingGroupsInput, arg1 func(*mediapackagevod.ListPackagingGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPackagingGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPackagingGroupsPagesWithContext mocks base method.
func (m *MockMediaPackageVodAPI) ListPackagingGroupsPagesWithContext(arg0 context.Context, arg1 *mediapackagevod.ListPackagingGroupsInput, arg2 func(*mediapackagevod.ListPackagingGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPackagingGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPackagingGroupsPagesWithContext indicates an expected call of ListPackagingGroupsPagesWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) ListPackagingGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPackagingGroupsPagesWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).ListPackagingGroupsPagesWithContext), varargs...)
}

// ListPackagingGroupsRequest mocks base method.
func (m *MockMediaPackageVodAPI) ListPackagingGroupsRequest(arg0 *mediapackagevod.ListPackagingGroupsInput) (*request.Request, *mediapackagevod.ListPackagingGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPackagingGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.ListPackagingGroupsOutput)
	return ret0, ret1
}

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

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

// ListPackagingGroupsWithContext indicates an expected call of ListPackagingGroupsWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) ListPackagingGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPackagingGroupsWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).ListPackagingGroupsWithContext), varargs...)
}

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

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

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

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

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

// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).ListTagsForResourceWithContext), varargs...)
}

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

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

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

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

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

// TagResourceWithContext indicates an expected call of TagResourceWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).TagResourceWithContext), varargs...)
}

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

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

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

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

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

// UntagResourceWithContext indicates an expected call of UntagResourceWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).UntagResourceWithContext), varargs...)
}

// UpdatePackagingGroup mocks base method.
func (m *MockMediaPackageVodAPI) UpdatePackagingGroup(arg0 *mediapackagevod.UpdatePackagingGroupInput) (*mediapackagevod.UpdatePackagingGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePackagingGroup", arg0)
	ret0, _ := ret[0].(*mediapackagevod.UpdatePackagingGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePackagingGroupRequest mocks base method.
func (m *MockMediaPackageVodAPI) UpdatePackagingGroupRequest(arg0 *mediapackagevod.UpdatePackagingGroupInput) (*request.Request, *mediapackagevod.UpdatePackagingGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePackagingGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*mediapackagevod.UpdatePackagingGroupOutput)
	return ret0, ret1
}

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

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

// UpdatePackagingGroupWithContext indicates an expected call of UpdatePackagingGroupWithContext.
func (mr *MockMediaPackageVodAPIMockRecorder) UpdatePackagingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePackagingGroupWithContext", reflect.TypeOf((*MockMediaPackageVodAPI)(nil).UpdatePackagingGroupWithContext), varargs...)
}