z_generated_fabricruntime.go

// Code generated by "go run github.com/tg123/fabric/mkidl"; DO NOT EDIT.
package fabric

import (
	"github.com/go-ole/go-ole"
	"unsafe"
)

type fabricRuntimeComHub struct {
	FabricRuntime *comFabricRuntime
}

func (v *fabricRuntimeComHub) init(createComObject comCreator) {
	createComObject("{CC53AF8E-74CD-11DF-AC3E-0024811E3892}", unsafe.Pointer(&v.FabricRuntime))
}
func (v *fabricRuntimeComHub) Close() error {
	if v.FabricRuntime != nil {
		releaseComObject(&v.FabricRuntime.IUnknown)
	}
	return nil
}
func (v *FabricRuntime) registerStatelessServiceFactory(
	serviceTypeName string,
	factory *comFabricStatelessServiceFactory,
) (err error) {
	if v.hub.FabricRuntime == nil {
		err = errComNotImpl
		return
	}
	return v.hub.FabricRuntime.RegisterStatelessServiceFactory(serviceTypeName, factory)
}
func (v *FabricRuntime) registerStatefulServiceFactory(
	serviceTypeName string,
	factory *comFabricStatefulServiceFactory,
) (err error) {
	if v.hub.FabricRuntime == nil {
		err = errComNotImpl
		return
	}
	return v.hub.FabricRuntime.RegisterStatefulServiceFactory(serviceTypeName, factory)
}
func (v *FabricRuntime) createServiceGroupFactoryBuilder() (builder *comFabricServiceGroupFactoryBuilder, err error) {
	if v.hub.FabricRuntime == nil {
		err = errComNotImpl
		return
	}
	return v.hub.FabricRuntime.CreateServiceGroupFactoryBuilder()
}
func (v *FabricRuntime) registerServiceGroupFactory(
	groupServiceType string,
	factory *comFabricServiceGroupFactory,
) (err error) {
	if v.hub.FabricRuntime == nil {
		err = errComNotImpl
		return
	}
	return v.hub.FabricRuntime.RegisterServiceGroupFactory(groupServiceType, factory)
}

type comFabricRuntime struct {
	ole.IUnknown
}

type comFabricRuntimeVtbl struct {
	ole.IUnknownVtbl
	BeginRegisterStatelessServiceFactory uintptr
	EndRegisterStatelessServiceFactory   uintptr
	RegisterStatelessServiceFactory      uintptr
	BeginRegisterStatefulServiceFactory  uintptr
	EndRegisterStatefulServiceFactory    uintptr
	RegisterStatefulServiceFactory       uintptr
	CreateServiceGroupFactoryBuilder     uintptr
	BeginRegisterServiceGroupFactory     uintptr
	EndRegisterServiceGroupFactory       uintptr
	RegisterServiceGroupFactory          uintptr
}

func (v *comFabricRuntime) vtable() *comFabricRuntimeVtbl {
	return (*comFabricRuntimeVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricRuntime) beginRegisterStatelessServiceFactory(
	serviceTypeName string,
	factory *comFabricStatelessServiceFactory,
	timeoutMilliseconds uint32,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(serviceTypeName)
	var p_4 *comFabricAsyncOperationContext
	defer func() {
		context = p_4
	}()
	hr, err1 := callStub2123967250(
		v.vtable().BeginRegisterStatelessServiceFactory,
		5,
		unsafe.Pointer(v),
		p_0,
		factory,
		timeoutMilliseconds,
		callback,
		&p_4,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricRuntime) RegisterStatelessServiceFactory(
	serviceTypeName string,
	factory *comFabricStatelessServiceFactory,
) (err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(serviceTypeName)
	hr, err1 := callStub906170255(
		v.vtable().RegisterStatelessServiceFactory,
		2,
		unsafe.Pointer(v),
		p_0,
		factory,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricRuntime) beginRegisterStatefulServiceFactory(
	serviceTypeName string,
	factory *comFabricStatefulServiceFactory,
	timeoutMilliseconds uint32,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(serviceTypeName)
	var p_4 *comFabricAsyncOperationContext
	defer func() {
		context = p_4
	}()
	hr, err1 := callStub1319774882(
		v.vtable().BeginRegisterStatefulServiceFactory,
		5,
		unsafe.Pointer(v),
		p_0,
		factory,
		timeoutMilliseconds,
		callback,
		&p_4,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricRuntime) RegisterStatefulServiceFactory(
	serviceTypeName string,
	factory *comFabricStatefulServiceFactory,
) (err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(serviceTypeName)
	hr, err1 := callStub637800223(
		v.vtable().RegisterStatefulServiceFactory,
		2,
		unsafe.Pointer(v),
		p_0,
		factory,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricRuntime) CreateServiceGroupFactoryBuilder() (builder *comFabricServiceGroupFactoryBuilder, err error) {
	var p_0 *comFabricServiceGroupFactoryBuilder
	defer func() {
		builder = p_0
	}()
	hr, err1 := callStub95161944(
		v.vtable().CreateServiceGroupFactoryBuilder,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricRuntime) beginRegisterServiceGroupFactory(
	groupServiceType string,
	factory *comFabricServiceGroupFactory,
	timeoutMilliseconds uint32,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(groupServiceType)
	var p_4 *comFabricAsyncOperationContext
	defer func() {
		context = p_4
	}()
	hr, err1 := callStub3357944167(
		v.vtable().BeginRegisterServiceGroupFactory,
		5,
		unsafe.Pointer(v),
		p_0,
		factory,
		timeoutMilliseconds,
		callback,
		&p_4,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricRuntime) RegisterServiceGroupFactory(
	groupServiceType string,
	factory *comFabricServiceGroupFactory,
) (err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(groupServiceType)
	hr, err1 := callStub4182969828(
		v.vtable().RegisterServiceGroupFactory,
		2,
		unsafe.Pointer(v),
		p_0,
		factory,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatelessServiceFactoryGoProxy struct {
	unknownref *goIUnknown
	builder    func(ServiceContext) (StatelessServiceInstance, error)
}

func newComFabricStatelessServiceFactory(
	builder func(ServiceContext) (StatelessServiceInstance, error),
) *comFabricStatelessServiceFactory {
	com := &comFabricStatelessServiceFactory{}
	*(**comFabricStatelessServiceFactoryVtbl)(unsafe.Pointer(com)) = &comFabricStatelessServiceFactoryVtbl{}
	vtbl := com.vtable()
	com.proxy.unknownref = attachIUnknown("{CC53AF8F-74CD-11DF-AC3E-0024811E3892}", &vtbl.IUnknownVtbl)

	vtbl.CreateInstance = createCallbackStub351017874(com.proxy.CreateInstance)

	com.proxy.builder = builder

	com.proxy.init()
	return com
}

/*
func (v *comFabricStatelessServiceFactoryGoProxy) CreateInstance(
_ *ole.IUnknown,
serviceTypeName *uint16,
serviceName *uint16,
initializationDataLength uint32,
initializationData *byte,
partitionId ole.GUID,
instanceId int64,
serviceInstance **comFabricStatelessServiceInstance,
) uintptr { return 0}
*/

type comFabricStatelessServiceFactory struct {
	ole.IUnknown
	proxy comFabricStatelessServiceFactoryGoProxy
}

type comFabricStatelessServiceFactoryVtbl struct {
	ole.IUnknownVtbl
	CreateInstance uintptr
}

func (v *comFabricStatelessServiceFactory) vtable() *comFabricStatelessServiceFactoryVtbl {
	return (*comFabricStatelessServiceFactoryVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatelessServiceFactory) CreateInstance(
	serviceTypeName string,
	serviceName string,
	initializationDataLength uint32,
	initializationData *byte,
	partitionId ole.GUID,
	instanceId int64,
) (serviceInstance *comFabricStatelessServiceInstance, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(serviceTypeName)
	var p_1 *uint16
	p_1 = utf16PtrFromString(serviceName)
	var p_6 *comFabricStatelessServiceInstance
	defer func() {
		serviceInstance = p_6
	}()
	hr, err1 := callStub351017874(
		v.vtable().CreateInstance,
		7,
		unsafe.Pointer(v),
		p_0,
		p_1,
		initializationDataLength,
		initializationData,
		partitionId,
		instanceId,
		&p_6,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatelessServiceInstanceGoProxy struct {
	unknownref *goIUnknown
	instance   StatelessServiceInstance
}

func newComFabricStatelessServiceInstance(
	instance StatelessServiceInstance,
) *comFabricStatelessServiceInstance {
	com := &comFabricStatelessServiceInstance{}
	*(**comFabricStatelessServiceInstanceVtbl)(unsafe.Pointer(com)) = &comFabricStatelessServiceInstanceVtbl{}
	vtbl := com.vtable()
	com.proxy.unknownref = attachIUnknown("{CC53AF90-74CD-11DF-AC3E-0024811E3892}", &vtbl.IUnknownVtbl)

	vtbl.BeginOpen = createCallbackStub3267176230(com.proxy.BeginOpen)
	vtbl.EndOpen = createCallbackStub1252332865(com.proxy.EndOpen)
	vtbl.BeginClose = createCallbackStub719329543(com.proxy.BeginClose)
	vtbl.EndClose = createCallbackStub3172535365(com.proxy.EndClose)
	vtbl.Abort = createCallbackStub1(com.proxy.Abort)

	com.proxy.instance = instance

	com.proxy.init()
	return com
}

/*
func (v *comFabricStatelessServiceInstanceGoProxy) BeginOpen(
_ *ole.IUnknown,
partition *comFabricStatelessServicePartition,
callback *comFabricAsyncOperationCallback,
context **comFabricAsyncOperationContext,
) uintptr { return 0}
func (v *comFabricStatelessServiceInstanceGoProxy) EndOpen(
_ *ole.IUnknown,
context *comFabricAsyncOperationContext,
serviceAddress **comFabricStringResult,
) uintptr { return 0}
func (v *comFabricStatelessServiceInstanceGoProxy) BeginClose(
_ *ole.IUnknown,
callback *comFabricAsyncOperationCallback,
context **comFabricAsyncOperationContext,
) uintptr { return 0}
func (v *comFabricStatelessServiceInstanceGoProxy) EndClose(
_ *ole.IUnknown,
context *comFabricAsyncOperationContext,
) uintptr { return 0}
func (v *comFabricStatelessServiceInstanceGoProxy) Abort(
_ *ole.IUnknown,
) uintptr { return 0}
*/

type comFabricStatelessServiceInstance struct {
	ole.IUnknown
	proxy comFabricStatelessServiceInstanceGoProxy
}

type comFabricStatelessServiceInstanceVtbl struct {
	ole.IUnknownVtbl
	BeginOpen  uintptr
	EndOpen    uintptr
	BeginClose uintptr
	EndClose   uintptr
	Abort      uintptr
}

func (v *comFabricStatelessServiceInstance) vtable() *comFabricStatelessServiceInstanceVtbl {
	return (*comFabricStatelessServiceInstanceVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatelessServiceInstance) beginOpen(
	partition *comFabricStatelessServicePartition,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_2 *comFabricAsyncOperationContext
	defer func() {
		context = p_2
	}()
	hr, err1 := callStub3267176230(
		v.vtable().BeginOpen,
		3,
		unsafe.Pointer(v),
		partition,
		callback,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatelessServiceInstance) endOpen(
	context *comFabricAsyncOperationContext,
) (serviceAddress *comFabricStringResult, err error) {
	var p_1 *comFabricStringResult
	defer func() {
		serviceAddress = p_1
	}()
	hr, err1 := callStub1252332865(
		v.vtable().EndOpen,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatelessServiceInstance) beginClose(
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_1 *comFabricAsyncOperationContext
	defer func() {
		context = p_1
	}()
	hr, err1 := callStub719329543(
		v.vtable().BeginClose,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatelessServiceInstance) endClose(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndClose,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatelessServiceInstance) Abort() (rt interface{}, err error) {
	hr, err1 := callStub1(
		v.vtable().Abort,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}

type comFabricStatelessServicePartition struct {
	ole.IUnknown
}

type comFabricStatelessServicePartitionVtbl struct {
	ole.IUnknownVtbl
	GetPartitionInfo uintptr
	ReportLoad       uintptr
	ReportFault      uintptr
}

func (v *comFabricStatelessServicePartition) vtable() *comFabricStatelessServicePartitionVtbl {
	return (*comFabricStatelessServicePartitionVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatelessServicePartition) GetPartitionInfo() (bufferedValue *FabricServicePartitionInformation, err error) {
	var p_0 *innerFabricServicePartitionInformation
	defer func() {
		bufferedValue = p_0.toGoStruct()
	}()
	hr, err1 := callStub923865033(
		v.vtable().GetPartitionInfo,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatelessServicePartition) ReportLoad(
	metricCount uint32,
	metrics *FabricLoadMetric,
) (err error) {
	var p_1 *innerFabricLoadMetric
	p_1 = metrics.toInnerStruct()
	hr, err1 := callStub2628324035(
		v.vtable().ReportLoad,
		2,
		unsafe.Pointer(v),
		metricCount,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatelessServicePartition) ReportFault(
	faultType FabricFaultType,
) (err error) {
	hr, err1 := callStub765920742(
		v.vtable().ReportFault,
		1,
		unsafe.Pointer(v),
		faultType,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatelessServicePartition1 struct {
	comFabricStatelessServicePartition
}

type comFabricStatelessServicePartition1Vtbl struct {
	comFabricStatelessServicePartitionVtbl
	ReportMoveCost uintptr
}

func (v *comFabricStatelessServicePartition1) vtable() *comFabricStatelessServicePartition1Vtbl {
	return (*comFabricStatelessServicePartition1Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatelessServicePartition1) ReportMoveCost(
	moveCost FabricMoveCost,
) (err error) {
	hr, err1 := callStub667092344(
		v.vtable().ReportMoveCost,
		1,
		unsafe.Pointer(v),
		moveCost,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatelessServicePartition2 struct {
	comFabricStatelessServicePartition1
}

type comFabricStatelessServicePartition2Vtbl struct {
	comFabricStatelessServicePartition1Vtbl
	ReportInstanceHealth  uintptr
	ReportPartitionHealth uintptr
}

func (v *comFabricStatelessServicePartition2) vtable() *comFabricStatelessServicePartition2Vtbl {
	return (*comFabricStatelessServicePartition2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatelessServicePartition2) ReportInstanceHealth(
	healthInfo *FabricHealthInformation,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	hr, err1 := callStub2782464874(
		v.vtable().ReportInstanceHealth,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatelessServicePartition2) ReportPartitionHealth(
	healthInfo *FabricHealthInformation,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	hr, err1 := callStub2782464874(
		v.vtable().ReportPartitionHealth,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatelessServicePartition3 struct {
	comFabricStatelessServicePartition2
}

type comFabricStatelessServicePartition3Vtbl struct {
	comFabricStatelessServicePartition2Vtbl
	ReportInstanceHealth2  uintptr
	ReportPartitionHealth2 uintptr
}

func (v *comFabricStatelessServicePartition3) vtable() *comFabricStatelessServicePartition3Vtbl {
	return (*comFabricStatelessServicePartition3Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatelessServicePartition3) ReportInstanceHealth2(
	healthInfo *FabricHealthInformation,
	sendOptions *FabricHealthReportSendOptions,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	var p_1 *innerFabricHealthReportSendOptions
	p_1 = sendOptions.toInnerStruct()
	hr, err1 := callStub959650155(
		v.vtable().ReportInstanceHealth2,
		2,
		unsafe.Pointer(v),
		p_0,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatelessServicePartition3) ReportPartitionHealth2(
	healthInfo *FabricHealthInformation,
	sendOptions *FabricHealthReportSendOptions,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	var p_1 *innerFabricHealthReportSendOptions
	p_1 = sendOptions.toInnerStruct()
	hr, err1 := callStub959650155(
		v.vtable().ReportPartitionHealth2,
		2,
		unsafe.Pointer(v),
		p_0,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatefulServiceFactory struct {
	ole.IUnknown
}

type comFabricStatefulServiceFactoryVtbl struct {
	ole.IUnknownVtbl
	CreateReplica uintptr
}

func (v *comFabricStatefulServiceFactory) vtable() *comFabricStatefulServiceFactoryVtbl {
	return (*comFabricStatefulServiceFactoryVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatefulServiceFactory) CreateReplica(
	serviceTypeName string,
	serviceName string,
	initializationDataLength uint32,
	initializationData *byte,
	partitionId ole.GUID,
	replicaId int64,
) (serviceReplica *comFabricStatefulServiceReplica, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(serviceTypeName)
	var p_1 *uint16
	p_1 = utf16PtrFromString(serviceName)
	var p_6 *comFabricStatefulServiceReplica
	defer func() {
		serviceReplica = p_6
	}()
	hr, err1 := callStub3716160173(
		v.vtable().CreateReplica,
		7,
		unsafe.Pointer(v),
		p_0,
		p_1,
		initializationDataLength,
		initializationData,
		partitionId,
		replicaId,
		&p_6,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatefulServiceReplica struct {
	ole.IUnknown
}

type comFabricStatefulServiceReplicaVtbl struct {
	ole.IUnknownVtbl
	BeginOpen       uintptr
	EndOpen         uintptr
	BeginChangeRole uintptr
	EndChangeRole   uintptr
	BeginClose      uintptr
	EndClose        uintptr
	Abort           uintptr
}

func (v *comFabricStatefulServiceReplica) vtable() *comFabricStatefulServiceReplicaVtbl {
	return (*comFabricStatefulServiceReplicaVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatefulServiceReplica) beginOpen(
	openMode FabricReplicaOpenMode,
	partition *comFabricStatefulServicePartition,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub895233792(
		v.vtable().BeginOpen,
		4,
		unsafe.Pointer(v),
		openMode,
		partition,
		callback,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServiceReplica) endOpen(
	context *comFabricAsyncOperationContext,
) (replicator *comFabricReplicator, err error) {
	var p_1 *comFabricReplicator
	defer func() {
		replicator = p_1
	}()
	hr, err1 := callStub540480608(
		v.vtable().EndOpen,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServiceReplica) beginChangeRole(
	newRole FabricReplicaRole,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_2 *comFabricAsyncOperationContext
	defer func() {
		context = p_2
	}()
	hr, err1 := callStub607330252(
		v.vtable().BeginChangeRole,
		3,
		unsafe.Pointer(v),
		newRole,
		callback,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServiceReplica) endChangeRole(
	context *comFabricAsyncOperationContext,
) (serviceAddress *comFabricStringResult, err error) {
	var p_1 *comFabricStringResult
	defer func() {
		serviceAddress = p_1
	}()
	hr, err1 := callStub1252332865(
		v.vtable().EndChangeRole,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServiceReplica) beginClose(
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_1 *comFabricAsyncOperationContext
	defer func() {
		context = p_1
	}()
	hr, err1 := callStub719329543(
		v.vtable().BeginClose,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServiceReplica) endClose(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndClose,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServiceReplica) Abort() (rt interface{}, err error) {
	hr, err1 := callStub1(
		v.vtable().Abort,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}

type comFabricStatefulServicePartition struct {
	ole.IUnknown
}

type comFabricStatefulServicePartitionVtbl struct {
	ole.IUnknownVtbl
	GetPartitionInfo uintptr
	GetReadStatus    uintptr
	GetWriteStatus   uintptr
	CreateReplicator uintptr
	ReportLoad       uintptr
	ReportFault      uintptr
}

func (v *comFabricStatefulServicePartition) vtable() *comFabricStatefulServicePartitionVtbl {
	return (*comFabricStatefulServicePartitionVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatefulServicePartition) GetPartitionInfo() (bufferedValue *FabricServicePartitionInformation, err error) {
	var p_0 *innerFabricServicePartitionInformation
	defer func() {
		bufferedValue = p_0.toGoStruct()
	}()
	hr, err1 := callStub923865033(
		v.vtable().GetPartitionInfo,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServicePartition) GetReadStatus() (readStatus FabricServicePartitionAccessStatus, err error) {
	var p_0 FabricServicePartitionAccessStatus
	defer func() {
		readStatus = p_0
	}()
	hr, err1 := callStub4029877715(
		v.vtable().GetReadStatus,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServicePartition) GetWriteStatus() (writeStatus FabricServicePartitionAccessStatus, err error) {
	var p_0 FabricServicePartitionAccessStatus
	defer func() {
		writeStatus = p_0
	}()
	hr, err1 := callStub4029877715(
		v.vtable().GetWriteStatus,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServicePartition) CreateReplicator(
	stateProvider *comFabricStateProvider,
	replicatorSettings *FabricReplicatorSettings,
) (replicator *comFabricReplicator, stateReplicator *comFabricStateReplicator, err error) {
	var p_1 *innerFabricReplicatorSettings
	p_1 = replicatorSettings.toInnerStruct()
	var p_2 *comFabricReplicator
	defer func() {
		replicator = p_2
	}()
	var p_3 *comFabricStateReplicator
	defer func() {
		stateReplicator = p_3
	}()
	hr, err1 := callStub4107741011(
		v.vtable().CreateReplicator,
		4,
		unsafe.Pointer(v),
		stateProvider,
		p_1,
		&p_2,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServicePartition) ReportLoad(
	metricCount uint32,
	metrics *FabricLoadMetric,
) (err error) {
	var p_1 *innerFabricLoadMetric
	p_1 = metrics.toInnerStruct()
	hr, err1 := callStub2628324035(
		v.vtable().ReportLoad,
		2,
		unsafe.Pointer(v),
		metricCount,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServicePartition) ReportFault(
	faultType FabricFaultType,
) (err error) {
	hr, err1 := callStub765920742(
		v.vtable().ReportFault,
		1,
		unsafe.Pointer(v),
		faultType,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatefulServicePartition1 struct {
	comFabricStatefulServicePartition
}

type comFabricStatefulServicePartition1Vtbl struct {
	comFabricStatefulServicePartitionVtbl
	ReportMoveCost uintptr
}

func (v *comFabricStatefulServicePartition1) vtable() *comFabricStatefulServicePartition1Vtbl {
	return (*comFabricStatefulServicePartition1Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatefulServicePartition1) ReportMoveCost(
	moveCost FabricMoveCost,
) (err error) {
	hr, err1 := callStub667092344(
		v.vtable().ReportMoveCost,
		1,
		unsafe.Pointer(v),
		moveCost,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatefulServicePartition2 struct {
	comFabricStatefulServicePartition1
}

type comFabricStatefulServicePartition2Vtbl struct {
	comFabricStatefulServicePartition1Vtbl
	ReportReplicaHealth   uintptr
	ReportPartitionHealth uintptr
}

func (v *comFabricStatefulServicePartition2) vtable() *comFabricStatefulServicePartition2Vtbl {
	return (*comFabricStatefulServicePartition2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatefulServicePartition2) ReportReplicaHealth(
	healthInfo *FabricHealthInformation,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	hr, err1 := callStub2782464874(
		v.vtable().ReportReplicaHealth,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServicePartition2) ReportPartitionHealth(
	healthInfo *FabricHealthInformation,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	hr, err1 := callStub2782464874(
		v.vtable().ReportPartitionHealth,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStatefulServicePartition3 struct {
	comFabricStatefulServicePartition2
}

type comFabricStatefulServicePartition3Vtbl struct {
	comFabricStatefulServicePartition2Vtbl
	ReportReplicaHealth2   uintptr
	ReportPartitionHealth2 uintptr
}

func (v *comFabricStatefulServicePartition3) vtable() *comFabricStatefulServicePartition3Vtbl {
	return (*comFabricStatefulServicePartition3Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStatefulServicePartition3) ReportReplicaHealth2(
	healthInfo *FabricHealthInformation,
	sendOptions *FabricHealthReportSendOptions,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	var p_1 *innerFabricHealthReportSendOptions
	p_1 = sendOptions.toInnerStruct()
	hr, err1 := callStub959650155(
		v.vtable().ReportReplicaHealth2,
		2,
		unsafe.Pointer(v),
		p_0,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStatefulServicePartition3) ReportPartitionHealth2(
	healthInfo *FabricHealthInformation,
	sendOptions *FabricHealthReportSendOptions,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	var p_1 *innerFabricHealthReportSendOptions
	p_1 = sendOptions.toInnerStruct()
	hr, err1 := callStub959650155(
		v.vtable().ReportPartitionHealth2,
		2,
		unsafe.Pointer(v),
		p_0,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStateReplicator struct {
	ole.IUnknown
}

type comFabricStateReplicatorVtbl struct {
	ole.IUnknownVtbl
	BeginReplicate           uintptr
	EndReplicate             uintptr
	GetReplicationStream     uintptr
	GetCopyStream            uintptr
	UpdateReplicatorSettings uintptr
}

func (v *comFabricStateReplicator) vtable() *comFabricStateReplicatorVtbl {
	return (*comFabricStateReplicatorVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStateReplicator) beginReplicate(
	operationData *comFabricOperationData,
	callback *comFabricAsyncOperationCallback,
) (sequenceNumber int64, context *comFabricAsyncOperationContext, err error) {
	var p_2 int64
	defer func() {
		sequenceNumber = p_2
	}()
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub3351979033(
		v.vtable().BeginReplicate,
		4,
		unsafe.Pointer(v),
		operationData,
		callback,
		&p_2,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateReplicator) endReplicate(
	context *comFabricAsyncOperationContext,
) (sequenceNumber int64, err error) {
	var p_1 int64
	defer func() {
		sequenceNumber = p_1
	}()
	hr, err1 := callStub452726352(
		v.vtable().EndReplicate,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateReplicator) GetReplicationStream() (stream *comFabricOperationStream, err error) {
	var p_0 *comFabricOperationStream
	defer func() {
		stream = p_0
	}()
	hr, err1 := callStub2135951864(
		v.vtable().GetReplicationStream,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateReplicator) GetCopyStream() (stream *comFabricOperationStream, err error) {
	var p_0 *comFabricOperationStream
	defer func() {
		stream = p_0
	}()
	hr, err1 := callStub2135951864(
		v.vtable().GetCopyStream,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateReplicator) UpdateReplicatorSettings(
	replicatorSettings *FabricReplicatorSettings,
) (err error) {
	var p_0 *innerFabricReplicatorSettings
	p_0 = replicatorSettings.toInnerStruct()
	hr, err1 := callStub3011972084(
		v.vtable().UpdateReplicatorSettings,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStateReplicator2 struct {
	comFabricStateReplicator
}

type comFabricStateReplicator2Vtbl struct {
	comFabricStateReplicatorVtbl
	GetReplicatorSettings uintptr
}

func (v *comFabricStateReplicator2) vtable() *comFabricStateReplicator2Vtbl {
	return (*comFabricStateReplicator2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStateReplicator2) GetReplicatorSettings() (replicatorSettings *comFabricReplicatorSettingsResult, err error) {
	var p_0 *comFabricReplicatorSettingsResult
	defer func() {
		replicatorSettings = p_0
	}()
	hr, err1 := callStub3947302336(
		v.vtable().GetReplicatorSettings,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStateProvider struct {
	ole.IUnknown
}

type comFabricStateProviderVtbl struct {
	ole.IUnknownVtbl
	BeginUpdateEpoch               uintptr
	EndUpdateEpoch                 uintptr
	GetLastCommittedSequenceNumber uintptr
	BeginOnDataLoss                uintptr
	EndOnDataLoss                  uintptr
	GetCopyContext                 uintptr
	GetCopyState                   uintptr
}

func (v *comFabricStateProvider) vtable() *comFabricStateProviderVtbl {
	return (*comFabricStateProviderVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStateProvider) beginUpdateEpoch(
	epoch *FabricEpoch,
	previousEpochLastSequenceNumber int64,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *innerFabricEpoch
	p_0 = epoch.toInnerStruct()
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub3304399248(
		v.vtable().BeginUpdateEpoch,
		4,
		unsafe.Pointer(v),
		p_0,
		previousEpochLastSequenceNumber,
		callback,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateProvider) endUpdateEpoch(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndUpdateEpoch,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateProvider) GetLastCommittedSequenceNumber() (sequenceNumber int64, err error) {
	var p_0 int64
	defer func() {
		sequenceNumber = p_0
	}()
	hr, err1 := callStub113443296(
		v.vtable().GetLastCommittedSequenceNumber,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateProvider) beginOnDataLoss(
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_1 *comFabricAsyncOperationContext
	defer func() {
		context = p_1
	}()
	hr, err1 := callStub719329543(
		v.vtable().BeginOnDataLoss,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateProvider) endOnDataLoss(
	context *comFabricAsyncOperationContext,
) (isStateChanged bool, err error) {
	var p_1 bool
	defer func() {
		isStateChanged = p_1
	}()
	hr, err1 := callStub213847623(
		v.vtable().EndOnDataLoss,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateProvider) GetCopyContext() (copyContextStream *comFabricOperationDataStream, err error) {
	var p_0 *comFabricOperationDataStream
	defer func() {
		copyContextStream = p_0
	}()
	hr, err1 := callStub2849508210(
		v.vtable().GetCopyContext,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStateProvider) GetCopyState(
	uptoSequenceNumber int64,
	copyContextStream *comFabricOperationDataStream,
) (copyStateStream *comFabricOperationDataStream, err error) {
	var p_2 *comFabricOperationDataStream
	defer func() {
		copyStateStream = p_2
	}()
	hr, err1 := callStub708974790(
		v.vtable().GetCopyState,
		3,
		unsafe.Pointer(v),
		uptoSequenceNumber,
		copyContextStream,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricOperation struct {
	ole.IUnknown
}

type comFabricOperationVtbl struct {
	ole.IUnknownVtbl
	get_Metadata uintptr
	GetData      uintptr
	Acknowledge  uintptr
}

func (v *comFabricOperation) vtable() *comFabricOperationVtbl {
	return (*comFabricOperationVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricOperation) GetMetadata() (rt *FabricOperationMetadata, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Metadata,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricOperationMetadata)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}
func (v *comFabricOperation) GetData() (count uint32, buffers *FabricOperationDataBuffer, err error) {
	var p_0 uint32
	defer func() {
		count = p_0
	}()
	var p_1 *innerFabricOperationDataBuffer
	defer func() {
		buffers = p_1.toGoStruct()
	}()
	hr, err1 := callStub519835320(
		v.vtable().GetData,
		2,
		unsafe.Pointer(v),
		&p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricOperation) Acknowledge() (err error) {
	hr, err1 := callStub1(
		v.vtable().Acknowledge,
		0,
		unsafe.Pointer(v),
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricOperationData struct {
	ole.IUnknown
}

type comFabricOperationDataVtbl struct {
	ole.IUnknownVtbl
	GetData uintptr
}

func (v *comFabricOperationData) vtable() *comFabricOperationDataVtbl {
	return (*comFabricOperationDataVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricOperationData) GetData() (count uint32, buffers *FabricOperationDataBuffer, err error) {
	var p_0 uint32
	defer func() {
		count = p_0
	}()
	var p_1 *innerFabricOperationDataBuffer
	defer func() {
		buffers = p_1.toGoStruct()
	}()
	hr, err1 := callStub519835320(
		v.vtable().GetData,
		2,
		unsafe.Pointer(v),
		&p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricOperationStream struct {
	ole.IUnknown
}

type comFabricOperationStreamVtbl struct {
	ole.IUnknownVtbl
	BeginGetOperation uintptr
	EndGetOperation   uintptr
}

func (v *comFabricOperationStream) vtable() *comFabricOperationStreamVtbl {
	return (*comFabricOperationStreamVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricOperationStream) beginGetOperation(
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_1 *comFabricAsyncOperationContext
	defer func() {
		context = p_1
	}()
	hr, err1 := callStub719329543(
		v.vtable().BeginGetOperation,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricOperationStream) endGetOperation(
	context *comFabricAsyncOperationContext,
) (operation *comFabricOperation, err error) {
	var p_1 *comFabricOperation
	defer func() {
		operation = p_1
	}()
	hr, err1 := callStub202642428(
		v.vtable().EndGetOperation,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricOperationStream2 struct {
	comFabricOperationStream
}

type comFabricOperationStream2Vtbl struct {
	comFabricOperationStreamVtbl
	ReportFault uintptr
}

func (v *comFabricOperationStream2) vtable() *comFabricOperationStream2Vtbl {
	return (*comFabricOperationStream2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricOperationStream2) ReportFault(
	faultType FabricFaultType,
) (err error) {
	hr, err1 := callStub765920742(
		v.vtable().ReportFault,
		1,
		unsafe.Pointer(v),
		faultType,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricOperationDataStream struct {
	ole.IUnknown
}

type comFabricOperationDataStreamVtbl struct {
	ole.IUnknownVtbl
	BeginGetNext uintptr
	EndGetNext   uintptr
}

func (v *comFabricOperationDataStream) vtable() *comFabricOperationDataStreamVtbl {
	return (*comFabricOperationDataStreamVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricOperationDataStream) beginGetNext(
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_1 *comFabricAsyncOperationContext
	defer func() {
		context = p_1
	}()
	hr, err1 := callStub719329543(
		v.vtable().BeginGetNext,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricOperationDataStream) endGetNext(
	context *comFabricAsyncOperationContext,
) (operationData *comFabricOperationData, err error) {
	var p_1 *comFabricOperationData
	defer func() {
		operationData = p_1
	}()
	hr, err1 := callStub1602229622(
		v.vtable().EndGetNext,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricReplicator struct {
	ole.IUnknown
}

type comFabricReplicatorVtbl struct {
	ole.IUnknownVtbl
	BeginOpen            uintptr
	EndOpen              uintptr
	BeginChangeRole      uintptr
	EndChangeRole        uintptr
	BeginUpdateEpoch     uintptr
	EndUpdateEpoch       uintptr
	BeginClose           uintptr
	EndClose             uintptr
	Abort                uintptr
	GetCurrentProgress   uintptr
	GetCatchUpCapability uintptr
}

func (v *comFabricReplicator) vtable() *comFabricReplicatorVtbl {
	return (*comFabricReplicatorVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricReplicator) beginOpen(
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_1 *comFabricAsyncOperationContext
	defer func() {
		context = p_1
	}()
	hr, err1 := callStub719329543(
		v.vtable().BeginOpen,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricReplicator) endOpen(
	context *comFabricAsyncOperationContext,
) (replicationAddress *comFabricStringResult, err error) {
	var p_1 *comFabricStringResult
	defer func() {
		replicationAddress = p_1
	}()
	hr, err1 := callStub1252332865(
		v.vtable().EndOpen,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricReplicator) beginChangeRole(
	epoch *FabricEpoch,
	role FabricReplicaRole,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *innerFabricEpoch
	p_0 = epoch.toInnerStruct()
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub2355046004(
		v.vtable().BeginChangeRole,
		4,
		unsafe.Pointer(v),
		p_0,
		role,
		callback,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricReplicator) endChangeRole(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndChangeRole,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricReplicator) beginUpdateEpoch(
	epoch *FabricEpoch,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *innerFabricEpoch
	p_0 = epoch.toInnerStruct()
	var p_2 *comFabricAsyncOperationContext
	defer func() {
		context = p_2
	}()
	hr, err1 := callStub456925103(
		v.vtable().BeginUpdateEpoch,
		3,
		unsafe.Pointer(v),
		p_0,
		callback,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricReplicator) endUpdateEpoch(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndUpdateEpoch,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricReplicator) beginClose(
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_1 *comFabricAsyncOperationContext
	defer func() {
		context = p_1
	}()
	hr, err1 := callStub719329543(
		v.vtable().BeginClose,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricReplicator) endClose(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndClose,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricReplicator) Abort() (rt interface{}, err error) {
	hr, err1 := callStub1(
		v.vtable().Abort,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}
func (v *comFabricReplicator) GetCurrentProgress() (lastSequenceNumber int64, err error) {
	var p_0 int64
	defer func() {
		lastSequenceNumber = p_0
	}()
	hr, err1 := callStub113443296(
		v.vtable().GetCurrentProgress,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricReplicator) GetCatchUpCapability() (fromSequenceNumber int64, err error) {
	var p_0 int64
	defer func() {
		fromSequenceNumber = p_0
	}()
	hr, err1 := callStub113443296(
		v.vtable().GetCatchUpCapability,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricPrimaryReplicator struct {
	comFabricReplicator
}

type comFabricPrimaryReplicatorVtbl struct {
	comFabricReplicatorVtbl
	BeginOnDataLoss                      uintptr
	EndOnDataLoss                        uintptr
	UpdateCatchUpReplicaSetConfiguration uintptr
	BeginWaitForCatchUpQuorum            uintptr
	EndWaitForCatchUpQuorum              uintptr
	UpdateCurrentReplicaSetConfiguration uintptr
	BeginBuildReplica                    uintptr
	EndBuildReplica                      uintptr
	RemoveReplica                        uintptr
}

func (v *comFabricPrimaryReplicator) vtable() *comFabricPrimaryReplicatorVtbl {
	return (*comFabricPrimaryReplicatorVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricPrimaryReplicator) beginOnDataLoss(
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_1 *comFabricAsyncOperationContext
	defer func() {
		context = p_1
	}()
	hr, err1 := callStub719329543(
		v.vtable().BeginOnDataLoss,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricPrimaryReplicator) endOnDataLoss(
	context *comFabricAsyncOperationContext,
) (isStateChanged bool, err error) {
	var p_1 bool
	defer func() {
		isStateChanged = p_1
	}()
	hr, err1 := callStub213847623(
		v.vtable().EndOnDataLoss,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricPrimaryReplicator) UpdateCatchUpReplicaSetConfiguration(
	currentConfiguration *FabricReplicaSetConfiguration,
	previousConfiguration *FabricReplicaSetConfiguration,
) (err error) {
	var p_0 *innerFabricReplicaSetConfiguration
	p_0 = currentConfiguration.toInnerStruct()
	var p_1 *innerFabricReplicaSetConfiguration
	p_1 = previousConfiguration.toInnerStruct()
	hr, err1 := callStub3686276047(
		v.vtable().UpdateCatchUpReplicaSetConfiguration,
		2,
		unsafe.Pointer(v),
		p_0,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricPrimaryReplicator) beginWaitForCatchUpQuorum(
	catchUpMode FabricReplicaSetQuorumMode,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_2 *comFabricAsyncOperationContext
	defer func() {
		context = p_2
	}()
	hr, err1 := callStub1667310452(
		v.vtable().BeginWaitForCatchUpQuorum,
		3,
		unsafe.Pointer(v),
		catchUpMode,
		callback,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricPrimaryReplicator) endWaitForCatchUpQuorum(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndWaitForCatchUpQuorum,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricPrimaryReplicator) UpdateCurrentReplicaSetConfiguration(
	currentConfiguration *FabricReplicaSetConfiguration,
) (err error) {
	var p_0 *innerFabricReplicaSetConfiguration
	p_0 = currentConfiguration.toInnerStruct()
	hr, err1 := callStub4059762130(
		v.vtable().UpdateCurrentReplicaSetConfiguration,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricPrimaryReplicator) beginBuildReplica(
	replica *FabricReplicaInformation,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *innerFabricReplicaInformation
	p_0 = replica.toInnerStruct()
	var p_2 *comFabricAsyncOperationContext
	defer func() {
		context = p_2
	}()
	hr, err1 := callStub4108199174(
		v.vtable().BeginBuildReplica,
		3,
		unsafe.Pointer(v),
		p_0,
		callback,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricPrimaryReplicator) endBuildReplica(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndBuildReplica,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricPrimaryReplicator) RemoveReplica(
	replicaId int64,
) (err error) {
	hr, err1 := callStub96862646(
		v.vtable().RemoveReplica,
		1,
		unsafe.Pointer(v),
		replicaId,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricReplicatorCatchupSpecificQuorum struct {
	ole.IUnknown
}

type comFabricReplicatorCatchupSpecificQuorumVtbl struct {
	ole.IUnknownVtbl
}

func (v *comFabricReplicatorCatchupSpecificQuorum) vtable() *comFabricReplicatorCatchupSpecificQuorumVtbl {
	return (*comFabricReplicatorCatchupSpecificQuorumVtbl)(unsafe.Pointer(v.RawVTable))
}

type comFabricAtomicGroupStateReplicator struct {
	ole.IUnknown
}

type comFabricAtomicGroupStateReplicatorVtbl struct {
	ole.IUnknownVtbl
	CreateAtomicGroup                  uintptr
	BeginReplicateAtomicGroupOperation uintptr
	EndReplicateAtomicGroupOperation   uintptr
	BeginReplicateAtomicGroupCommit    uintptr
	EndReplicateAtomicGroupCommit      uintptr
	BeginReplicateAtomicGroupRollback  uintptr
	EndReplicateAtomicGroupRollback    uintptr
}

func (v *comFabricAtomicGroupStateReplicator) vtable() *comFabricAtomicGroupStateReplicatorVtbl {
	return (*comFabricAtomicGroupStateReplicatorVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricAtomicGroupStateReplicator) CreateAtomicGroup() (AtomicGroupId int64, err error) {
	var p_0 int64
	defer func() {
		AtomicGroupId = p_0
	}()
	hr, err1 := callStub113443296(
		v.vtable().CreateAtomicGroup,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateReplicator) beginReplicateAtomicGroupOperation(
	atomicGroupId int64,
	operationData *comFabricOperationData,
	callback *comFabricAsyncOperationCallback,
) (operationSequenceNumber int64, context *comFabricAsyncOperationContext, err error) {
	var p_3 int64
	defer func() {
		operationSequenceNumber = p_3
	}()
	var p_4 *comFabricAsyncOperationContext
	defer func() {
		context = p_4
	}()
	hr, err1 := callStub2212636154(
		v.vtable().BeginReplicateAtomicGroupOperation,
		5,
		unsafe.Pointer(v),
		atomicGroupId,
		operationData,
		callback,
		&p_3,
		&p_4,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateReplicator) endReplicateAtomicGroupOperation(
	context *comFabricAsyncOperationContext,
) (operationSequenceNumber int64, err error) {
	var p_1 int64
	defer func() {
		operationSequenceNumber = p_1
	}()
	hr, err1 := callStub452726352(
		v.vtable().EndReplicateAtomicGroupOperation,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateReplicator) beginReplicateAtomicGroupCommit(
	atomicGroupId int64,
	callback *comFabricAsyncOperationCallback,
) (commitSequenceNumber int64, context *comFabricAsyncOperationContext, err error) {
	var p_2 int64
	defer func() {
		commitSequenceNumber = p_2
	}()
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub1547050227(
		v.vtable().BeginReplicateAtomicGroupCommit,
		4,
		unsafe.Pointer(v),
		atomicGroupId,
		callback,
		&p_2,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateReplicator) endReplicateAtomicGroupCommit(
	context *comFabricAsyncOperationContext,
) (commitSequenceNumber int64, err error) {
	var p_1 int64
	defer func() {
		commitSequenceNumber = p_1
	}()
	hr, err1 := callStub452726352(
		v.vtable().EndReplicateAtomicGroupCommit,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateReplicator) beginReplicateAtomicGroupRollback(
	atomicGroupId int64,
	callback *comFabricAsyncOperationCallback,
) (rollbackSequenceNumber int64, context *comFabricAsyncOperationContext, err error) {
	var p_2 int64
	defer func() {
		rollbackSequenceNumber = p_2
	}()
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub1547050227(
		v.vtable().BeginReplicateAtomicGroupRollback,
		4,
		unsafe.Pointer(v),
		atomicGroupId,
		callback,
		&p_2,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateReplicator) endReplicateAtomicGroupRollback(
	context *comFabricAsyncOperationContext,
) (rollbackSequenceNumber int64, err error) {
	var p_1 int64
	defer func() {
		rollbackSequenceNumber = p_1
	}()
	hr, err1 := callStub452726352(
		v.vtable().EndReplicateAtomicGroupRollback,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricAtomicGroupStateProvider struct {
	ole.IUnknown
}

type comFabricAtomicGroupStateProviderVtbl struct {
	ole.IUnknownVtbl
	BeginAtomicGroupCommit   uintptr
	EndAtomicGroupCommit     uintptr
	BeginAtomicGroupRollback uintptr
	EndAtomicGroupRollback   uintptr
	BeginUndoProgress        uintptr
	EndUndoProgress          uintptr
}

func (v *comFabricAtomicGroupStateProvider) vtable() *comFabricAtomicGroupStateProviderVtbl {
	return (*comFabricAtomicGroupStateProviderVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricAtomicGroupStateProvider) beginAtomicGroupCommit(
	atomicGroupId int64,
	commitSequenceNumber int64,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub969350345(
		v.vtable().BeginAtomicGroupCommit,
		4,
		unsafe.Pointer(v),
		atomicGroupId,
		commitSequenceNumber,
		callback,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateProvider) endAtomicGroupCommit(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndAtomicGroupCommit,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateProvider) beginAtomicGroupRollback(
	atomicGroupId int64,
	rollbackequenceNumber int64,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub969350345(
		v.vtable().BeginAtomicGroupRollback,
		4,
		unsafe.Pointer(v),
		atomicGroupId,
		rollbackequenceNumber,
		callback,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateProvider) endAtomicGroupRollback(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndAtomicGroupRollback,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateProvider) beginUndoProgress(
	fromCommitSequenceNumber int64,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_2 *comFabricAsyncOperationContext
	defer func() {
		context = p_2
	}()
	hr, err1 := callStub2896763624(
		v.vtable().BeginUndoProgress,
		3,
		unsafe.Pointer(v),
		fromCommitSequenceNumber,
		callback,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricAtomicGroupStateProvider) endUndoProgress(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndUndoProgress,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricServiceGroupFactory struct {
	ole.IUnknown
}

type comFabricServiceGroupFactoryVtbl struct {
	ole.IUnknownVtbl
}

func (v *comFabricServiceGroupFactory) vtable() *comFabricServiceGroupFactoryVtbl {
	return (*comFabricServiceGroupFactoryVtbl)(unsafe.Pointer(v.RawVTable))
}

type comFabricServiceGroupFactoryBuilder struct {
	ole.IUnknown
}

type comFabricServiceGroupFactoryBuilderVtbl struct {
	ole.IUnknownVtbl
	AddStatelessServiceFactory uintptr
	AddStatefulServiceFactory  uintptr
	RemoveServiceFactory       uintptr
	ToServiceGroupFactory      uintptr
}

func (v *comFabricServiceGroupFactoryBuilder) vtable() *comFabricServiceGroupFactoryBuilderVtbl {
	return (*comFabricServiceGroupFactoryBuilderVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricServiceGroupFactoryBuilder) AddStatelessServiceFactory(
	memberServiceType string,
	factory *comFabricStatelessServiceFactory,
) (err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(memberServiceType)
	hr, err1 := callStub906170255(
		v.vtable().AddStatelessServiceFactory,
		2,
		unsafe.Pointer(v),
		p_0,
		factory,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricServiceGroupFactoryBuilder) AddStatefulServiceFactory(
	memberServiceType string,
	factory *comFabricStatefulServiceFactory,
) (err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(memberServiceType)
	hr, err1 := callStub637800223(
		v.vtable().AddStatefulServiceFactory,
		2,
		unsafe.Pointer(v),
		p_0,
		factory,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricServiceGroupFactoryBuilder) RemoveServiceFactory(
	memberServiceType string,
) (err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(memberServiceType)
	hr, err1 := callStub161743442(
		v.vtable().RemoveServiceFactory,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricServiceGroupFactoryBuilder) ToServiceGroupFactory() (factory *comFabricServiceGroupFactory, err error) {
	var p_0 *comFabricServiceGroupFactory
	defer func() {
		factory = p_0
	}()
	hr, err1 := callStub2851408785(
		v.vtable().ToServiceGroupFactory,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricServiceGroupPartition struct {
	ole.IUnknown
}

type comFabricServiceGroupPartitionVtbl struct {
	ole.IUnknownVtbl
	ResolveMember uintptr
}

func (v *comFabricServiceGroupPartition) vtable() *comFabricServiceGroupPartitionVtbl {
	return (*comFabricServiceGroupPartitionVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricServiceGroupPartition) ResolveMember(
	name string,
	riid *ole.GUID,
) (member interface{}, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(name)
	var p_2 unsafe.Pointer
	defer func() {
		member = fromUnsafePointer(p_2)
	}()
	hr, err1 := callStub2879064828(
		v.vtable().ResolveMember,
		3,
		unsafe.Pointer(v),
		p_0,
		riid,
		unsafe.Pointer(&p_2),
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricCodePackageActivationContext struct {
	ole.IUnknown
}

type comFabricCodePackageActivationContextVtbl struct {
	ole.IUnknownVtbl
	get_ContextId                               uintptr
	get_CodePackageName                         uintptr
	get_CodePackageVersion                      uintptr
	get_WorkDirectory                           uintptr
	get_LogDirectory                            uintptr
	get_TempDirectory                           uintptr
	get_ServiceTypes                            uintptr
	get_ServiceGroupTypes                       uintptr
	get_ApplicationPrincipals                   uintptr
	get_ServiceEndpointResources                uintptr
	GetServiceEndpointResource                  uintptr
	GetCodePackageNames                         uintptr
	GetConfigurationPackageNames                uintptr
	GetDataPackageNames                         uintptr
	GetCodePackage                              uintptr
	GetConfigurationPackage                     uintptr
	GetDataPackage                              uintptr
	RegisterCodePackageChangeHandler            uintptr
	UnregisterCodePackageChangeHandler          uintptr
	RegisterConfigurationPackageChangeHandler   uintptr
	UnregisterConfigurationPackageChangeHandler uintptr
	RegisterDataPackageChangeHandler            uintptr
	UnregisterDataPackageChangeHandler          uintptr
}

func (v *comFabricCodePackageActivationContext) vtable() *comFabricCodePackageActivationContextVtbl {
	return (*comFabricCodePackageActivationContextVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackageActivationContext) GetContextId() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ContextId,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricCodePackageActivationContext) GetCodePackageName() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_CodePackageName,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricCodePackageActivationContext) GetCodePackageVersion() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_CodePackageVersion,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricCodePackageActivationContext) GetWorkDirectory() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_WorkDirectory,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricCodePackageActivationContext) GetLogDirectory() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_LogDirectory,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricCodePackageActivationContext) GetTempDirectory() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_TempDirectory,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricCodePackageActivationContext) GetServiceTypes() (rt []FabricServiceTypeDescription, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ServiceTypes,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricServiceTypeDescriptionList)(unsafe.Pointer(hr))

	{
		innerlst := unsafe.Slice(tmp.Items, tmp.Count)

		for _, item := range innerlst {
			var tmpitem FabricServiceTypeDescription

			tmpitem = *item.toGoStruct()

			rt = append(rt, tmpitem)
		}

	}
	return
}
func (v *comFabricCodePackageActivationContext) GetServiceGroupTypes() (rt []FabricServiceGroupTypeDescription, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ServiceGroupTypes,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricServiceGroupTypeDescriptionList)(unsafe.Pointer(hr))

	{
		innerlst := unsafe.Slice(tmp.Items, tmp.Count)

		for _, item := range innerlst {
			var tmpitem FabricServiceGroupTypeDescription

			tmpitem = *item.toGoStruct()

			rt = append(rt, tmpitem)
		}

	}
	return
}
func (v *comFabricCodePackageActivationContext) GetApplicationPrincipals() (rt *FabricApplicationPrincipalsDescription, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ApplicationPrincipals,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricApplicationPrincipalsDescription)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}
func (v *comFabricCodePackageActivationContext) GetServiceEndpointResources() (rt []FabricEndpointResourceDescription, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ServiceEndpointResources,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricEndpointResourceDescriptionList)(unsafe.Pointer(hr))

	{
		innerlst := unsafe.Slice(tmp.Items, tmp.Count)

		for _, item := range innerlst {
			var tmpitem FabricEndpointResourceDescription

			tmpitem = *item.toGoStruct()

			rt = append(rt, tmpitem)
		}

	}
	return
}
func (v *comFabricCodePackageActivationContext) GetServiceEndpointResource(
	serviceEndpointResourceName string,
) (bufferedValue *FabricEndpointResourceDescription, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(serviceEndpointResourceName)
	var p_1 *innerFabricEndpointResourceDescription
	defer func() {
		bufferedValue = p_1.toGoStruct()
	}()
	hr, err1 := callStub2791051842(
		v.vtable().GetServiceEndpointResource,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) GetCodePackageNames() (names *comFabricStringListResult, err error) {
	var p_0 *comFabricStringListResult
	defer func() {
		names = p_0
	}()
	hr, err1 := callStub2309098093(
		v.vtable().GetCodePackageNames,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) GetConfigurationPackageNames() (names *comFabricStringListResult, err error) {
	var p_0 *comFabricStringListResult
	defer func() {
		names = p_0
	}()
	hr, err1 := callStub2309098093(
		v.vtable().GetConfigurationPackageNames,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) GetDataPackageNames() (names *comFabricStringListResult, err error) {
	var p_0 *comFabricStringListResult
	defer func() {
		names = p_0
	}()
	hr, err1 := callStub2309098093(
		v.vtable().GetDataPackageNames,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) GetCodePackage(
	codePackageName string,
) (codePackage *comFabricCodePackage, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(codePackageName)
	var p_1 *comFabricCodePackage
	defer func() {
		codePackage = p_1
	}()
	hr, err1 := callStub2593786495(
		v.vtable().GetCodePackage,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) GetConfigurationPackage(
	configPackageName string,
) (configPackage *comFabricConfigurationPackage, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(configPackageName)
	var p_1 *comFabricConfigurationPackage
	defer func() {
		configPackage = p_1
	}()
	hr, err1 := callStub261819996(
		v.vtable().GetConfigurationPackage,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) GetDataPackage(
	dataPackageName string,
) (dataPackage *comFabricDataPackage, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(dataPackageName)
	var p_1 *comFabricDataPackage
	defer func() {
		dataPackage = p_1
	}()
	hr, err1 := callStub2592672382(
		v.vtable().GetDataPackage,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) RegisterCodePackageChangeHandler(
	callback *comFabricCodePackageChangeHandler,
) (callbackHandle int64, err error) {
	var p_1 int64
	defer func() {
		callbackHandle = p_1
	}()
	hr, err1 := callStub1041370855(
		v.vtable().RegisterCodePackageChangeHandler,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) UnregisterCodePackageChangeHandler(
	callbackHandle int64,
) (err error) {
	hr, err1 := callStub96862646(
		v.vtable().UnregisterCodePackageChangeHandler,
		1,
		unsafe.Pointer(v),
		callbackHandle,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) RegisterConfigurationPackageChangeHandler(
	callback *comFabricConfigurationPackageChangeHandler,
) (callbackHandle int64, err error) {
	var p_1 int64
	defer func() {
		callbackHandle = p_1
	}()
	hr, err1 := callStub3899200196(
		v.vtable().RegisterConfigurationPackageChangeHandler,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) UnregisterConfigurationPackageChangeHandler(
	callbackHandle int64,
) (err error) {
	hr, err1 := callStub96862646(
		v.vtable().UnregisterConfigurationPackageChangeHandler,
		1,
		unsafe.Pointer(v),
		callbackHandle,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) RegisterDataPackageChangeHandler(
	callback *comFabricDataPackageChangeHandler,
) (callbackHandle int64, err error) {
	var p_1 int64
	defer func() {
		callbackHandle = p_1
	}()
	hr, err1 := callStub1038946022(
		v.vtable().RegisterDataPackageChangeHandler,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext) UnregisterDataPackageChangeHandler(
	callbackHandle int64,
) (err error) {
	hr, err1 := callStub96862646(
		v.vtable().UnregisterDataPackageChangeHandler,
		1,
		unsafe.Pointer(v),
		callbackHandle,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricCodePackageActivationContext2 struct {
	comFabricCodePackageActivationContext
}

type comFabricCodePackageActivationContext2Vtbl struct {
	comFabricCodePackageActivationContextVtbl
	get_ApplicationName       uintptr
	get_ApplicationTypeName   uintptr
	GetServiceManifestName    uintptr
	GetServiceManifestVersion uintptr
}

func (v *comFabricCodePackageActivationContext2) vtable() *comFabricCodePackageActivationContext2Vtbl {
	return (*comFabricCodePackageActivationContext2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackageActivationContext2) GetApplicationName() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ApplicationName,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricCodePackageActivationContext2) GetApplicationTypeName() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ApplicationTypeName,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricCodePackageActivationContext2) GetServiceManifestName() (serviceManifestName *comFabricStringResult, err error) {
	var p_0 *comFabricStringResult
	defer func() {
		serviceManifestName = p_0
	}()
	hr, err1 := callStub1659701457(
		v.vtable().GetServiceManifestName,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext2) GetServiceManifestVersion() (serviceManifestVersion *comFabricStringResult, err error) {
	var p_0 *comFabricStringResult
	defer func() {
		serviceManifestVersion = p_0
	}()
	hr, err1 := callStub1659701457(
		v.vtable().GetServiceManifestVersion,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricCodePackageActivationContext3 struct {
	comFabricCodePackageActivationContext2
}

type comFabricCodePackageActivationContext3Vtbl struct {
	comFabricCodePackageActivationContext2Vtbl
	ReportApplicationHealth            uintptr
	ReportDeployedApplicationHealth    uintptr
	ReportDeployedServicePackageHealth uintptr
}

func (v *comFabricCodePackageActivationContext3) vtable() *comFabricCodePackageActivationContext3Vtbl {
	return (*comFabricCodePackageActivationContext3Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackageActivationContext3) ReportApplicationHealth(
	healthInfo *FabricHealthInformation,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	hr, err1 := callStub2782464874(
		v.vtable().ReportApplicationHealth,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext3) ReportDeployedApplicationHealth(
	healthInfo *FabricHealthInformation,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	hr, err1 := callStub2782464874(
		v.vtable().ReportDeployedApplicationHealth,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext3) ReportDeployedServicePackageHealth(
	healthInfo *FabricHealthInformation,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	hr, err1 := callStub2782464874(
		v.vtable().ReportDeployedServicePackageHealth,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricCodePackageActivationContext4 struct {
	comFabricCodePackageActivationContext3
}

type comFabricCodePackageActivationContext4Vtbl struct {
	comFabricCodePackageActivationContext3Vtbl
	ReportApplicationHealth2            uintptr
	ReportDeployedApplicationHealth2    uintptr
	ReportDeployedServicePackageHealth2 uintptr
}

func (v *comFabricCodePackageActivationContext4) vtable() *comFabricCodePackageActivationContext4Vtbl {
	return (*comFabricCodePackageActivationContext4Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackageActivationContext4) ReportApplicationHealth2(
	healthInfo *FabricHealthInformation,
	sendOptions *FabricHealthReportSendOptions,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	var p_1 *innerFabricHealthReportSendOptions
	p_1 = sendOptions.toInnerStruct()
	hr, err1 := callStub959650155(
		v.vtable().ReportApplicationHealth2,
		2,
		unsafe.Pointer(v),
		p_0,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext4) ReportDeployedApplicationHealth2(
	healthInfo *FabricHealthInformation,
	sendOptions *FabricHealthReportSendOptions,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	var p_1 *innerFabricHealthReportSendOptions
	p_1 = sendOptions.toInnerStruct()
	hr, err1 := callStub959650155(
		v.vtable().ReportDeployedApplicationHealth2,
		2,
		unsafe.Pointer(v),
		p_0,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivationContext4) ReportDeployedServicePackageHealth2(
	healthInfo *FabricHealthInformation,
	sendOptions *FabricHealthReportSendOptions,
) (err error) {
	var p_0 *innerFabricHealthInformation
	p_0 = healthInfo.toInnerStruct()
	var p_1 *innerFabricHealthReportSendOptions
	p_1 = sendOptions.toInnerStruct()
	hr, err1 := callStub959650155(
		v.vtable().ReportDeployedServicePackageHealth2,
		2,
		unsafe.Pointer(v),
		p_0,
		p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricCodePackageActivationContext5 struct {
	comFabricCodePackageActivationContext4
}

type comFabricCodePackageActivationContext5Vtbl struct {
	comFabricCodePackageActivationContext4Vtbl
	get_ServiceListenAddress  uintptr
	get_ServicePublishAddress uintptr
}

func (v *comFabricCodePackageActivationContext5) vtable() *comFabricCodePackageActivationContext5Vtbl {
	return (*comFabricCodePackageActivationContext5Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackageActivationContext5) GetServiceListenAddress() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ServiceListenAddress,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricCodePackageActivationContext5) GetServicePublishAddress() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ServicePublishAddress,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}

type comFabricCodePackageActivationContext6 struct {
	comFabricCodePackageActivationContext5
}

type comFabricCodePackageActivationContext6Vtbl struct {
	comFabricCodePackageActivationContext5Vtbl
	GetDirectory uintptr
}

func (v *comFabricCodePackageActivationContext6) vtable() *comFabricCodePackageActivationContext6Vtbl {
	return (*comFabricCodePackageActivationContext6Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackageActivationContext6) GetDirectory(
	logicalDirectoryName string,
) (directoryPath *comFabricStringResult, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(logicalDirectoryName)
	var p_1 *comFabricStringResult
	defer func() {
		directoryPath = p_1
	}()
	hr, err1 := callStub2823424846(
		v.vtable().GetDirectory,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricCodePackage struct {
	ole.IUnknown
}

type comFabricCodePackageVtbl struct {
	ole.IUnknownVtbl
	get_Description uintptr
	get_Path        uintptr
}

func (v *comFabricCodePackage) vtable() *comFabricCodePackageVtbl {
	return (*comFabricCodePackageVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackage) GetDescription() (rt *FabricCodePackageDescription, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Description,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricCodePackageDescription)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}
func (v *comFabricCodePackage) GetPath() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Path,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}

type comFabricCodePackage2 struct {
	comFabricCodePackage
}

type comFabricCodePackage2Vtbl struct {
	comFabricCodePackageVtbl
	get_SetupEntryPointRunAsPolicy uintptr
	get_EntryPointRunAsPolicy      uintptr
}

func (v *comFabricCodePackage2) vtable() *comFabricCodePackage2Vtbl {
	return (*comFabricCodePackage2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackage2) GetSetupEntryPointRunAsPolicy() (rt *FabricRunasPolicyDescription, err error) {
	hr, err1 := callStub1(
		v.vtable().get_SetupEntryPointRunAsPolicy,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricRunasPolicyDescription)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}
func (v *comFabricCodePackage2) GetEntryPointRunAsPolicy() (rt *FabricRunasPolicyDescription, err error) {
	hr, err1 := callStub1(
		v.vtable().get_EntryPointRunAsPolicy,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricRunasPolicyDescription)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}

type comFabricConfigurationPackage struct {
	ole.IUnknown
}

type comFabricConfigurationPackageVtbl struct {
	ole.IUnknownVtbl
	get_Description uintptr
	get_Path        uintptr
	get_Settings    uintptr
	GetSection      uintptr
	GetValue        uintptr
	DecryptValue    uintptr
}

func (v *comFabricConfigurationPackage) vtable() *comFabricConfigurationPackageVtbl {
	return (*comFabricConfigurationPackageVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricConfigurationPackage) GetDescription() (rt *FabricConfigurationPackageDescription, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Description,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricConfigurationPackageDescription)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}
func (v *comFabricConfigurationPackage) GetPath() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Path,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}
func (v *comFabricConfigurationPackage) GetSettings() (rt *FabricConfigurationSettings, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Settings,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricConfigurationSettings)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}
func (v *comFabricConfigurationPackage) GetSection(
	sectionName string,
) (bufferedValue *FabricConfigurationSection, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(sectionName)
	var p_1 *innerFabricConfigurationSection
	defer func() {
		bufferedValue = p_1.toGoStruct()
	}()
	hr, err1 := callStub805965666(
		v.vtable().GetSection,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricConfigurationPackage) GetValue(
	sectionName string,
	parameterName string,
) (isEncrypted bool, bufferedValue string, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(sectionName)
	var p_1 *uint16
	p_1 = utf16PtrFromString(parameterName)
	var p_2 bool
	defer func() {
		isEncrypted = p_2
	}()
	var p_3 *uint16
	defer func() {
		bufferedValue = utf16PtrToString(p_3)
	}()
	hr, err1 := callStub2480277880(
		v.vtable().GetValue,
		4,
		unsafe.Pointer(v),
		p_0,
		p_1,
		&p_2,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricConfigurationPackage) DecryptValue(
	encryptedValue string,
) (decryptedValue *comFabricStringResult, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(encryptedValue)
	var p_1 *comFabricStringResult
	defer func() {
		decryptedValue = p_1
	}()
	hr, err1 := callStub2823424846(
		v.vtable().DecryptValue,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricConfigurationPackage2 struct {
	comFabricConfigurationPackage
}

type comFabricConfigurationPackage2Vtbl struct {
	comFabricConfigurationPackageVtbl
	GetValues uintptr
}

func (v *comFabricConfigurationPackage2) vtable() *comFabricConfigurationPackage2Vtbl {
	return (*comFabricConfigurationPackage2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricConfigurationPackage2) GetValues(
	sectionName string,
	parameterPrefix string,
) (bufferedValue []FabricConfigurationParameter, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(sectionName)
	var p_1 *uint16
	p_1 = utf16PtrFromString(parameterPrefix)
	var p_2 *innerFabricConfigurationParameterList
	defer func() {
		{
			innerlst := unsafe.Slice(p_2.Items, p_2.Count)

			for _, item := range innerlst {
				var tmpitem FabricConfigurationParameter

				tmpitem = *item.toGoStruct()

				bufferedValue = append(bufferedValue, tmpitem)
			}

		}
	}()
	hr, err1 := callStub358945863(
		v.vtable().GetValues,
		3,
		unsafe.Pointer(v),
		p_0,
		p_1,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricDataPackage struct {
	ole.IUnknown
}

type comFabricDataPackageVtbl struct {
	ole.IUnknownVtbl
	get_Description uintptr
	get_Path        uintptr
}

func (v *comFabricDataPackage) vtable() *comFabricDataPackageVtbl {
	return (*comFabricDataPackageVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricDataPackage) GetDescription() (rt *FabricDataPackageDescription, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Description,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricDataPackageDescription)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}
func (v *comFabricDataPackage) GetPath() (rt string, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Path,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*uint16)(unsafe.Pointer(hr))

	rt = utf16PtrToString(tmp)
	return
}

type comFabricCodePackageChangeHandler struct {
	ole.IUnknown
}

type comFabricCodePackageChangeHandlerVtbl struct {
	ole.IUnknownVtbl
	OnPackageAdded    uintptr
	OnPackageRemoved  uintptr
	OnPackageModified uintptr
}

func (v *comFabricCodePackageChangeHandler) vtable() *comFabricCodePackageChangeHandlerVtbl {
	return (*comFabricCodePackageChangeHandlerVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackageChangeHandler) OnPackageAdded(
	source *comFabricCodePackageActivationContext,
	codePackage *comFabricCodePackage,
) (rt interface{}, err error) {
	hr, err1 := callStub3022460626(
		v.vtable().OnPackageAdded,
		2,
		unsafe.Pointer(v),
		source,
		codePackage,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}
func (v *comFabricCodePackageChangeHandler) OnPackageRemoved(
	source *comFabricCodePackageActivationContext,
	codePackage *comFabricCodePackage,
) (rt interface{}, err error) {
	hr, err1 := callStub3022460626(
		v.vtable().OnPackageRemoved,
		2,
		unsafe.Pointer(v),
		source,
		codePackage,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}
func (v *comFabricCodePackageChangeHandler) OnPackageModified(
	source *comFabricCodePackageActivationContext,
	previousCodePackage *comFabricCodePackage,
	codePackage *comFabricCodePackage,
) (rt interface{}, err error) {
	hr, err1 := callStub36708053(
		v.vtable().OnPackageModified,
		3,
		unsafe.Pointer(v),
		source,
		previousCodePackage,
		codePackage,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}

type comFabricConfigurationPackageChangeHandler struct {
	ole.IUnknown
}

type comFabricConfigurationPackageChangeHandlerVtbl struct {
	ole.IUnknownVtbl
	OnPackageAdded    uintptr
	OnPackageRemoved  uintptr
	OnPackageModified uintptr
}

func (v *comFabricConfigurationPackageChangeHandler) vtable() *comFabricConfigurationPackageChangeHandlerVtbl {
	return (*comFabricConfigurationPackageChangeHandlerVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricConfigurationPackageChangeHandler) OnPackageAdded(
	source *comFabricCodePackageActivationContext,
	configPackage *comFabricConfigurationPackage,
) (rt interface{}, err error) {
	hr, err1 := callStub2551388847(
		v.vtable().OnPackageAdded,
		2,
		unsafe.Pointer(v),
		source,
		configPackage,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}
func (v *comFabricConfigurationPackageChangeHandler) OnPackageRemoved(
	source *comFabricCodePackageActivationContext,
	configPackage *comFabricConfigurationPackage,
) (rt interface{}, err error) {
	hr, err1 := callStub2551388847(
		v.vtable().OnPackageRemoved,
		2,
		unsafe.Pointer(v),
		source,
		configPackage,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}
func (v *comFabricConfigurationPackageChangeHandler) OnPackageModified(
	source *comFabricCodePackageActivationContext,
	previousConfigPackage *comFabricConfigurationPackage,
	configPackage *comFabricConfigurationPackage,
) (rt interface{}, err error) {
	hr, err1 := callStub2313561743(
		v.vtable().OnPackageModified,
		3,
		unsafe.Pointer(v),
		source,
		previousConfigPackage,
		configPackage,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}

type comFabricDataPackageChangeHandler struct {
	ole.IUnknown
}

type comFabricDataPackageChangeHandlerVtbl struct {
	ole.IUnknownVtbl
	OnPackageAdded    uintptr
	OnPackageRemoved  uintptr
	OnPackageModified uintptr
}

func (v *comFabricDataPackageChangeHandler) vtable() *comFabricDataPackageChangeHandlerVtbl {
	return (*comFabricDataPackageChangeHandlerVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricDataPackageChangeHandler) OnPackageAdded(
	source *comFabricCodePackageActivationContext,
	dataPackage *comFabricDataPackage,
) (rt interface{}, err error) {
	hr, err1 := callStub3021346513(
		v.vtable().OnPackageAdded,
		2,
		unsafe.Pointer(v),
		source,
		dataPackage,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}
func (v *comFabricDataPackageChangeHandler) OnPackageRemoved(
	source *comFabricCodePackageActivationContext,
	dataPackage *comFabricDataPackage,
) (rt interface{}, err error) {
	hr, err1 := callStub3021346513(
		v.vtable().OnPackageRemoved,
		2,
		unsafe.Pointer(v),
		source,
		dataPackage,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}
func (v *comFabricDataPackageChangeHandler) OnPackageModified(
	source *comFabricCodePackageActivationContext,
	previousDataPackage *comFabricDataPackage,
	dataPackage *comFabricDataPackage,
) (rt interface{}, err error) {
	hr, err1 := callStub33038035(
		v.vtable().OnPackageModified,
		3,
		unsafe.Pointer(v),
		source,
		previousDataPackage,
		dataPackage,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}

type comFabricProcessExitHandler struct {
	ole.IUnknown
}

type comFabricProcessExitHandlerVtbl struct {
	ole.IUnknownVtbl
	FabricProcessExited uintptr
}

func (v *comFabricProcessExitHandler) vtable() *comFabricProcessExitHandlerVtbl {
	return (*comFabricProcessExitHandlerVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricProcessExitHandler) FabricProcessExited() (rt interface{}, err error) {
	hr, err1 := callStub1(
		v.vtable().FabricProcessExited,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}

type comFabricTransactionBase struct {
	ole.IUnknown
}

type comFabricTransactionBaseVtbl struct {
	ole.IUnknownVtbl
	get_Id             uintptr
	get_IsolationLevel uintptr
}

func (v *comFabricTransactionBase) vtable() *comFabricTransactionBaseVtbl {
	return (*comFabricTransactionBaseVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricTransactionBase) GetId() (rt *ole.GUID, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Id,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*ole.GUID)(unsafe.Pointer(hr))

	rt = tmp
	return
}
func (v *comFabricTransactionBase) GetIsolationLevel() (rt FabricTransactionIsolationLevel, err error) {
	hr, err1 := callStub1(
		v.vtable().get_IsolationLevel,
		0,
		unsafe.Pointer(v),
	)
	_ = err1
	rt = FabricTransactionIsolationLevel(hr)
	return
}

type comFabricTransaction struct {
	comFabricTransactionBase
}

type comFabricTransactionVtbl struct {
	comFabricTransactionBaseVtbl
	BeginCommit uintptr
	EndCommit   uintptr
	Rollback    uintptr
}

func (v *comFabricTransaction) vtable() *comFabricTransactionVtbl {
	return (*comFabricTransactionVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricTransaction) beginCommit(
	timeoutMilliseconds uint32,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_2 *comFabricAsyncOperationContext
	defer func() {
		context = p_2
	}()
	hr, err1 := callStub3426753368(
		v.vtable().BeginCommit,
		3,
		unsafe.Pointer(v),
		timeoutMilliseconds,
		callback,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricTransaction) endCommit(
	context *comFabricAsyncOperationContext,
) (commitSequenceNumber int64, err error) {
	var p_1 int64
	defer func() {
		commitSequenceNumber = p_1
	}()
	hr, err1 := callStub452726352(
		v.vtable().EndCommit,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricTransaction) Rollback() (rt interface{}, err error) {
	hr, err1 := callStub1(
		v.vtable().Rollback,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}

type comFabricKeyValueStoreReplica struct {
	comFabricStatefulServiceReplica
}

type comFabricKeyValueStoreReplicaVtbl struct {
	comFabricStatefulServiceReplicaVtbl
	GetCurrentEpoch          uintptr
	UpdateReplicatorSettings uintptr
	CreateTransaction        uintptr
	Add                      uintptr
	Remove                   uintptr
	Update                   uintptr
	Get                      uintptr
	GetMetadata              uintptr
	Contains                 uintptr
	Enumerate                uintptr
	EnumerateByKey           uintptr
	EnumerateMetadata        uintptr
	EnumerateMetadataByKey   uintptr
}

func (v *comFabricKeyValueStoreReplica) vtable() *comFabricKeyValueStoreReplicaVtbl {
	return (*comFabricKeyValueStoreReplicaVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreReplica) GetCurrentEpoch() (currentEpoch FabricEpoch, err error) {
	var p_0 innerFabricEpoch
	defer func() {
		currentEpoch = *p_0.toGoStruct()
	}()
	hr, err1 := callStub955057789(
		v.vtable().GetCurrentEpoch,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) UpdateReplicatorSettings(
	replicatorSettings *FabricReplicatorSettings,
) (err error) {
	var p_0 *innerFabricReplicatorSettings
	p_0 = replicatorSettings.toInnerStruct()
	hr, err1 := callStub3011972084(
		v.vtable().UpdateReplicatorSettings,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) CreateTransaction() (transaction *comFabricTransaction, err error) {
	var p_0 *comFabricTransaction
	defer func() {
		transaction = p_0
	}()
	hr, err1 := callStub1510606945(
		v.vtable().CreateTransaction,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) Add(
	transaction *comFabricTransactionBase,
	key string,
	valueSizeInBytes int32,
	value *byte,
) (err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	hr, err1 := callStub2106724373(
		v.vtable().Add,
		4,
		unsafe.Pointer(v),
		transaction,
		p_1,
		valueSizeInBytes,
		value,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) Remove(
	transaction *comFabricTransactionBase,
	key string,
	checkSequenceNumber int64,
) (err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	hr, err1 := callStub591269392(
		v.vtable().Remove,
		3,
		unsafe.Pointer(v),
		transaction,
		p_1,
		checkSequenceNumber,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) Update(
	transaction *comFabricTransactionBase,
	key string,
	valueSizeInBytes int32,
	value *byte,
	checkSequenceNumber int64,
) (err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	hr, err1 := callStub3839431158(
		v.vtable().Update,
		5,
		unsafe.Pointer(v),
		transaction,
		p_1,
		valueSizeInBytes,
		value,
		checkSequenceNumber,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) Get(
	transaction *comFabricTransactionBase,
	key string,
) (result *comFabricKeyValueStoreItemResult, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	var p_2 *comFabricKeyValueStoreItemResult
	defer func() {
		result = p_2
	}()
	hr, err1 := callStub1583356278(
		v.vtable().Get,
		3,
		unsafe.Pointer(v),
		transaction,
		p_1,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) GetMetadata(
	transaction *comFabricTransactionBase,
	key string,
) (result *comFabricKeyValueStoreItemMetadataResult, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	var p_2 *comFabricKeyValueStoreItemMetadataResult
	defer func() {
		result = p_2
	}()
	hr, err1 := callStub917576855(
		v.vtable().GetMetadata,
		3,
		unsafe.Pointer(v),
		transaction,
		p_1,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) Contains(
	transaction *comFabricTransactionBase,
	key string,
) (result bool, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	var p_2 bool
	defer func() {
		result = p_2
	}()
	hr, err1 := callStub577637937(
		v.vtable().Contains,
		3,
		unsafe.Pointer(v),
		transaction,
		p_1,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) Enumerate(
	transaction *comFabricTransactionBase,
) (result *comFabricKeyValueStoreItemEnumerator, err error) {
	var p_1 *comFabricKeyValueStoreItemEnumerator
	defer func() {
		result = p_1
	}()
	hr, err1 := callStub239278236(
		v.vtable().Enumerate,
		2,
		unsafe.Pointer(v),
		transaction,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) EnumerateByKey(
	transaction *comFabricTransactionBase,
	keyPrefix string,
) (result *comFabricKeyValueStoreItemEnumerator, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(keyPrefix)
	var p_2 *comFabricKeyValueStoreItemEnumerator
	defer func() {
		result = p_2
	}()
	hr, err1 := callStub3353025305(
		v.vtable().EnumerateByKey,
		3,
		unsafe.Pointer(v),
		transaction,
		p_1,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) EnumerateMetadata(
	transaction *comFabricTransactionBase,
) (result *comFabricKeyValueStoreItemMetadataEnumerator, err error) {
	var p_1 *comFabricKeyValueStoreItemMetadataEnumerator
	defer func() {
		result = p_1
	}()
	hr, err1 := callStub3743488957(
		v.vtable().EnumerateMetadata,
		2,
		unsafe.Pointer(v),
		transaction,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica) EnumerateMetadataByKey(
	transaction *comFabricTransactionBase,
	keyPrefix string,
) (result *comFabricKeyValueStoreItemMetadataEnumerator, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(keyPrefix)
	var p_2 *comFabricKeyValueStoreItemMetadataEnumerator
	defer func() {
		result = p_2
	}()
	hr, err1 := callStub2897223226(
		v.vtable().EnumerateMetadataByKey,
		3,
		unsafe.Pointer(v),
		transaction,
		p_1,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreReplica2 struct {
	comFabricKeyValueStoreReplica
}

type comFabricKeyValueStoreReplica2Vtbl struct {
	comFabricKeyValueStoreReplicaVtbl
	Backup             uintptr
	Restore            uintptr
	CreateTransaction2 uintptr
}

func (v *comFabricKeyValueStoreReplica2) vtable() *comFabricKeyValueStoreReplica2Vtbl {
	return (*comFabricKeyValueStoreReplica2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreReplica2) Backup(
	backupDirectory string,
) (err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(backupDirectory)
	hr, err1 := callStub161743442(
		v.vtable().Backup,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica2) Restore(
	backupDirectory string,
) (err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(backupDirectory)
	hr, err1 := callStub161743442(
		v.vtable().Restore,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica2) CreateTransaction2(
	settings *FabricKeyValueStoreTransactionSettings,
) (transaction *comFabricTransaction, err error) {
	var p_0 *innerFabricKeyValueStoreTransactionSettings
	p_0 = settings.toInnerStruct()
	var p_1 *comFabricTransaction
	defer func() {
		transaction = p_1
	}()
	hr, err1 := callStub1956780580(
		v.vtable().CreateTransaction2,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreReplica3 struct {
	comFabricKeyValueStoreReplica2
}

type comFabricKeyValueStoreReplica3Vtbl struct {
	comFabricKeyValueStoreReplica2Vtbl
	BeginBackup uintptr
	EndBackup   uintptr
}

func (v *comFabricKeyValueStoreReplica3) vtable() *comFabricKeyValueStoreReplica3Vtbl {
	return (*comFabricKeyValueStoreReplica3Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreReplica3) beginBackup(
	backupDirectory string,
	backupOption FabricStoreBackupOption,
	postBackupHandler *comFabricStorePostBackupHandler,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(backupDirectory)
	var p_4 *comFabricAsyncOperationContext
	defer func() {
		context = p_4
	}()
	hr, err1 := callStub1992503670(
		v.vtable().BeginBackup,
		5,
		unsafe.Pointer(v),
		p_0,
		backupOption,
		postBackupHandler,
		callback,
		&p_4,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica3) endBackup(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndBackup,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreReplica4 struct {
	comFabricKeyValueStoreReplica3
}

type comFabricKeyValueStoreReplica4Vtbl struct {
	comFabricKeyValueStoreReplica3Vtbl
	BeginRestore uintptr
	EndRestore   uintptr
}

func (v *comFabricKeyValueStoreReplica4) vtable() *comFabricKeyValueStoreReplica4Vtbl {
	return (*comFabricKeyValueStoreReplica4Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreReplica4) beginRestore(
	backupDirectory string,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(backupDirectory)
	var p_2 *comFabricAsyncOperationContext
	defer func() {
		context = p_2
	}()
	hr, err1 := callStub3636403076(
		v.vtable().BeginRestore,
		3,
		unsafe.Pointer(v),
		p_0,
		callback,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica4) endRestore(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndRestore,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreReplica5 struct {
	comFabricKeyValueStoreReplica4
}

type comFabricKeyValueStoreReplica5Vtbl struct {
	comFabricKeyValueStoreReplica4Vtbl
	TryAdd                  uintptr
	TryRemove               uintptr
	TryUpdate               uintptr
	TryGet                  uintptr
	TryGetMetadata          uintptr
	EnumerateByKey2         uintptr
	EnumerateMetadataByKey2 uintptr
}

func (v *comFabricKeyValueStoreReplica5) vtable() *comFabricKeyValueStoreReplica5Vtbl {
	return (*comFabricKeyValueStoreReplica5Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreReplica5) TryAdd(
	transaction *comFabricTransactionBase,
	key string,
	valueSizeInBytes int32,
	value *byte,
) (added bool, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	var p_4 bool
	defer func() {
		added = p_4
	}()
	hr, err1 := callStub3825799703(
		v.vtable().TryAdd,
		5,
		unsafe.Pointer(v),
		transaction,
		p_1,
		valueSizeInBytes,
		value,
		&p_4,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica5) TryRemove(
	transaction *comFabricTransactionBase,
	key string,
	checkSequenceNumber int64,
) (exists bool, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	var p_3 bool
	defer func() {
		exists = p_3
	}()
	hr, err1 := callStub2107052050(
		v.vtable().TryRemove,
		4,
		unsafe.Pointer(v),
		transaction,
		p_1,
		checkSequenceNumber,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica5) TryUpdate(
	transaction *comFabricTransactionBase,
	key string,
	valueSizeInBytes int32,
	value *byte,
	checkSequenceNumber int64,
) (exists bool, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	var p_5 bool
	defer func() {
		exists = p_5
	}()
	hr, err1 := callStub1453659128(
		v.vtable().TryUpdate,
		6,
		unsafe.Pointer(v),
		transaction,
		p_1,
		valueSizeInBytes,
		value,
		checkSequenceNumber,
		&p_5,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica5) TryGet(
	transaction *comFabricTransactionBase,
	key string,
) (result *comFabricKeyValueStoreItemResult, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	var p_2 *comFabricKeyValueStoreItemResult
	defer func() {
		result = p_2
	}()
	hr, err1 := callStub1583356278(
		v.vtable().TryGet,
		3,
		unsafe.Pointer(v),
		transaction,
		p_1,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica5) TryGetMetadata(
	transaction *comFabricTransactionBase,
	key string,
) (result *comFabricKeyValueStoreItemMetadataResult, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(key)
	var p_2 *comFabricKeyValueStoreItemMetadataResult
	defer func() {
		result = p_2
	}()
	hr, err1 := callStub917576855(
		v.vtable().TryGetMetadata,
		3,
		unsafe.Pointer(v),
		transaction,
		p_1,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica5) EnumerateByKey2(
	transaction *comFabricTransactionBase,
	keyPrefix string,
	strictPrefix bool,
) (result *comFabricKeyValueStoreItemEnumerator, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(keyPrefix)
	var p_3 *comFabricKeyValueStoreItemEnumerator
	defer func() {
		result = p_3
	}()
	hr, err1 := callStub1371020529(
		v.vtable().EnumerateByKey2,
		4,
		unsafe.Pointer(v),
		transaction,
		p_1,
		strictPrefix,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreReplica5) EnumerateMetadataByKey2(
	transaction *comFabricTransactionBase,
	keyPrefix string,
	strictPrefix bool,
) (result *comFabricKeyValueStoreItemMetadataEnumerator, err error) {
	var p_1 *uint16
	p_1 = utf16PtrFromString(keyPrefix)
	var p_3 *comFabricKeyValueStoreItemMetadataEnumerator
	defer func() {
		result = p_3
	}()
	hr, err1 := callStub1162682386(
		v.vtable().EnumerateMetadataByKey2,
		4,
		unsafe.Pointer(v),
		transaction,
		p_1,
		strictPrefix,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreReplica6 struct {
	comFabricKeyValueStoreReplica5
}

type comFabricKeyValueStoreReplica6Vtbl struct {
	comFabricKeyValueStoreReplica5Vtbl
	BeginRestore2 uintptr
}

func (v *comFabricKeyValueStoreReplica6) vtable() *comFabricKeyValueStoreReplica6Vtbl {
	return (*comFabricKeyValueStoreReplica6Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreReplica6) beginRestore2(
	backupDirectory string,
	settings *FabricKeyValueStoreRestoreSettings,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(backupDirectory)
	var p_1 *innerFabricKeyValueStoreRestoreSettings
	p_1 = settings.toInnerStruct()
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub2786667429(
		v.vtable().BeginRestore2,
		4,
		unsafe.Pointer(v),
		p_0,
		p_1,
		callback,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreEnumerator struct {
	ole.IUnknown
}

type comFabricKeyValueStoreEnumeratorVtbl struct {
	ole.IUnknownVtbl
	EnumerateByKey         uintptr
	EnumerateMetadataByKey uintptr
}

func (v *comFabricKeyValueStoreEnumerator) vtable() *comFabricKeyValueStoreEnumeratorVtbl {
	return (*comFabricKeyValueStoreEnumeratorVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreEnumerator) EnumerateByKey(
	keyPrefix string,
) (result *comFabricKeyValueStoreItemEnumerator, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(keyPrefix)
	var p_1 *comFabricKeyValueStoreItemEnumerator
	defer func() {
		result = p_1
	}()
	hr, err1 := callStub2104103228(
		v.vtable().EnumerateByKey,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreEnumerator) EnumerateMetadataByKey(
	keyPrefix string,
) (result *comFabricKeyValueStoreItemMetadataEnumerator, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(keyPrefix)
	var p_1 *comFabricKeyValueStoreItemMetadataEnumerator
	defer func() {
		result = p_1
	}()
	hr, err1 := callStub324473949(
		v.vtable().EnumerateMetadataByKey,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreEnumerator2 struct {
	comFabricKeyValueStoreEnumerator
}

type comFabricKeyValueStoreEnumerator2Vtbl struct {
	comFabricKeyValueStoreEnumeratorVtbl
	EnumerateByKey2         uintptr
	EnumerateMetadataByKey2 uintptr
}

func (v *comFabricKeyValueStoreEnumerator2) vtable() *comFabricKeyValueStoreEnumerator2Vtbl {
	return (*comFabricKeyValueStoreEnumerator2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreEnumerator2) EnumerateByKey2(
	keyPrefix string,
	strictPrefix bool,
) (result *comFabricKeyValueStoreItemEnumerator, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(keyPrefix)
	var p_2 *comFabricKeyValueStoreItemEnumerator
	defer func() {
		result = p_2
	}()
	hr, err1 := callStub3588690708(
		v.vtable().EnumerateByKey2,
		3,
		unsafe.Pointer(v),
		p_0,
		strictPrefix,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreEnumerator2) EnumerateMetadataByKey2(
	keyPrefix string,
	strictPrefix bool,
) (result *comFabricKeyValueStoreItemMetadataEnumerator, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(keyPrefix)
	var p_2 *comFabricKeyValueStoreItemMetadataEnumerator
	defer func() {
		result = p_2
	}()
	hr, err1 := callStub2056525365(
		v.vtable().EnumerateMetadataByKey2,
		3,
		unsafe.Pointer(v),
		p_0,
		strictPrefix,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreItemEnumerator struct {
	ole.IUnknown
}

type comFabricKeyValueStoreItemEnumeratorVtbl struct {
	ole.IUnknownVtbl
	MoveNext    uintptr
	get_Current uintptr
}

func (v *comFabricKeyValueStoreItemEnumerator) vtable() *comFabricKeyValueStoreItemEnumeratorVtbl {
	return (*comFabricKeyValueStoreItemEnumeratorVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreItemEnumerator) MoveNext() (err error) {
	hr, err1 := callStub1(
		v.vtable().MoveNext,
		0,
		unsafe.Pointer(v),
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreItemEnumerator) GetCurrent() (rt *comFabricKeyValueStoreItemResult, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Current,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*comFabricKeyValueStoreItemResult)(unsafe.Pointer(hr))

	rt = tmp
	return
}

type comFabricKeyValueStoreItemMetadataEnumerator struct {
	ole.IUnknown
}

type comFabricKeyValueStoreItemMetadataEnumeratorVtbl struct {
	ole.IUnknownVtbl
	MoveNext    uintptr
	get_Current uintptr
}

func (v *comFabricKeyValueStoreItemMetadataEnumerator) vtable() *comFabricKeyValueStoreItemMetadataEnumeratorVtbl {
	return (*comFabricKeyValueStoreItemMetadataEnumeratorVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreItemMetadataEnumerator) MoveNext() (err error) {
	hr, err1 := callStub1(
		v.vtable().MoveNext,
		0,
		unsafe.Pointer(v),
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreItemMetadataEnumerator) GetCurrent() (rt *comFabricKeyValueStoreItemMetadataResult, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Current,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*comFabricKeyValueStoreItemMetadataResult)(unsafe.Pointer(hr))

	rt = tmp
	return
}

type comFabricKeyValueStoreNotificationEnumerator struct {
	ole.IUnknown
}

type comFabricKeyValueStoreNotificationEnumeratorVtbl struct {
	ole.IUnknownVtbl
	MoveNext    uintptr
	get_Current uintptr
	Reset       uintptr
}

func (v *comFabricKeyValueStoreNotificationEnumerator) vtable() *comFabricKeyValueStoreNotificationEnumeratorVtbl {
	return (*comFabricKeyValueStoreNotificationEnumeratorVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreNotificationEnumerator) MoveNext() (err error) {
	hr, err1 := callStub1(
		v.vtable().MoveNext,
		0,
		unsafe.Pointer(v),
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricKeyValueStoreNotificationEnumerator) GetCurrent() (rt *comFabricKeyValueStoreNotification, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Current,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*comFabricKeyValueStoreNotification)(unsafe.Pointer(hr))

	rt = tmp
	return
}
func (v *comFabricKeyValueStoreNotificationEnumerator) Reset() (rt interface{}, err error) {
	hr, err1 := callStub1(
		v.vtable().Reset,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}

type comFabricKeyValueStoreItemEnumerator2 struct {
	comFabricKeyValueStoreItemEnumerator
}

type comFabricKeyValueStoreItemEnumerator2Vtbl struct {
	comFabricKeyValueStoreItemEnumeratorVtbl
	TryMoveNext uintptr
}

func (v *comFabricKeyValueStoreItemEnumerator2) vtable() *comFabricKeyValueStoreItemEnumerator2Vtbl {
	return (*comFabricKeyValueStoreItemEnumerator2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreItemEnumerator2) TryMoveNext() (success bool, err error) {
	var p_0 bool
	defer func() {
		success = p_0
	}()
	hr, err1 := callStub83231191(
		v.vtable().TryMoveNext,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreItemMetadataEnumerator2 struct {
	comFabricKeyValueStoreItemMetadataEnumerator
}

type comFabricKeyValueStoreItemMetadataEnumerator2Vtbl struct {
	comFabricKeyValueStoreItemMetadataEnumeratorVtbl
	TryMoveNext uintptr
}

func (v *comFabricKeyValueStoreItemMetadataEnumerator2) vtable() *comFabricKeyValueStoreItemMetadataEnumerator2Vtbl {
	return (*comFabricKeyValueStoreItemMetadataEnumerator2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreItemMetadataEnumerator2) TryMoveNext() (success bool, err error) {
	var p_0 bool
	defer func() {
		success = p_0
	}()
	hr, err1 := callStub83231191(
		v.vtable().TryMoveNext,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreNotificationEnumerator2 struct {
	comFabricKeyValueStoreNotificationEnumerator
}

type comFabricKeyValueStoreNotificationEnumerator2Vtbl struct {
	comFabricKeyValueStoreNotificationEnumeratorVtbl
	TryMoveNext uintptr
}

func (v *comFabricKeyValueStoreNotificationEnumerator2) vtable() *comFabricKeyValueStoreNotificationEnumerator2Vtbl {
	return (*comFabricKeyValueStoreNotificationEnumerator2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreNotificationEnumerator2) TryMoveNext() (success bool, err error) {
	var p_0 bool
	defer func() {
		success = p_0
	}()
	hr, err1 := callStub83231191(
		v.vtable().TryMoveNext,
		1,
		unsafe.Pointer(v),
		&p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricKeyValueStoreItemResult struct {
	ole.IUnknown
}

type comFabricKeyValueStoreItemResultVtbl struct {
	ole.IUnknownVtbl
	get_Item uintptr
}

func (v *comFabricKeyValueStoreItemResult) vtable() *comFabricKeyValueStoreItemResultVtbl {
	return (*comFabricKeyValueStoreItemResultVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreItemResult) GetItem() (rt *FabricKeyValueStoreItem, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Item,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricKeyValueStoreItem)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}

type comFabricKeyValueStoreItemMetadataResult struct {
	ole.IUnknown
}

type comFabricKeyValueStoreItemMetadataResultVtbl struct {
	ole.IUnknownVtbl
	get_Metadata uintptr
}

func (v *comFabricKeyValueStoreItemMetadataResult) vtable() *comFabricKeyValueStoreItemMetadataResultVtbl {
	return (*comFabricKeyValueStoreItemMetadataResultVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreItemMetadataResult) GetMetadata() (rt *FabricKeyValueStoreItemMetadata, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Metadata,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricKeyValueStoreItemMetadata)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}

type comFabricKeyValueStoreNotification struct {
	comFabricKeyValueStoreItemResult
}

type comFabricKeyValueStoreNotificationVtbl struct {
	comFabricKeyValueStoreItemResultVtbl
	IsDelete uintptr
}

func (v *comFabricKeyValueStoreNotification) vtable() *comFabricKeyValueStoreNotificationVtbl {
	return (*comFabricKeyValueStoreNotificationVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricKeyValueStoreNotification) IsDelete() (rt bool, err error) {
	hr, err1 := callStub1(
		v.vtable().IsDelete,
		0,
		unsafe.Pointer(v),
	)
	_ = err1
	rt = hr != 0
	return
}

type comFabricStoreEventHandler struct {
	ole.IUnknown
}

type comFabricStoreEventHandlerVtbl struct {
	ole.IUnknownVtbl
	OnDataLoss uintptr
}

func (v *comFabricStoreEventHandler) vtable() *comFabricStoreEventHandlerVtbl {
	return (*comFabricStoreEventHandlerVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStoreEventHandler) OnDataLoss() (rt interface{}, err error) {
	hr, err1 := callStub1(
		v.vtable().OnDataLoss,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}

type comFabricStoreEventHandler2 struct {
	comFabricStoreEventHandler
}

type comFabricStoreEventHandler2Vtbl struct {
	comFabricStoreEventHandlerVtbl
	BeginOnDataLoss uintptr
	EndOnDataLoss   uintptr
}

func (v *comFabricStoreEventHandler2) vtable() *comFabricStoreEventHandler2Vtbl {
	return (*comFabricStoreEventHandler2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStoreEventHandler2) beginOnDataLoss(
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_1 *comFabricAsyncOperationContext
	defer func() {
		context = p_1
	}()
	hr, err1 := callStub719329543(
		v.vtable().BeginOnDataLoss,
		2,
		unsafe.Pointer(v),
		callback,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStoreEventHandler2) endOnDataLoss(
	context *comFabricAsyncOperationContext,
) (isStateChanged bool, err error) {
	var p_1 bool
	defer func() {
		isStateChanged = p_1
	}()
	hr, err1 := callStub213847623(
		v.vtable().EndOnDataLoss,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricStorePostBackupHandler struct {
	ole.IUnknown
}

type comFabricStorePostBackupHandlerVtbl struct {
	ole.IUnknownVtbl
	BeginPostBackup uintptr
	EndPostBackup   uintptr
}

func (v *comFabricStorePostBackupHandler) vtable() *comFabricStorePostBackupHandlerVtbl {
	return (*comFabricStorePostBackupHandlerVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricStorePostBackupHandler) beginPostBackup(
	info *FabricStoreBackupInfo,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *innerFabricStoreBackupInfo
	p_0 = info.toInnerStruct()
	var p_2 *comFabricAsyncOperationContext
	defer func() {
		context = p_2
	}()
	hr, err1 := callStub2053317551(
		v.vtable().BeginPostBackup,
		3,
		unsafe.Pointer(v),
		p_0,
		callback,
		&p_2,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricStorePostBackupHandler) endPostBackup(
	context *comFabricAsyncOperationContext,
) (status bool, err error) {
	var p_1 bool
	defer func() {
		status = p_1
	}()
	hr, err1 := callStub213847623(
		v.vtable().EndPostBackup,
		2,
		unsafe.Pointer(v),
		context,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricSecondaryEventHandler struct {
	ole.IUnknown
}

type comFabricSecondaryEventHandlerVtbl struct {
	ole.IUnknownVtbl
	OnCopyComplete         uintptr
	OnReplicationOperation uintptr
}

func (v *comFabricSecondaryEventHandler) vtable() *comFabricSecondaryEventHandlerVtbl {
	return (*comFabricSecondaryEventHandlerVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricSecondaryEventHandler) OnCopyComplete(
	enumerator *comFabricKeyValueStoreEnumerator,
) (err error) {
	hr, err1 := callStub3583053062(
		v.vtable().OnCopyComplete,
		1,
		unsafe.Pointer(v),
		enumerator,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricSecondaryEventHandler) OnReplicationOperation(
	enumerator *comFabricKeyValueStoreNotificationEnumerator,
) (err error) {
	hr, err1 := callStub2425950701(
		v.vtable().OnReplicationOperation,
		1,
		unsafe.Pointer(v),
		enumerator,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricNodeContextResult struct {
	ole.IUnknown
}

type comFabricNodeContextResultVtbl struct {
	ole.IUnknownVtbl
	get_NodeContext uintptr
}

func (v *comFabricNodeContextResult) vtable() *comFabricNodeContextResultVtbl {
	return (*comFabricNodeContextResultVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricNodeContextResult) GetNodeContext() (rt *FabricNodeContext, err error) {
	hr, err1 := callStub1(
		v.vtable().get_NodeContext,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricNodeContext)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}

type comFabricNodeContextResult2 struct {
	comFabricNodeContextResult
}

type comFabricNodeContextResult2Vtbl struct {
	comFabricNodeContextResultVtbl
	GetDirectory uintptr
}

func (v *comFabricNodeContextResult2) vtable() *comFabricNodeContextResult2Vtbl {
	return (*comFabricNodeContextResult2Vtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricNodeContextResult2) GetDirectory(
	logicalDirectoryName string,
) (directoryPath *comFabricStringResult, err error) {
	var p_0 *uint16
	p_0 = utf16PtrFromString(logicalDirectoryName)
	var p_1 *comFabricStringResult
	defer func() {
		directoryPath = p_1
	}()
	hr, err1 := callStub2823424846(
		v.vtable().GetDirectory,
		2,
		unsafe.Pointer(v),
		p_0,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricReplicatorSettingsResult struct {
	ole.IUnknown
}

type comFabricReplicatorSettingsResultVtbl struct {
	ole.IUnknownVtbl
	get_ReplicatorSettings uintptr
}

func (v *comFabricReplicatorSettingsResult) vtable() *comFabricReplicatorSettingsResultVtbl {
	return (*comFabricReplicatorSettingsResultVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricReplicatorSettingsResult) GetReplicatorSettings() (rt *FabricReplicatorSettings, err error) {
	hr, err1 := callStub1(
		v.vtable().get_ReplicatorSettings,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricReplicatorSettings)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}

type comFabricEseLocalStoreSettingsResult struct {
	ole.IUnknown
}

type comFabricEseLocalStoreSettingsResultVtbl struct {
	ole.IUnknownVtbl
	get_Settings uintptr
}

func (v *comFabricEseLocalStoreSettingsResult) vtable() *comFabricEseLocalStoreSettingsResultVtbl {
	return (*comFabricEseLocalStoreSettingsResultVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricEseLocalStoreSettingsResult) GetSettings() (rt *FabricEseLocalStoreSettings, err error) {
	hr, err1 := callStub1(
		v.vtable().get_Settings,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricEseLocalStoreSettings)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}

type comFabricSecurityCredentialsResult struct {
	ole.IUnknown
}

type comFabricSecurityCredentialsResultVtbl struct {
	ole.IUnknownVtbl
	get_SecurityCredentials uintptr
}

func (v *comFabricSecurityCredentialsResult) vtable() *comFabricSecurityCredentialsResultVtbl {
	return (*comFabricSecurityCredentialsResultVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricSecurityCredentialsResult) GetSecurityCredentials() (rt *FabricSecurityCredentials, err error) {
	hr, err1 := callStub1(
		v.vtable().get_SecurityCredentials,
		0,
		unsafe.Pointer(v),
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (*innerFabricSecurityCredentials)(unsafe.Pointer(hr))

	rt = tmp.toGoStruct()
	return
}

type comFabricCodePackageActivator struct {
	ole.IUnknown
}

type comFabricCodePackageActivatorVtbl struct {
	ole.IUnknownVtbl
	BeginActivateCodePackage          uintptr
	EndActivateCodePackage            uintptr
	BeginDeactivateCodePackage        uintptr
	EndDeactivateCodePackage          uintptr
	AbortCodePackage                  uintptr
	RegisterCodePackageEventHandler   uintptr
	UnregisterCodePackageEventHandler uintptr
}

func (v *comFabricCodePackageActivator) vtable() *comFabricCodePackageActivatorVtbl {
	return (*comFabricCodePackageActivatorVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackageActivator) beginActivateCodePackage(
	codePackageNames []string,
	environment map[string]string,
	timeoutMilliseconds uint32,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *innerFabricStringList
	lst_1 := &innerFabricStringList{}
	{

		var tmp []*uint16

		for _, item := range codePackageNames {
			var tmpitem *uint16

			tmpitem = utf16PtrFromString(item)

			tmp = append(tmp, tmpitem)
		}

		lst_1.Count = uint32(len(tmp))
		if len(tmp) > 0 {
			lst_1.Items = &tmp[0]
		}

	}
	p_0 = lst_1
	var p_1 *innerFabricStringMap
	{
		mapobj := &innerFabricStringMap{}

		var tmp []innerFabricApplicationParameter

		for k, v := range environment {
			kv := innerFabricApplicationParameter{}

			kv.Name = utf16PtrFromString(k)
			kv.Value = utf16PtrFromString(v)

			tmp = append(tmp, kv)
		}

		mapobj.Count = uint32(len(tmp))
		if len(tmp) > 0 {
			mapobj.Items = &tmp[0]
		}

		p_1 = mapobj
	}
	var p_4 *comFabricAsyncOperationContext
	defer func() {
		context = p_4
	}()
	hr, err1 := callStub644099186(
		v.vtable().BeginActivateCodePackage,
		5,
		unsafe.Pointer(v),
		p_0,
		p_1,
		timeoutMilliseconds,
		callback,
		&p_4,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivator) endActivateCodePackage(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndActivateCodePackage,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivator) beginDeactivateCodePackage(
	codePackageNames []string,
	timeoutMilliseconds uint32,
	callback *comFabricAsyncOperationCallback,
) (context *comFabricAsyncOperationContext, err error) {
	var p_0 *innerFabricStringList
	lst_3 := &innerFabricStringList{}
	{

		var tmp []*uint16

		for _, item := range codePackageNames {
			var tmpitem *uint16

			tmpitem = utf16PtrFromString(item)

			tmp = append(tmp, tmpitem)
		}

		lst_3.Count = uint32(len(tmp))
		if len(tmp) > 0 {
			lst_3.Items = &tmp[0]
		}

	}
	p_0 = lst_3
	var p_3 *comFabricAsyncOperationContext
	defer func() {
		context = p_3
	}()
	hr, err1 := callStub2933269540(
		v.vtable().BeginDeactivateCodePackage,
		4,
		unsafe.Pointer(v),
		p_0,
		timeoutMilliseconds,
		callback,
		&p_3,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivator) endDeactivateCodePackage(
	context *comFabricAsyncOperationContext,
) (err error) {
	hr, err1 := callStub3172535365(
		v.vtable().EndDeactivateCodePackage,
		1,
		unsafe.Pointer(v),
		context,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivator) AbortCodePackage(
	codePackageNames []string,
) (err error) {
	var p_0 *innerFabricStringList
	lst_4 := &innerFabricStringList{}
	{

		var tmp []*uint16

		for _, item := range codePackageNames {
			var tmpitem *uint16

			tmpitem = utf16PtrFromString(item)

			tmp = append(tmp, tmpitem)
		}

		lst_4.Count = uint32(len(tmp))
		if len(tmp) > 0 {
			lst_4.Items = &tmp[0]
		}

	}
	p_0 = lst_4
	hr, err1 := callStub1614547105(
		v.vtable().AbortCodePackage,
		1,
		unsafe.Pointer(v),
		p_0,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivator) RegisterCodePackageEventHandler(
	eventHandler *comFabricCodePackageEventHandler,
) (callbackHandle uint64, err error) {
	var p_1 uint64
	defer func() {
		callbackHandle = p_1
	}()
	hr, err1 := callStub1078136600(
		v.vtable().RegisterCodePackageEventHandler,
		2,
		unsafe.Pointer(v),
		eventHandler,
		&p_1,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}
func (v *comFabricCodePackageActivator) UnregisterCodePackageEventHandler(
	callbackHandle uint64,
) (err error) {
	hr, err1 := callStub142934571(
		v.vtable().UnregisterCodePackageEventHandler,
		1,
		unsafe.Pointer(v),
		callbackHandle,
	)
	if hr != 0 {
		err = errno(hr, err1)
		return
	}
	return
}

type comFabricCodePackageEventHandler struct {
	ole.IUnknown
}

type comFabricCodePackageEventHandlerVtbl struct {
	ole.IUnknownVtbl
	OnCodePackageEvent uintptr
}

func (v *comFabricCodePackageEventHandler) vtable() *comFabricCodePackageEventHandlerVtbl {
	return (*comFabricCodePackageEventHandlerVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *comFabricCodePackageEventHandler) OnCodePackageEvent(
	source *comFabricCodePackageActivator,
	eventDesc *FabricCodePackageEventDescription,
) (rt interface{}, err error) {
	var p_1 *innerFabricCodePackageEventDescription
	p_1 = eventDesc.toInnerStruct()
	hr, err1 := callStub2819431147(
		v.vtable().OnCodePackageEvent,
		2,
		unsafe.Pointer(v),
		source,
		p_1,
	)
	if hr == 0 {
		err = err1
		return
	}

	tmp := (unsafe.Pointer)(unsafe.Pointer(hr))

	rt = fromUnsafePointer(tmp)
	return
}